Russell King | 96f60e3 | 2012-08-15 13:59:49 +0100 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2012 Russell King |
| 3 | * |
| 4 | * This program is free software; you can redistribute it and/or modify |
| 5 | * it under the terms of the GNU General Public License version 2 as |
| 6 | * published by the Free Software Foundation. |
| 7 | */ |
| 8 | #include <linux/clk.h> |
Russell King | 0101fd0 | 2014-02-04 11:57:06 +0000 | [diff] [blame] | 9 | #include <linux/component.h> |
Russell King | 96f60e3 | 2012-08-15 13:59:49 +0100 | [diff] [blame] | 10 | #include <linux/module.h> |
Russell King | 0101fd0 | 2014-02-04 11:57:06 +0000 | [diff] [blame] | 11 | #include <linux/of_graph.h> |
Russell King | 96f60e3 | 2012-08-15 13:59:49 +0100 | [diff] [blame] | 12 | #include <drm/drmP.h> |
| 13 | #include <drm/drm_crtc_helper.h> |
| 14 | #include "armada_crtc.h" |
| 15 | #include "armada_drm.h" |
| 16 | #include "armada_gem.h" |
| 17 | #include "armada_hw.h" |
| 18 | #include <drm/armada_drm.h> |
| 19 | #include "armada_ioctlP.h" |
| 20 | |
| 21 | static void armada_drm_unref_work(struct work_struct *work) |
| 22 | { |
| 23 | struct armada_private *priv = |
| 24 | container_of(work, struct armada_private, fb_unref_work); |
| 25 | struct drm_framebuffer *fb; |
| 26 | |
| 27 | while (kfifo_get(&priv->fb_unref, &fb)) |
| 28 | drm_framebuffer_unreference(fb); |
| 29 | } |
| 30 | |
| 31 | /* Must be called with dev->event_lock held */ |
| 32 | void __armada_drm_queue_unref_work(struct drm_device *dev, |
| 33 | struct drm_framebuffer *fb) |
| 34 | { |
| 35 | struct armada_private *priv = dev->dev_private; |
| 36 | |
Russell King | d13c46c | 2014-03-03 14:49:51 +0000 | [diff] [blame] | 37 | WARN_ON(!kfifo_put(&priv->fb_unref, fb)); |
Russell King | 96f60e3 | 2012-08-15 13:59:49 +0100 | [diff] [blame] | 38 | schedule_work(&priv->fb_unref_work); |
| 39 | } |
| 40 | |
| 41 | void armada_drm_queue_unref_work(struct drm_device *dev, |
| 42 | struct drm_framebuffer *fb) |
| 43 | { |
| 44 | unsigned long flags; |
| 45 | |
| 46 | spin_lock_irqsave(&dev->event_lock, flags); |
| 47 | __armada_drm_queue_unref_work(dev, fb); |
| 48 | spin_unlock_irqrestore(&dev->event_lock, flags); |
| 49 | } |
| 50 | |
| 51 | static int armada_drm_load(struct drm_device *dev, unsigned long flags) |
| 52 | { |
Russell King | 96f60e3 | 2012-08-15 13:59:49 +0100 | [diff] [blame] | 53 | struct armada_private *priv; |
Russell King | 96f60e3 | 2012-08-15 13:59:49 +0100 | [diff] [blame] | 54 | struct resource *mem = NULL; |
Russell King | 0fb2970 | 2015-06-06 21:46:53 +0100 | [diff] [blame^] | 55 | int ret, n; |
Russell King | 96f60e3 | 2012-08-15 13:59:49 +0100 | [diff] [blame] | 56 | |
Russell King | 0fb2970 | 2015-06-06 21:46:53 +0100 | [diff] [blame^] | 57 | for (n = 0; ; n++) { |
Russell King | 96f60e3 | 2012-08-15 13:59:49 +0100 | [diff] [blame] | 58 | struct resource *r = platform_get_resource(dev->platformdev, |
| 59 | IORESOURCE_MEM, n); |
| 60 | if (!r) |
| 61 | break; |
| 62 | |
| 63 | /* Resources above 64K are graphics memory */ |
| 64 | if (resource_size(r) > SZ_64K) |
| 65 | mem = r; |
Russell King | 96f60e3 | 2012-08-15 13:59:49 +0100 | [diff] [blame] | 66 | else |
| 67 | return -EINVAL; |
| 68 | } |
| 69 | |
Russell King | d8c9608 | 2014-04-22 11:10:15 +0100 | [diff] [blame] | 70 | if (!mem) |
Russell King | 96f60e3 | 2012-08-15 13:59:49 +0100 | [diff] [blame] | 71 | return -ENXIO; |
| 72 | |
| 73 | if (!devm_request_mem_region(dev->dev, mem->start, |
| 74 | resource_size(mem), "armada-drm")) |
| 75 | return -EBUSY; |
| 76 | |
| 77 | priv = devm_kzalloc(dev->dev, sizeof(*priv), GFP_KERNEL); |
| 78 | if (!priv) { |
| 79 | DRM_ERROR("failed to allocate private\n"); |
| 80 | return -ENOMEM; |
| 81 | } |
| 82 | |
Daniel Vetter | 50fb3c3 | 2013-12-11 11:34:28 +0100 | [diff] [blame] | 83 | platform_set_drvdata(dev->platformdev, dev); |
Russell King | 96f60e3 | 2012-08-15 13:59:49 +0100 | [diff] [blame] | 84 | dev->dev_private = priv; |
| 85 | |
Russell King | 96f60e3 | 2012-08-15 13:59:49 +0100 | [diff] [blame] | 86 | INIT_WORK(&priv->fb_unref_work, armada_drm_unref_work); |
| 87 | INIT_KFIFO(priv->fb_unref); |
| 88 | |
| 89 | /* Mode setting support */ |
| 90 | drm_mode_config_init(dev); |
| 91 | dev->mode_config.min_width = 320; |
| 92 | dev->mode_config.min_height = 200; |
| 93 | |
| 94 | /* |
| 95 | * With vscale enabled, the maximum width is 1920 due to the |
| 96 | * 1920 by 3 lines RAM |
| 97 | */ |
| 98 | dev->mode_config.max_width = 1920; |
| 99 | dev->mode_config.max_height = 2048; |
| 100 | |
| 101 | dev->mode_config.preferred_depth = 24; |
| 102 | dev->mode_config.funcs = &armada_drm_mode_config_funcs; |
| 103 | drm_mm_init(&priv->linear, mem->start, resource_size(mem)); |
| 104 | |
Russell King | 0fb2970 | 2015-06-06 21:46:53 +0100 | [diff] [blame^] | 105 | ret = component_bind_all(dev->dev, dev); |
| 106 | if (ret) |
| 107 | goto err_kms; |
Russell King | 585b691 | 2013-05-04 20:08:27 +0100 | [diff] [blame] | 108 | |
Russell King | d016540 | 2014-04-22 11:02:23 +0100 | [diff] [blame] | 109 | ret = drm_vblank_init(dev, dev->mode_config.num_crtc); |
Russell King | 96f60e3 | 2012-08-15 13:59:49 +0100 | [diff] [blame] | 110 | if (ret) |
Russell King | 0101fd0 | 2014-02-04 11:57:06 +0000 | [diff] [blame] | 111 | goto err_comp; |
Russell King | 96f60e3 | 2012-08-15 13:59:49 +0100 | [diff] [blame] | 112 | |
Russell King | 0544e38 | 2014-08-27 16:53:31 +0100 | [diff] [blame] | 113 | dev->irq_enabled = true; |
Russell King | 96f60e3 | 2012-08-15 13:59:49 +0100 | [diff] [blame] | 114 | dev->vblank_disable_allowed = 1; |
| 115 | |
| 116 | ret = armada_fbdev_init(dev); |
| 117 | if (ret) |
Russell King | 0101fd0 | 2014-02-04 11:57:06 +0000 | [diff] [blame] | 118 | goto err_comp; |
Russell King | 96f60e3 | 2012-08-15 13:59:49 +0100 | [diff] [blame] | 119 | |
| 120 | drm_kms_helper_poll_init(dev); |
| 121 | |
| 122 | return 0; |
| 123 | |
Russell King | 0101fd0 | 2014-02-04 11:57:06 +0000 | [diff] [blame] | 124 | err_comp: |
Russell King | 0fb2970 | 2015-06-06 21:46:53 +0100 | [diff] [blame^] | 125 | component_unbind_all(dev->dev, dev); |
Russell King | 96f60e3 | 2012-08-15 13:59:49 +0100 | [diff] [blame] | 126 | err_kms: |
| 127 | drm_mode_config_cleanup(dev); |
| 128 | drm_mm_takedown(&priv->linear); |
| 129 | flush_work(&priv->fb_unref_work); |
| 130 | |
| 131 | return ret; |
| 132 | } |
| 133 | |
| 134 | static int armada_drm_unload(struct drm_device *dev) |
| 135 | { |
| 136 | struct armada_private *priv = dev->dev_private; |
| 137 | |
| 138 | drm_kms_helper_poll_fini(dev); |
| 139 | armada_fbdev_fini(dev); |
Russell King | 0101fd0 | 2014-02-04 11:57:06 +0000 | [diff] [blame] | 140 | |
Russell King | 0fb2970 | 2015-06-06 21:46:53 +0100 | [diff] [blame^] | 141 | component_unbind_all(dev->dev, dev); |
Russell King | 0101fd0 | 2014-02-04 11:57:06 +0000 | [diff] [blame] | 142 | |
Russell King | 96f60e3 | 2012-08-15 13:59:49 +0100 | [diff] [blame] | 143 | drm_mode_config_cleanup(dev); |
| 144 | drm_mm_takedown(&priv->linear); |
| 145 | flush_work(&priv->fb_unref_work); |
| 146 | dev->dev_private = NULL; |
| 147 | |
| 148 | return 0; |
| 149 | } |
| 150 | |
| 151 | void armada_drm_vbl_event_add(struct armada_crtc *dcrtc, |
| 152 | struct armada_vbl_event *evt) |
| 153 | { |
| 154 | unsigned long flags; |
| 155 | |
| 156 | spin_lock_irqsave(&dcrtc->irq_lock, flags); |
| 157 | if (list_empty(&evt->node)) { |
| 158 | list_add_tail(&evt->node, &dcrtc->vbl_list); |
| 159 | |
| 160 | drm_vblank_get(dcrtc->crtc.dev, dcrtc->num); |
| 161 | } |
| 162 | spin_unlock_irqrestore(&dcrtc->irq_lock, flags); |
| 163 | } |
| 164 | |
| 165 | void armada_drm_vbl_event_remove(struct armada_crtc *dcrtc, |
| 166 | struct armada_vbl_event *evt) |
| 167 | { |
| 168 | if (!list_empty(&evt->node)) { |
| 169 | list_del_init(&evt->node); |
| 170 | drm_vblank_put(dcrtc->crtc.dev, dcrtc->num); |
| 171 | } |
| 172 | } |
| 173 | |
Russell King | 96f60e3 | 2012-08-15 13:59:49 +0100 | [diff] [blame] | 174 | /* These are called under the vbl_lock. */ |
| 175 | static int armada_drm_enable_vblank(struct drm_device *dev, int crtc) |
| 176 | { |
| 177 | struct armada_private *priv = dev->dev_private; |
| 178 | armada_drm_crtc_enable_irq(priv->dcrtc[crtc], VSYNC_IRQ_ENA); |
| 179 | return 0; |
| 180 | } |
| 181 | |
| 182 | static void armada_drm_disable_vblank(struct drm_device *dev, int crtc) |
| 183 | { |
| 184 | struct armada_private *priv = dev->dev_private; |
| 185 | armada_drm_crtc_disable_irq(priv->dcrtc[crtc], VSYNC_IRQ_ENA); |
| 186 | } |
| 187 | |
Russell King | 96f60e3 | 2012-08-15 13:59:49 +0100 | [diff] [blame] | 188 | static struct drm_ioctl_desc armada_ioctls[] = { |
| 189 | DRM_IOCTL_DEF_DRV(ARMADA_GEM_CREATE, armada_gem_create_ioctl, |
| 190 | DRM_UNLOCKED), |
| 191 | DRM_IOCTL_DEF_DRV(ARMADA_GEM_MMAP, armada_gem_mmap_ioctl, |
| 192 | DRM_UNLOCKED), |
| 193 | DRM_IOCTL_DEF_DRV(ARMADA_GEM_PWRITE, armada_gem_pwrite_ioctl, |
| 194 | DRM_UNLOCKED), |
| 195 | }; |
| 196 | |
Russell King | 2f5ae49 | 2013-10-27 15:26:33 +0000 | [diff] [blame] | 197 | static void armada_drm_lastclose(struct drm_device *dev) |
| 198 | { |
| 199 | armada_fbdev_lastclose(dev); |
| 200 | } |
| 201 | |
Russell King | 96f60e3 | 2012-08-15 13:59:49 +0100 | [diff] [blame] | 202 | static const struct file_operations armada_drm_fops = { |
| 203 | .owner = THIS_MODULE, |
| 204 | .llseek = no_llseek, |
| 205 | .read = drm_read, |
| 206 | .poll = drm_poll, |
| 207 | .unlocked_ioctl = drm_ioctl, |
| 208 | .mmap = drm_gem_mmap, |
| 209 | .open = drm_open, |
| 210 | .release = drm_release, |
| 211 | }; |
| 212 | |
| 213 | static struct drm_driver armada_drm_driver = { |
| 214 | .load = armada_drm_load, |
| 215 | .open = NULL, |
| 216 | .preclose = NULL, |
| 217 | .postclose = NULL, |
Russell King | 2f5ae49 | 2013-10-27 15:26:33 +0000 | [diff] [blame] | 218 | .lastclose = armada_drm_lastclose, |
Russell King | 96f60e3 | 2012-08-15 13:59:49 +0100 | [diff] [blame] | 219 | .unload = armada_drm_unload, |
David Herrmann | 915b4d1 | 2014-08-29 12:12:43 +0200 | [diff] [blame] | 220 | .set_busid = drm_platform_set_busid, |
Russell King | 96f60e3 | 2012-08-15 13:59:49 +0100 | [diff] [blame] | 221 | .get_vblank_counter = drm_vblank_count, |
| 222 | .enable_vblank = armada_drm_enable_vblank, |
| 223 | .disable_vblank = armada_drm_disable_vblank, |
Russell King | 96f60e3 | 2012-08-15 13:59:49 +0100 | [diff] [blame] | 224 | #ifdef CONFIG_DEBUG_FS |
| 225 | .debugfs_init = armada_drm_debugfs_init, |
| 226 | .debugfs_cleanup = armada_drm_debugfs_cleanup, |
| 227 | #endif |
Russell King | 96f60e3 | 2012-08-15 13:59:49 +0100 | [diff] [blame] | 228 | .gem_free_object = armada_gem_free_object, |
| 229 | .prime_handle_to_fd = drm_gem_prime_handle_to_fd, |
| 230 | .prime_fd_to_handle = drm_gem_prime_fd_to_handle, |
| 231 | .gem_prime_export = armada_gem_prime_export, |
| 232 | .gem_prime_import = armada_gem_prime_import, |
| 233 | .dumb_create = armada_gem_dumb_create, |
| 234 | .dumb_map_offset = armada_gem_dumb_map_offset, |
| 235 | .dumb_destroy = armada_gem_dumb_destroy, |
| 236 | .gem_vm_ops = &armada_gem_vm_ops, |
| 237 | .major = 1, |
| 238 | .minor = 0, |
| 239 | .name = "armada-drm", |
| 240 | .desc = "Armada SoC DRM", |
| 241 | .date = "20120730", |
| 242 | .driver_features = DRIVER_GEM | DRIVER_MODESET | |
Russell King | 0544e38 | 2014-08-27 16:53:31 +0100 | [diff] [blame] | 243 | DRIVER_HAVE_IRQ | DRIVER_PRIME, |
Russell King | 96f60e3 | 2012-08-15 13:59:49 +0100 | [diff] [blame] | 244 | .ioctls = armada_ioctls, |
| 245 | .fops = &armada_drm_fops, |
| 246 | }; |
| 247 | |
Russell King | 0101fd0 | 2014-02-04 11:57:06 +0000 | [diff] [blame] | 248 | static int armada_drm_bind(struct device *dev) |
| 249 | { |
| 250 | return drm_platform_init(&armada_drm_driver, to_platform_device(dev)); |
| 251 | } |
| 252 | |
| 253 | static void armada_drm_unbind(struct device *dev) |
| 254 | { |
| 255 | drm_put_dev(dev_get_drvdata(dev)); |
| 256 | } |
| 257 | |
| 258 | static int compare_of(struct device *dev, void *data) |
| 259 | { |
| 260 | return dev->of_node == data; |
| 261 | } |
| 262 | |
| 263 | static int compare_dev_name(struct device *dev, void *data) |
| 264 | { |
| 265 | const char *name = data; |
| 266 | return !strcmp(dev_name(dev), name); |
| 267 | } |
| 268 | |
| 269 | static void armada_add_endpoints(struct device *dev, |
| 270 | struct component_match **match, struct device_node *port) |
| 271 | { |
| 272 | struct device_node *ep, *remote; |
| 273 | |
| 274 | for_each_child_of_node(port, ep) { |
| 275 | remote = of_graph_get_remote_port_parent(ep); |
| 276 | if (!remote || !of_device_is_available(remote)) { |
| 277 | of_node_put(remote); |
| 278 | continue; |
| 279 | } else if (!of_device_is_available(remote->parent)) { |
| 280 | dev_warn(dev, "parent device of %s is not available\n", |
| 281 | remote->full_name); |
| 282 | of_node_put(remote); |
| 283 | continue; |
| 284 | } |
| 285 | |
| 286 | component_match_add(dev, match, compare_of, remote); |
| 287 | of_node_put(remote); |
| 288 | } |
| 289 | } |
| 290 | |
| 291 | static int armada_drm_find_components(struct device *dev, |
| 292 | struct component_match **match) |
| 293 | { |
| 294 | struct device_node *port; |
| 295 | int i; |
| 296 | |
| 297 | if (dev->of_node) { |
| 298 | struct device_node *np = dev->of_node; |
| 299 | |
| 300 | for (i = 0; ; i++) { |
| 301 | port = of_parse_phandle(np, "ports", i); |
| 302 | if (!port) |
| 303 | break; |
| 304 | |
| 305 | component_match_add(dev, match, compare_of, port); |
| 306 | of_node_put(port); |
| 307 | } |
| 308 | |
| 309 | if (i == 0) { |
| 310 | dev_err(dev, "missing 'ports' property\n"); |
| 311 | return -ENODEV; |
| 312 | } |
| 313 | |
| 314 | for (i = 0; ; i++) { |
| 315 | port = of_parse_phandle(np, "ports", i); |
| 316 | if (!port) |
| 317 | break; |
| 318 | |
| 319 | armada_add_endpoints(dev, match, port); |
| 320 | of_node_put(port); |
| 321 | } |
| 322 | } else if (dev->platform_data) { |
| 323 | char **devices = dev->platform_data; |
| 324 | struct device *d; |
| 325 | |
| 326 | for (i = 0; devices[i]; i++) |
| 327 | component_match_add(dev, match, compare_dev_name, |
| 328 | devices[i]); |
| 329 | |
| 330 | if (i == 0) { |
| 331 | dev_err(dev, "missing 'ports' property\n"); |
| 332 | return -ENODEV; |
| 333 | } |
| 334 | |
| 335 | for (i = 0; devices[i]; i++) { |
| 336 | d = bus_find_device_by_name(&platform_bus_type, NULL, |
| 337 | devices[i]); |
| 338 | if (d && d->of_node) { |
| 339 | for_each_child_of_node(d->of_node, port) |
| 340 | armada_add_endpoints(dev, match, port); |
| 341 | } |
| 342 | put_device(d); |
| 343 | } |
| 344 | } |
| 345 | |
| 346 | return 0; |
| 347 | } |
| 348 | |
| 349 | static const struct component_master_ops armada_master_ops = { |
| 350 | .bind = armada_drm_bind, |
| 351 | .unbind = armada_drm_unbind, |
| 352 | }; |
| 353 | |
Russell King | 96f60e3 | 2012-08-15 13:59:49 +0100 | [diff] [blame] | 354 | static int armada_drm_probe(struct platform_device *pdev) |
| 355 | { |
Russell King | 0fb2970 | 2015-06-06 21:46:53 +0100 | [diff] [blame^] | 356 | struct component_match *match = NULL; |
| 357 | int ret; |
Russell King | 0101fd0 | 2014-02-04 11:57:06 +0000 | [diff] [blame] | 358 | |
Russell King | 0fb2970 | 2015-06-06 21:46:53 +0100 | [diff] [blame^] | 359 | ret = armada_drm_find_components(&pdev->dev, &match); |
| 360 | if (ret < 0) |
| 361 | return ret; |
Russell King | 0101fd0 | 2014-02-04 11:57:06 +0000 | [diff] [blame] | 362 | |
Russell King | 0fb2970 | 2015-06-06 21:46:53 +0100 | [diff] [blame^] | 363 | return component_master_add_with_match(&pdev->dev, &armada_master_ops, |
| 364 | match); |
Russell King | 96f60e3 | 2012-08-15 13:59:49 +0100 | [diff] [blame] | 365 | } |
| 366 | |
| 367 | static int armada_drm_remove(struct platform_device *pdev) |
| 368 | { |
Russell King | 0fb2970 | 2015-06-06 21:46:53 +0100 | [diff] [blame^] | 369 | component_master_del(&pdev->dev, &armada_master_ops); |
Russell King | 96f60e3 | 2012-08-15 13:59:49 +0100 | [diff] [blame] | 370 | return 0; |
| 371 | } |
| 372 | |
| 373 | static const struct platform_device_id armada_drm_platform_ids[] = { |
| 374 | { |
| 375 | .name = "armada-drm", |
Russell King | 96f60e3 | 2012-08-15 13:59:49 +0100 | [diff] [blame] | 376 | }, { |
| 377 | .name = "armada-510-drm", |
Russell King | 96f60e3 | 2012-08-15 13:59:49 +0100 | [diff] [blame] | 378 | }, |
| 379 | { }, |
| 380 | }; |
| 381 | MODULE_DEVICE_TABLE(platform, armada_drm_platform_ids); |
| 382 | |
| 383 | static struct platform_driver armada_drm_platform_driver = { |
| 384 | .probe = armada_drm_probe, |
| 385 | .remove = armada_drm_remove, |
| 386 | .driver = { |
| 387 | .name = "armada-drm", |
Russell King | 96f60e3 | 2012-08-15 13:59:49 +0100 | [diff] [blame] | 388 | }, |
| 389 | .id_table = armada_drm_platform_ids, |
| 390 | }; |
| 391 | |
| 392 | static int __init armada_drm_init(void) |
| 393 | { |
Russell King | d8c9608 | 2014-04-22 11:10:15 +0100 | [diff] [blame] | 394 | int ret; |
| 395 | |
Damien Lespiau | f95aeb1 | 2014-06-09 14:39:49 +0100 | [diff] [blame] | 396 | armada_drm_driver.num_ioctls = ARRAY_SIZE(armada_ioctls); |
Russell King | d8c9608 | 2014-04-22 11:10:15 +0100 | [diff] [blame] | 397 | |
| 398 | ret = platform_driver_register(&armada_lcd_platform_driver); |
| 399 | if (ret) |
| 400 | return ret; |
| 401 | ret = platform_driver_register(&armada_drm_platform_driver); |
| 402 | if (ret) |
| 403 | platform_driver_unregister(&armada_lcd_platform_driver); |
| 404 | return ret; |
Russell King | 96f60e3 | 2012-08-15 13:59:49 +0100 | [diff] [blame] | 405 | } |
| 406 | module_init(armada_drm_init); |
| 407 | |
| 408 | static void __exit armada_drm_exit(void) |
| 409 | { |
| 410 | platform_driver_unregister(&armada_drm_platform_driver); |
Russell King | d8c9608 | 2014-04-22 11:10:15 +0100 | [diff] [blame] | 411 | platform_driver_unregister(&armada_lcd_platform_driver); |
Russell King | 96f60e3 | 2012-08-15 13:59:49 +0100 | [diff] [blame] | 412 | } |
| 413 | module_exit(armada_drm_exit); |
| 414 | |
| 415 | MODULE_AUTHOR("Russell King <rmk+kernel@arm.linux.org.uk>"); |
| 416 | MODULE_DESCRIPTION("Armada DRM Driver"); |
| 417 | MODULE_LICENSE("GPL"); |
| 418 | MODULE_ALIAS("platform:armada-drm"); |