Jianwei Wang | 109eee2 | 2015-08-19 22:19:49 -0400 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2015 Freescale Semiconductor, Inc. |
| 3 | * |
| 4 | * Freescale DCU drm device driver |
| 5 | * |
| 6 | * This program is free software; you can redistribute it and/or modify |
| 7 | * it under the terms of the GNU General Public License as published by |
| 8 | * the Free Software Foundation; either version 2 of the License, or |
| 9 | * (at your option) any later version. |
| 10 | */ |
| 11 | |
| 12 | #include <linux/clk.h> |
| 13 | #include <linux/clk-provider.h> |
| 14 | #include <linux/io.h> |
| 15 | #include <linux/mfd/syscon.h> |
| 16 | #include <linux/mm.h> |
| 17 | #include <linux/module.h> |
| 18 | #include <linux/of_platform.h> |
| 19 | #include <linux/platform_device.h> |
| 20 | #include <linux/pm.h> |
| 21 | #include <linux/pm_runtime.h> |
| 22 | #include <linux/regmap.h> |
| 23 | |
| 24 | #include <drm/drmP.h> |
| 25 | #include <drm/drm_crtc_helper.h> |
| 26 | #include <drm/drm_gem_cma_helper.h> |
| 27 | |
| 28 | #include "fsl_dcu_drm_crtc.h" |
| 29 | #include "fsl_dcu_drm_drv.h" |
Stefan Agner | fb127b7 | 2015-12-02 14:39:40 -0800 | [diff] [blame] | 30 | #include "fsl_tcon.h" |
Jianwei Wang | 109eee2 | 2015-08-19 22:19:49 -0400 | [diff] [blame] | 31 | |
Stefan Agner | efb8b49 | 2015-11-17 18:05:25 -0800 | [diff] [blame] | 32 | static bool fsl_dcu_drm_is_volatile_reg(struct device *dev, unsigned int reg) |
| 33 | { |
| 34 | if (reg == DCU_INT_STATUS || reg == DCU_UPDATE_MODE) |
| 35 | return true; |
| 36 | |
| 37 | return false; |
| 38 | } |
| 39 | |
Jianwei Wang | 109eee2 | 2015-08-19 22:19:49 -0400 | [diff] [blame] | 40 | static const struct regmap_config fsl_dcu_regmap_config = { |
| 41 | .reg_bits = 32, |
| 42 | .reg_stride = 4, |
| 43 | .val_bits = 32, |
| 44 | .cache_type = REGCACHE_RBTREE, |
Stefan Agner | efb8b49 | 2015-11-17 18:05:25 -0800 | [diff] [blame] | 45 | |
| 46 | .volatile_reg = fsl_dcu_drm_is_volatile_reg, |
Jianwei Wang | 109eee2 | 2015-08-19 22:19:49 -0400 | [diff] [blame] | 47 | }; |
| 48 | |
| 49 | static int fsl_dcu_drm_irq_init(struct drm_device *dev) |
| 50 | { |
| 51 | struct fsl_dcu_drm_device *fsl_dev = dev->dev_private; |
Jianwei Wang | 109eee2 | 2015-08-19 22:19:49 -0400 | [diff] [blame] | 52 | int ret; |
| 53 | |
| 54 | ret = drm_irq_install(dev, fsl_dev->irq); |
| 55 | if (ret < 0) |
| 56 | dev_err(dev->dev, "failed to install IRQ handler\n"); |
| 57 | |
Stefan Agner | e291d29 | 2015-11-18 16:50:55 -0800 | [diff] [blame] | 58 | regmap_write(fsl_dev->regmap, DCU_INT_STATUS, 0); |
Stefan Agner | 638c93f | 2015-11-18 17:27:04 -0800 | [diff] [blame] | 59 | regmap_write(fsl_dev->regmap, DCU_INT_MASK, ~0); |
Stefan Agner | e291d29 | 2015-11-18 16:50:55 -0800 | [diff] [blame] | 60 | regmap_write(fsl_dev->regmap, DCU_UPDATE_MODE, |
| 61 | DCU_UPDATE_MODE_READREG); |
Jianwei Wang | 109eee2 | 2015-08-19 22:19:49 -0400 | [diff] [blame] | 62 | |
| 63 | return ret; |
| 64 | } |
| 65 | |
Stefan Agner | b617966 | 2016-04-13 00:14:18 -0700 | [diff] [blame^] | 66 | static int fsl_dcu_load(struct drm_device *dev, unsigned long flags) |
Jianwei Wang | 109eee2 | 2015-08-19 22:19:49 -0400 | [diff] [blame] | 67 | { |
Stefan Agner | b617966 | 2016-04-13 00:14:18 -0700 | [diff] [blame^] | 68 | struct fsl_dcu_drm_device *fsl_dev = dev->dev_private; |
Jianwei Wang | 109eee2 | 2015-08-19 22:19:49 -0400 | [diff] [blame] | 69 | int ret; |
| 70 | |
| 71 | ret = fsl_dcu_drm_modeset_init(fsl_dev); |
| 72 | if (ret < 0) { |
Stefan Agner | b617966 | 2016-04-13 00:14:18 -0700 | [diff] [blame^] | 73 | dev_err(dev->dev, "failed to initialize mode setting\n"); |
Jianwei Wang | 109eee2 | 2015-08-19 22:19:49 -0400 | [diff] [blame] | 74 | return ret; |
| 75 | } |
| 76 | |
Stefan Agner | b617966 | 2016-04-13 00:14:18 -0700 | [diff] [blame^] | 77 | ret = drm_vblank_init(dev, dev->mode_config.num_crtc); |
Jianwei Wang | 109eee2 | 2015-08-19 22:19:49 -0400 | [diff] [blame] | 78 | if (ret < 0) { |
Stefan Agner | b617966 | 2016-04-13 00:14:18 -0700 | [diff] [blame^] | 79 | dev_err(dev->dev, "failed to initialize vblank\n"); |
Jianwei Wang | 109eee2 | 2015-08-19 22:19:49 -0400 | [diff] [blame] | 80 | goto done; |
| 81 | } |
Stefan Agner | b617966 | 2016-04-13 00:14:18 -0700 | [diff] [blame^] | 82 | dev->vblank_disable_allowed = true; |
Jianwei Wang | 109eee2 | 2015-08-19 22:19:49 -0400 | [diff] [blame] | 83 | |
Stefan Agner | b617966 | 2016-04-13 00:14:18 -0700 | [diff] [blame^] | 84 | ret = fsl_dcu_drm_irq_init(dev); |
Jianwei Wang | 109eee2 | 2015-08-19 22:19:49 -0400 | [diff] [blame] | 85 | if (ret < 0) |
| 86 | goto done; |
Stefan Agner | b617966 | 2016-04-13 00:14:18 -0700 | [diff] [blame^] | 87 | dev->irq_enabled = true; |
Jianwei Wang | 109eee2 | 2015-08-19 22:19:49 -0400 | [diff] [blame] | 88 | |
Stefan Agner | b617966 | 2016-04-13 00:14:18 -0700 | [diff] [blame^] | 89 | fsl_dcu_fbdev_init(dev); |
Jianwei Wang | 109eee2 | 2015-08-19 22:19:49 -0400 | [diff] [blame] | 90 | |
| 91 | return 0; |
| 92 | done: |
Stefan Agner | b617966 | 2016-04-13 00:14:18 -0700 | [diff] [blame^] | 93 | drm_mode_config_cleanup(dev); |
| 94 | drm_vblank_cleanup(dev); |
| 95 | drm_irq_uninstall(dev); |
| 96 | dev->dev_private = NULL; |
Jianwei Wang | 109eee2 | 2015-08-19 22:19:49 -0400 | [diff] [blame] | 97 | |
| 98 | return ret; |
| 99 | } |
| 100 | |
| 101 | static int fsl_dcu_unload(struct drm_device *dev) |
| 102 | { |
| 103 | drm_mode_config_cleanup(dev); |
| 104 | drm_vblank_cleanup(dev); |
| 105 | drm_irq_uninstall(dev); |
| 106 | |
| 107 | dev->dev_private = NULL; |
| 108 | |
| 109 | return 0; |
| 110 | } |
| 111 | |
Jianwei Wang | 109eee2 | 2015-08-19 22:19:49 -0400 | [diff] [blame] | 112 | static irqreturn_t fsl_dcu_drm_irq(int irq, void *arg) |
| 113 | { |
| 114 | struct drm_device *dev = arg; |
| 115 | struct fsl_dcu_drm_device *fsl_dev = dev->dev_private; |
| 116 | unsigned int int_status; |
| 117 | int ret; |
| 118 | |
| 119 | ret = regmap_read(fsl_dev->regmap, DCU_INT_STATUS, &int_status); |
Stefan Agner | e291d29 | 2015-11-18 16:50:55 -0800 | [diff] [blame] | 120 | if (ret) { |
| 121 | dev_err(dev->dev, "read DCU_INT_STATUS failed\n"); |
| 122 | return IRQ_NONE; |
| 123 | } |
| 124 | |
Jianwei Wang | 109eee2 | 2015-08-19 22:19:49 -0400 | [diff] [blame] | 125 | if (int_status & DCU_INT_STATUS_VBLANK) |
| 126 | drm_handle_vblank(dev, 0); |
| 127 | |
Stefan Agner | e291d29 | 2015-11-18 16:50:55 -0800 | [diff] [blame] | 128 | regmap_write(fsl_dev->regmap, DCU_INT_STATUS, int_status); |
| 129 | regmap_write(fsl_dev->regmap, DCU_UPDATE_MODE, |
| 130 | DCU_UPDATE_MODE_READREG); |
Jianwei Wang | 109eee2 | 2015-08-19 22:19:49 -0400 | [diff] [blame] | 131 | |
| 132 | return IRQ_HANDLED; |
| 133 | } |
| 134 | |
Thierry Reding | 88e7271 | 2015-09-24 18:35:31 +0200 | [diff] [blame] | 135 | static int fsl_dcu_drm_enable_vblank(struct drm_device *dev, unsigned int pipe) |
Jianwei Wang | 109eee2 | 2015-08-19 22:19:49 -0400 | [diff] [blame] | 136 | { |
| 137 | struct fsl_dcu_drm_device *fsl_dev = dev->dev_private; |
| 138 | unsigned int value; |
Jianwei Wang | 109eee2 | 2015-08-19 22:19:49 -0400 | [diff] [blame] | 139 | |
Stefan Agner | e291d29 | 2015-11-18 16:50:55 -0800 | [diff] [blame] | 140 | regmap_read(fsl_dev->regmap, DCU_INT_MASK, &value); |
Jianwei Wang | 109eee2 | 2015-08-19 22:19:49 -0400 | [diff] [blame] | 141 | value &= ~DCU_INT_MASK_VBLANK; |
Stefan Agner | e291d29 | 2015-11-18 16:50:55 -0800 | [diff] [blame] | 142 | regmap_write(fsl_dev->regmap, DCU_INT_MASK, value); |
| 143 | |
Jianwei Wang | 109eee2 | 2015-08-19 22:19:49 -0400 | [diff] [blame] | 144 | return 0; |
| 145 | } |
| 146 | |
Thierry Reding | 88e7271 | 2015-09-24 18:35:31 +0200 | [diff] [blame] | 147 | static void fsl_dcu_drm_disable_vblank(struct drm_device *dev, |
| 148 | unsigned int pipe) |
Jianwei Wang | 109eee2 | 2015-08-19 22:19:49 -0400 | [diff] [blame] | 149 | { |
| 150 | struct fsl_dcu_drm_device *fsl_dev = dev->dev_private; |
| 151 | unsigned int value; |
Jianwei Wang | 109eee2 | 2015-08-19 22:19:49 -0400 | [diff] [blame] | 152 | |
Stefan Agner | e291d29 | 2015-11-18 16:50:55 -0800 | [diff] [blame] | 153 | regmap_read(fsl_dev->regmap, DCU_INT_MASK, &value); |
Jianwei Wang | 109eee2 | 2015-08-19 22:19:49 -0400 | [diff] [blame] | 154 | value |= DCU_INT_MASK_VBLANK; |
Stefan Agner | e291d29 | 2015-11-18 16:50:55 -0800 | [diff] [blame] | 155 | regmap_write(fsl_dev->regmap, DCU_INT_MASK, value); |
Jianwei Wang | 109eee2 | 2015-08-19 22:19:49 -0400 | [diff] [blame] | 156 | } |
| 157 | |
| 158 | static const struct file_operations fsl_dcu_drm_fops = { |
| 159 | .owner = THIS_MODULE, |
| 160 | .open = drm_open, |
| 161 | .release = drm_release, |
| 162 | .unlocked_ioctl = drm_ioctl, |
| 163 | #ifdef CONFIG_COMPAT |
| 164 | .compat_ioctl = drm_compat_ioctl, |
| 165 | #endif |
| 166 | .poll = drm_poll, |
| 167 | .read = drm_read, |
| 168 | .llseek = no_llseek, |
| 169 | .mmap = drm_gem_cma_mmap, |
| 170 | }; |
| 171 | |
| 172 | static struct drm_driver fsl_dcu_drm_driver = { |
| 173 | .driver_features = DRIVER_HAVE_IRQ | DRIVER_GEM | DRIVER_MODESET |
| 174 | | DRIVER_PRIME | DRIVER_ATOMIC, |
| 175 | .load = fsl_dcu_load, |
| 176 | .unload = fsl_dcu_unload, |
Jianwei Wang | 109eee2 | 2015-08-19 22:19:49 -0400 | [diff] [blame] | 177 | .irq_handler = fsl_dcu_drm_irq, |
Ville Syrjälä | b44f840 | 2015-09-30 16:46:48 +0300 | [diff] [blame] | 178 | .get_vblank_counter = drm_vblank_no_hw_counter, |
Jianwei Wang | 109eee2 | 2015-08-19 22:19:49 -0400 | [diff] [blame] | 179 | .enable_vblank = fsl_dcu_drm_enable_vblank, |
| 180 | .disable_vblank = fsl_dcu_drm_disable_vblank, |
| 181 | .gem_free_object = drm_gem_cma_free_object, |
| 182 | .gem_vm_ops = &drm_gem_cma_vm_ops, |
| 183 | .prime_handle_to_fd = drm_gem_prime_handle_to_fd, |
| 184 | .prime_fd_to_handle = drm_gem_prime_fd_to_handle, |
| 185 | .gem_prime_import = drm_gem_prime_import, |
| 186 | .gem_prime_export = drm_gem_prime_export, |
| 187 | .gem_prime_get_sg_table = drm_gem_cma_prime_get_sg_table, |
| 188 | .gem_prime_import_sg_table = drm_gem_cma_prime_import_sg_table, |
| 189 | .gem_prime_vmap = drm_gem_cma_prime_vmap, |
| 190 | .gem_prime_vunmap = drm_gem_cma_prime_vunmap, |
| 191 | .gem_prime_mmap = drm_gem_cma_prime_mmap, |
| 192 | .dumb_create = drm_gem_cma_dumb_create, |
| 193 | .dumb_map_offset = drm_gem_cma_dumb_map_offset, |
| 194 | .dumb_destroy = drm_gem_dumb_destroy, |
| 195 | .fops = &fsl_dcu_drm_fops, |
| 196 | .name = "fsl-dcu-drm", |
| 197 | .desc = "Freescale DCU DRM", |
| 198 | .date = "20150213", |
| 199 | .major = 1, |
| 200 | .minor = 0, |
| 201 | }; |
| 202 | |
| 203 | #ifdef CONFIG_PM_SLEEP |
| 204 | static int fsl_dcu_drm_pm_suspend(struct device *dev) |
| 205 | { |
| 206 | struct fsl_dcu_drm_device *fsl_dev = dev_get_drvdata(dev); |
| 207 | |
| 208 | if (!fsl_dev) |
| 209 | return 0; |
| 210 | |
| 211 | drm_kms_helper_poll_disable(fsl_dev->drm); |
| 212 | regcache_cache_only(fsl_dev->regmap, true); |
| 213 | regcache_mark_dirty(fsl_dev->regmap); |
| 214 | clk_disable(fsl_dev->clk); |
| 215 | clk_unprepare(fsl_dev->clk); |
| 216 | |
| 217 | return 0; |
| 218 | } |
| 219 | |
| 220 | static int fsl_dcu_drm_pm_resume(struct device *dev) |
| 221 | { |
| 222 | struct fsl_dcu_drm_device *fsl_dev = dev_get_drvdata(dev); |
| 223 | int ret; |
| 224 | |
| 225 | if (!fsl_dev) |
| 226 | return 0; |
| 227 | |
| 228 | ret = clk_enable(fsl_dev->clk); |
| 229 | if (ret < 0) { |
| 230 | dev_err(dev, "failed to enable dcu clk\n"); |
| 231 | clk_unprepare(fsl_dev->clk); |
| 232 | return ret; |
| 233 | } |
| 234 | ret = clk_prepare(fsl_dev->clk); |
| 235 | if (ret < 0) { |
| 236 | dev_err(dev, "failed to prepare dcu clk\n"); |
| 237 | return ret; |
| 238 | } |
| 239 | |
| 240 | drm_kms_helper_poll_enable(fsl_dev->drm); |
| 241 | regcache_cache_only(fsl_dev->regmap, false); |
| 242 | regcache_sync(fsl_dev->regmap); |
| 243 | |
| 244 | return 0; |
| 245 | } |
| 246 | #endif |
| 247 | |
| 248 | static const struct dev_pm_ops fsl_dcu_drm_pm_ops = { |
| 249 | SET_SYSTEM_SLEEP_PM_OPS(fsl_dcu_drm_pm_suspend, fsl_dcu_drm_pm_resume) |
| 250 | }; |
| 251 | |
| 252 | static const struct fsl_dcu_soc_data fsl_dcu_ls1021a_data = { |
| 253 | .name = "ls1021a", |
| 254 | .total_layer = 16, |
| 255 | .max_layer = 4, |
| 256 | }; |
| 257 | |
| 258 | static const struct fsl_dcu_soc_data fsl_dcu_vf610_data = { |
| 259 | .name = "vf610", |
| 260 | .total_layer = 64, |
| 261 | .max_layer = 6, |
| 262 | }; |
| 263 | |
| 264 | static const struct of_device_id fsl_dcu_of_match[] = { |
| 265 | { |
| 266 | .compatible = "fsl,ls1021a-dcu", |
| 267 | .data = &fsl_dcu_ls1021a_data, |
| 268 | }, { |
| 269 | .compatible = "fsl,vf610-dcu", |
| 270 | .data = &fsl_dcu_vf610_data, |
| 271 | }, { |
| 272 | }, |
| 273 | }; |
| 274 | MODULE_DEVICE_TABLE(of, fsl_dcu_of_match); |
| 275 | |
| 276 | static int fsl_dcu_drm_probe(struct platform_device *pdev) |
| 277 | { |
| 278 | struct fsl_dcu_drm_device *fsl_dev; |
| 279 | struct drm_device *drm; |
| 280 | struct device *dev = &pdev->dev; |
| 281 | struct resource *res; |
| 282 | void __iomem *base; |
| 283 | struct drm_driver *driver = &fsl_dcu_drm_driver; |
Stefan Agner | 2d70144 | 2016-03-22 18:06:08 -0700 | [diff] [blame] | 284 | struct clk *pix_clk_in; |
| 285 | char pix_clk_name[32]; |
| 286 | const char *pix_clk_in_name; |
Jianwei Wang | 109eee2 | 2015-08-19 22:19:49 -0400 | [diff] [blame] | 287 | const struct of_device_id *id; |
| 288 | int ret; |
| 289 | |
| 290 | fsl_dev = devm_kzalloc(dev, sizeof(*fsl_dev), GFP_KERNEL); |
| 291 | if (!fsl_dev) |
| 292 | return -ENOMEM; |
| 293 | |
Stefan Agner | 73fa303 | 2016-03-22 15:13:05 -0700 | [diff] [blame] | 294 | id = of_match_node(fsl_dcu_of_match, pdev->dev.of_node); |
| 295 | if (!id) |
| 296 | return -ENODEV; |
| 297 | fsl_dev->soc = id->data; |
| 298 | |
Jianwei Wang | 109eee2 | 2015-08-19 22:19:49 -0400 | [diff] [blame] | 299 | res = platform_get_resource(pdev, IORESOURCE_MEM, 0); |
| 300 | if (!res) { |
| 301 | dev_err(dev, "could not get memory IO resource\n"); |
| 302 | return -ENODEV; |
| 303 | } |
| 304 | |
| 305 | base = devm_ioremap_resource(dev, res); |
| 306 | if (IS_ERR(base)) { |
| 307 | ret = PTR_ERR(base); |
| 308 | return ret; |
| 309 | } |
| 310 | |
| 311 | fsl_dev->irq = platform_get_irq(pdev, 0); |
| 312 | if (fsl_dev->irq < 0) { |
| 313 | dev_err(dev, "failed to get irq\n"); |
| 314 | return -ENXIO; |
| 315 | } |
| 316 | |
Jianwei Wang | 109eee2 | 2015-08-19 22:19:49 -0400 | [diff] [blame] | 317 | fsl_dev->regmap = devm_regmap_init_mmio(dev, base, |
| 318 | &fsl_dcu_regmap_config); |
| 319 | if (IS_ERR(fsl_dev->regmap)) { |
| 320 | dev_err(dev, "regmap init failed\n"); |
| 321 | return PTR_ERR(fsl_dev->regmap); |
| 322 | } |
| 323 | |
Stefan Agner | 73fa303 | 2016-03-22 15:13:05 -0700 | [diff] [blame] | 324 | fsl_dev->clk = devm_clk_get(dev, "dcu"); |
| 325 | if (IS_ERR(fsl_dev->clk)) { |
| 326 | dev_err(dev, "failed to get dcu clock\n"); |
| 327 | return PTR_ERR(fsl_dev->clk); |
| 328 | } |
| 329 | ret = clk_prepare_enable(fsl_dev->clk); |
| 330 | if (ret < 0) { |
| 331 | dev_err(dev, "failed to enable dcu clk\n"); |
| 332 | return ret; |
| 333 | } |
Jianwei Wang | 109eee2 | 2015-08-19 22:19:49 -0400 | [diff] [blame] | 334 | |
Stefan Agner | 2d70144 | 2016-03-22 18:06:08 -0700 | [diff] [blame] | 335 | pix_clk_in = devm_clk_get(dev, "pix"); |
| 336 | if (IS_ERR(pix_clk_in)) { |
| 337 | /* legancy binding, use dcu clock as pixel clock input */ |
| 338 | pix_clk_in = fsl_dev->clk; |
Stefan Agner | f93500f | 2016-03-22 15:45:29 -0700 | [diff] [blame] | 339 | } |
Stefan Agner | 2d70144 | 2016-03-22 18:06:08 -0700 | [diff] [blame] | 340 | |
| 341 | pix_clk_in_name = __clk_get_name(pix_clk_in); |
| 342 | snprintf(pix_clk_name, sizeof(pix_clk_name), "%s_pix", pix_clk_in_name); |
| 343 | fsl_dev->pix_clk = clk_register_divider(dev, pix_clk_name, |
| 344 | pix_clk_in_name, 0, base + DCU_DIV_RATIO, |
| 345 | 0, 8, CLK_DIVIDER_ROUND_CLOSEST, NULL); |
| 346 | if (IS_ERR(fsl_dev->pix_clk)) { |
| 347 | dev_err(dev, "failed to register pix clk\n"); |
| 348 | ret = PTR_ERR(fsl_dev->pix_clk); |
| 349 | goto disable_clk; |
| 350 | } |
| 351 | |
Stefan Agner | f93500f | 2016-03-22 15:45:29 -0700 | [diff] [blame] | 352 | ret = clk_prepare_enable(fsl_dev->pix_clk); |
| 353 | if (ret < 0) { |
| 354 | dev_err(dev, "failed to enable pix clk\n"); |
Stefan Agner | 2d70144 | 2016-03-22 18:06:08 -0700 | [diff] [blame] | 355 | goto unregister_pix_clk; |
Stefan Agner | f93500f | 2016-03-22 15:45:29 -0700 | [diff] [blame] | 356 | } |
| 357 | |
Stefan Agner | fb127b7 | 2015-12-02 14:39:40 -0800 | [diff] [blame] | 358 | fsl_dev->tcon = fsl_tcon_init(dev); |
| 359 | |
Jianwei Wang | 109eee2 | 2015-08-19 22:19:49 -0400 | [diff] [blame] | 360 | drm = drm_dev_alloc(driver, dev); |
Stefan Agner | 73fa303 | 2016-03-22 15:13:05 -0700 | [diff] [blame] | 361 | if (!drm) { |
| 362 | ret = -ENOMEM; |
Stefan Agner | f93500f | 2016-03-22 15:45:29 -0700 | [diff] [blame] | 363 | goto disable_pix_clk; |
Stefan Agner | 73fa303 | 2016-03-22 15:13:05 -0700 | [diff] [blame] | 364 | } |
Jianwei Wang | 109eee2 | 2015-08-19 22:19:49 -0400 | [diff] [blame] | 365 | |
| 366 | fsl_dev->dev = dev; |
| 367 | fsl_dev->drm = drm; |
| 368 | fsl_dev->np = dev->of_node; |
| 369 | drm->dev_private = fsl_dev; |
| 370 | dev_set_drvdata(dev, fsl_dev); |
Jianwei Wang | 109eee2 | 2015-08-19 22:19:49 -0400 | [diff] [blame] | 371 | |
| 372 | ret = drm_dev_register(drm, 0); |
| 373 | if (ret < 0) |
| 374 | goto unref; |
| 375 | |
| 376 | DRM_INFO("Initialized %s %d.%d.%d %s on minor %d\n", driver->name, |
| 377 | driver->major, driver->minor, driver->patchlevel, |
| 378 | driver->date, drm->primary->index); |
| 379 | |
| 380 | return 0; |
| 381 | |
| 382 | unref: |
| 383 | drm_dev_unref(drm); |
Stefan Agner | f93500f | 2016-03-22 15:45:29 -0700 | [diff] [blame] | 384 | disable_pix_clk: |
| 385 | clk_disable_unprepare(fsl_dev->pix_clk); |
Stefan Agner | 2d70144 | 2016-03-22 18:06:08 -0700 | [diff] [blame] | 386 | unregister_pix_clk: |
| 387 | clk_unregister(fsl_dev->pix_clk); |
Stefan Agner | 73fa303 | 2016-03-22 15:13:05 -0700 | [diff] [blame] | 388 | disable_clk: |
| 389 | clk_disable_unprepare(fsl_dev->clk); |
Jianwei Wang | 109eee2 | 2015-08-19 22:19:49 -0400 | [diff] [blame] | 390 | return ret; |
| 391 | } |
| 392 | |
| 393 | static int fsl_dcu_drm_remove(struct platform_device *pdev) |
| 394 | { |
| 395 | struct fsl_dcu_drm_device *fsl_dev = platform_get_drvdata(pdev); |
| 396 | |
Stefan Agner | 73fa303 | 2016-03-22 15:13:05 -0700 | [diff] [blame] | 397 | clk_disable_unprepare(fsl_dev->clk); |
Stefan Agner | f93500f | 2016-03-22 15:45:29 -0700 | [diff] [blame] | 398 | clk_disable_unprepare(fsl_dev->pix_clk); |
Stefan Agner | 2d70144 | 2016-03-22 18:06:08 -0700 | [diff] [blame] | 399 | clk_unregister(fsl_dev->pix_clk); |
Jianwei Wang | 109eee2 | 2015-08-19 22:19:49 -0400 | [diff] [blame] | 400 | drm_put_dev(fsl_dev->drm); |
| 401 | |
| 402 | return 0; |
| 403 | } |
| 404 | |
| 405 | static struct platform_driver fsl_dcu_drm_platform_driver = { |
| 406 | .probe = fsl_dcu_drm_probe, |
| 407 | .remove = fsl_dcu_drm_remove, |
| 408 | .driver = { |
| 409 | .name = "fsl-dcu", |
| 410 | .pm = &fsl_dcu_drm_pm_ops, |
| 411 | .of_match_table = fsl_dcu_of_match, |
| 412 | }, |
| 413 | }; |
| 414 | |
| 415 | module_platform_driver(fsl_dcu_drm_platform_driver); |
| 416 | |
| 417 | MODULE_DESCRIPTION("Freescale DCU DRM Driver"); |
| 418 | MODULE_LICENSE("GPL"); |