Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) Fuzhou Rockchip Electronics Co.Ltd |
| 3 | * Author:Mark Yao <mark.yao@rock-chips.com> |
| 4 | * |
| 5 | * based on exynos_drm_drv.c |
| 6 | * |
| 7 | * This software is licensed under the terms of the GNU General Public |
| 8 | * License version 2, as published by the Free Software Foundation, and |
| 9 | * may be copied, distributed, and modified under those terms. |
| 10 | * |
| 11 | * This program is distributed in the hope that it will be useful, |
| 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 14 | * GNU General Public License for more details. |
| 15 | */ |
| 16 | |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 17 | #include <drm/drmP.h> |
| 18 | #include <drm/drm_crtc_helper.h> |
| 19 | #include <drm/drm_fb_helper.h> |
Daniel Vetter | 80f67cd | 2016-05-30 19:53:12 +0200 | [diff] [blame] | 20 | #include <drm/drm_gem_cma_helper.h> |
Russell King | 97ac0e4 | 2016-10-19 11:28:27 +0100 | [diff] [blame] | 21 | #include <drm/drm_of.h> |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 22 | #include <linux/dma-mapping.h> |
Shunqian Zheng | 1aa5ca6 | 2016-06-24 10:13:32 +0800 | [diff] [blame] | 23 | #include <linux/dma-iommu.h> |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 24 | #include <linux/pm_runtime.h> |
Paul Gortmaker | 00fe614 | 2015-05-01 20:02:30 -0400 | [diff] [blame] | 25 | #include <linux/module.h> |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 26 | #include <linux/of_graph.h> |
| 27 | #include <linux/component.h> |
Tomeu Vizoso | 5a58738 | 2016-06-06 16:53:32 +0200 | [diff] [blame] | 28 | #include <linux/console.h> |
Shunqian Zheng | 1aa5ca6 | 2016-06-24 10:13:32 +0800 | [diff] [blame] | 29 | #include <linux/iommu.h> |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 30 | |
| 31 | #include "rockchip_drm_drv.h" |
| 32 | #include "rockchip_drm_fb.h" |
| 33 | #include "rockchip_drm_fbdev.h" |
| 34 | #include "rockchip_drm_gem.h" |
| 35 | |
| 36 | #define DRIVER_NAME "rockchip" |
| 37 | #define DRIVER_DESC "RockChip Soc DRM" |
| 38 | #define DRIVER_DATE "20140818" |
| 39 | #define DRIVER_MAJOR 1 |
| 40 | #define DRIVER_MINOR 0 |
| 41 | |
Mark Yao | 2d90d47 | 2016-04-19 10:13:27 +0800 | [diff] [blame] | 42 | static bool is_support_iommu = true; |
Tomeu Vizoso | f706974 | 2016-06-10 13:14:13 +0200 | [diff] [blame] | 43 | static struct drm_driver rockchip_drm_driver; |
Mark Yao | 2d90d47 | 2016-04-19 10:13:27 +0800 | [diff] [blame] | 44 | |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 45 | /* |
| 46 | * Attach a (component) device to the shared drm dma mapping from master drm |
| 47 | * device. This is used by the VOPs to map GEM buffers to a common DMA |
| 48 | * mapping. |
| 49 | */ |
| 50 | int rockchip_drm_dma_attach_device(struct drm_device *drm_dev, |
| 51 | struct device *dev) |
| 52 | { |
Shunqian Zheng | 1aa5ca6 | 2016-06-24 10:13:32 +0800 | [diff] [blame] | 53 | struct rockchip_drm_private *private = drm_dev->dev_private; |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 54 | int ret; |
| 55 | |
Mark Yao | 2d90d47 | 2016-04-19 10:13:27 +0800 | [diff] [blame] | 56 | if (!is_support_iommu) |
| 57 | return 0; |
| 58 | |
Shunqian Zheng | 1aa5ca6 | 2016-06-24 10:13:32 +0800 | [diff] [blame] | 59 | ret = iommu_attach_device(private->domain, dev); |
| 60 | if (ret) { |
| 61 | dev_err(dev, "Failed to attach iommu device\n"); |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 62 | return ret; |
Shunqian Zheng | 1aa5ca6 | 2016-06-24 10:13:32 +0800 | [diff] [blame] | 63 | } |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 64 | |
Shunqian Zheng | 1aa5ca6 | 2016-06-24 10:13:32 +0800 | [diff] [blame] | 65 | return 0; |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 66 | } |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 67 | |
| 68 | void rockchip_drm_dma_detach_device(struct drm_device *drm_dev, |
| 69 | struct device *dev) |
| 70 | { |
Shunqian Zheng | 1aa5ca6 | 2016-06-24 10:13:32 +0800 | [diff] [blame] | 71 | struct rockchip_drm_private *private = drm_dev->dev_private; |
| 72 | struct iommu_domain *domain = private->domain; |
| 73 | |
Mark Yao | 2d90d47 | 2016-04-19 10:13:27 +0800 | [diff] [blame] | 74 | if (!is_support_iommu) |
| 75 | return; |
| 76 | |
Shunqian Zheng | 1aa5ca6 | 2016-06-24 10:13:32 +0800 | [diff] [blame] | 77 | iommu_detach_device(domain, dev); |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 78 | } |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 79 | |
Shunqian Zheng | 1aa5ca6 | 2016-06-24 10:13:32 +0800 | [diff] [blame] | 80 | static int rockchip_drm_init_iommu(struct drm_device *drm_dev) |
| 81 | { |
| 82 | struct rockchip_drm_private *private = drm_dev->dev_private; |
| 83 | struct iommu_domain_geometry *geometry; |
| 84 | u64 start, end; |
| 85 | |
| 86 | if (!is_support_iommu) |
| 87 | return 0; |
| 88 | |
| 89 | private->domain = iommu_domain_alloc(&platform_bus_type); |
| 90 | if (!private->domain) |
| 91 | return -ENOMEM; |
| 92 | |
| 93 | geometry = &private->domain->geometry; |
| 94 | start = geometry->aperture_start; |
| 95 | end = geometry->aperture_end; |
| 96 | |
| 97 | DRM_DEBUG("IOMMU context initialized (aperture: %#llx-%#llx)\n", |
| 98 | start, end); |
| 99 | drm_mm_init(&private->mm, start, end - start + 1); |
| 100 | mutex_init(&private->mm_lock); |
| 101 | |
| 102 | return 0; |
| 103 | } |
| 104 | |
| 105 | static void rockchip_iommu_cleanup(struct drm_device *drm_dev) |
| 106 | { |
| 107 | struct rockchip_drm_private *private = drm_dev->dev_private; |
| 108 | |
| 109 | if (!is_support_iommu) |
| 110 | return; |
| 111 | |
| 112 | drm_mm_takedown(&private->mm); |
| 113 | iommu_domain_free(private->domain); |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 114 | } |
| 115 | |
Tomeu Vizoso | f706974 | 2016-06-10 13:14:13 +0200 | [diff] [blame] | 116 | static int rockchip_drm_bind(struct device *dev) |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 117 | { |
Tomeu Vizoso | f706974 | 2016-06-10 13:14:13 +0200 | [diff] [blame] | 118 | struct drm_device *drm_dev; |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 119 | struct rockchip_drm_private *private; |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 120 | int ret; |
| 121 | |
Tomeu Vizoso | f706974 | 2016-06-10 13:14:13 +0200 | [diff] [blame] | 122 | drm_dev = drm_dev_alloc(&rockchip_drm_driver, dev); |
Tom Gundersen | 0f28860 | 2016-09-21 16:59:19 +0200 | [diff] [blame] | 123 | if (IS_ERR(drm_dev)) |
| 124 | return PTR_ERR(drm_dev); |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 125 | |
Tomeu Vizoso | f706974 | 2016-06-10 13:14:13 +0200 | [diff] [blame] | 126 | dev_set_drvdata(dev, drm_dev); |
| 127 | |
| 128 | private = devm_kzalloc(drm_dev->dev, sizeof(*private), GFP_KERNEL); |
| 129 | if (!private) { |
| 130 | ret = -ENOMEM; |
Tomasz Figa | 9127f99 | 2016-06-21 13:27:34 +0900 | [diff] [blame] | 131 | goto err_free; |
Tomeu Vizoso | f706974 | 2016-06-10 13:14:13 +0200 | [diff] [blame] | 132 | } |
| 133 | |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 134 | drm_dev->dev_private = private; |
| 135 | |
Yakir Yang | 5182c1a | 2016-07-24 14:57:44 +0800 | [diff] [blame] | 136 | INIT_LIST_HEAD(&private->psr_list); |
Sean Paul | 18d8d4d | 2016-08-16 16:11:28 -0700 | [diff] [blame] | 137 | spin_lock_init(&private->psr_list_lock); |
Yakir Yang | 5182c1a | 2016-07-24 14:57:44 +0800 | [diff] [blame] | 138 | |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 139 | drm_mode_config_init(drm_dev); |
| 140 | |
| 141 | rockchip_drm_mode_config_init(drm_dev); |
| 142 | |
Shunqian Zheng | 1aa5ca6 | 2016-06-24 10:13:32 +0800 | [diff] [blame] | 143 | ret = rockchip_drm_init_iommu(drm_dev); |
| 144 | if (ret) |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 145 | goto err_config_cleanup; |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 146 | |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 147 | /* Try to bind all sub drivers. */ |
| 148 | ret = component_bind_all(dev, drm_dev); |
| 149 | if (ret) |
Shunqian Zheng | 1aa5ca6 | 2016-06-24 10:13:32 +0800 | [diff] [blame] | 150 | goto err_iommu_cleanup; |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 151 | |
| 152 | /* init kms poll for handling hpd */ |
| 153 | drm_kms_helper_poll_init(drm_dev); |
| 154 | |
| 155 | /* |
| 156 | * enable drm irq mode. |
| 157 | * - with irq_enabled = true, we can use the vblank feature. |
| 158 | */ |
| 159 | drm_dev->irq_enabled = true; |
| 160 | |
| 161 | ret = drm_vblank_init(drm_dev, ROCKCHIP_MAX_CRTC); |
| 162 | if (ret) |
| 163 | goto err_kms_helper_poll_fini; |
| 164 | |
Mark Yao | 63ebb9f | 2015-11-30 18:22:42 +0800 | [diff] [blame] | 165 | drm_mode_config_reset(drm_dev); |
| 166 | |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 167 | ret = rockchip_drm_fbdev_init(drm_dev); |
| 168 | if (ret) |
| 169 | goto err_vblank_cleanup; |
| 170 | |
Tomasz Figa | 9127f99 | 2016-06-21 13:27:34 +0900 | [diff] [blame] | 171 | ret = drm_dev_register(drm_dev, 0); |
| 172 | if (ret) |
| 173 | goto err_fbdev_fini; |
| 174 | |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 175 | return 0; |
Tomasz Figa | 9127f99 | 2016-06-21 13:27:34 +0900 | [diff] [blame] | 176 | err_fbdev_fini: |
| 177 | rockchip_drm_fbdev_fini(drm_dev); |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 178 | err_vblank_cleanup: |
| 179 | drm_vblank_cleanup(drm_dev); |
| 180 | err_kms_helper_poll_fini: |
| 181 | drm_kms_helper_poll_fini(drm_dev); |
| 182 | component_unbind_all(dev, drm_dev); |
Shunqian Zheng | 1aa5ca6 | 2016-06-24 10:13:32 +0800 | [diff] [blame] | 183 | err_iommu_cleanup: |
| 184 | rockchip_iommu_cleanup(drm_dev); |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 185 | err_config_cleanup: |
| 186 | drm_mode_config_cleanup(drm_dev); |
| 187 | drm_dev->dev_private = NULL; |
Tomeu Vizoso | f706974 | 2016-06-10 13:14:13 +0200 | [diff] [blame] | 188 | err_free: |
| 189 | drm_dev_unref(drm_dev); |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 190 | return ret; |
| 191 | } |
| 192 | |
Tomeu Vizoso | f706974 | 2016-06-10 13:14:13 +0200 | [diff] [blame] | 193 | static void rockchip_drm_unbind(struct device *dev) |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 194 | { |
Tomeu Vizoso | f706974 | 2016-06-10 13:14:13 +0200 | [diff] [blame] | 195 | struct drm_device *drm_dev = dev_get_drvdata(dev); |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 196 | |
| 197 | rockchip_drm_fbdev_fini(drm_dev); |
| 198 | drm_vblank_cleanup(drm_dev); |
| 199 | drm_kms_helper_poll_fini(drm_dev); |
| 200 | component_unbind_all(dev, drm_dev); |
Shunqian Zheng | 1aa5ca6 | 2016-06-24 10:13:32 +0800 | [diff] [blame] | 201 | rockchip_iommu_cleanup(drm_dev); |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 202 | drm_mode_config_cleanup(drm_dev); |
| 203 | drm_dev->dev_private = NULL; |
Tomeu Vizoso | f706974 | 2016-06-10 13:14:13 +0200 | [diff] [blame] | 204 | drm_dev_unregister(drm_dev); |
| 205 | drm_dev_unref(drm_dev); |
| 206 | dev_set_drvdata(dev, NULL); |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 207 | } |
| 208 | |
John Keeping | 8ff490a | 2016-05-10 17:03:56 +0100 | [diff] [blame] | 209 | static void rockchip_drm_lastclose(struct drm_device *dev) |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 210 | { |
| 211 | struct rockchip_drm_private *priv = dev->dev_private; |
| 212 | |
| 213 | drm_fb_helper_restore_fbdev_mode_unlocked(&priv->fbdev_helper); |
| 214 | } |
| 215 | |
| 216 | static const struct file_operations rockchip_drm_driver_fops = { |
| 217 | .owner = THIS_MODULE, |
| 218 | .open = drm_open, |
| 219 | .mmap = rockchip_gem_mmap, |
| 220 | .poll = drm_poll, |
| 221 | .read = drm_read, |
| 222 | .unlocked_ioctl = drm_ioctl, |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 223 | .compat_ioctl = drm_compat_ioctl, |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 224 | .release = drm_release, |
| 225 | }; |
| 226 | |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 227 | static struct drm_driver rockchip_drm_driver = { |
Mark Yao | 63ebb9f | 2015-11-30 18:22:42 +0800 | [diff] [blame] | 228 | .driver_features = DRIVER_MODESET | DRIVER_GEM | |
| 229 | DRIVER_PRIME | DRIVER_ATOMIC, |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 230 | .lastclose = rockchip_drm_lastclose, |
Daniel Vetter | 80f67cd | 2016-05-30 19:53:12 +0200 | [diff] [blame] | 231 | .gem_vm_ops = &drm_gem_cma_vm_ops, |
Daniel Vetter | c2466ac | 2016-05-30 19:53:03 +0200 | [diff] [blame] | 232 | .gem_free_object_unlocked = rockchip_gem_free_object, |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 233 | .dumb_create = rockchip_gem_dumb_create, |
| 234 | .dumb_map_offset = rockchip_gem_dumb_map_offset, |
| 235 | .dumb_destroy = drm_gem_dumb_destroy, |
| 236 | .prime_handle_to_fd = drm_gem_prime_handle_to_fd, |
| 237 | .prime_fd_to_handle = drm_gem_prime_fd_to_handle, |
| 238 | .gem_prime_import = drm_gem_prime_import, |
| 239 | .gem_prime_export = drm_gem_prime_export, |
| 240 | .gem_prime_get_sg_table = rockchip_gem_prime_get_sg_table, |
| 241 | .gem_prime_vmap = rockchip_gem_prime_vmap, |
| 242 | .gem_prime_vunmap = rockchip_gem_prime_vunmap, |
| 243 | .gem_prime_mmap = rockchip_gem_mmap_buf, |
| 244 | .fops = &rockchip_drm_driver_fops, |
| 245 | .name = DRIVER_NAME, |
| 246 | .desc = DRIVER_DESC, |
| 247 | .date = DRIVER_DATE, |
| 248 | .major = DRIVER_MAJOR, |
| 249 | .minor = DRIVER_MINOR, |
| 250 | }; |
| 251 | |
| 252 | #ifdef CONFIG_PM_SLEEP |
Baoyou Xie | 62398177 | 2016-09-25 15:43:08 +0800 | [diff] [blame] | 253 | static void rockchip_drm_fb_suspend(struct drm_device *drm) |
Tomeu Vizoso | 5a58738 | 2016-06-06 16:53:32 +0200 | [diff] [blame] | 254 | { |
| 255 | struct rockchip_drm_private *priv = drm->dev_private; |
| 256 | |
| 257 | console_lock(); |
| 258 | drm_fb_helper_set_suspend(&priv->fbdev_helper, 1); |
| 259 | console_unlock(); |
| 260 | } |
| 261 | |
Baoyou Xie | 62398177 | 2016-09-25 15:43:08 +0800 | [diff] [blame] | 262 | static void rockchip_drm_fb_resume(struct drm_device *drm) |
Tomeu Vizoso | 5a58738 | 2016-06-06 16:53:32 +0200 | [diff] [blame] | 263 | { |
| 264 | struct rockchip_drm_private *priv = drm->dev_private; |
| 265 | |
| 266 | console_lock(); |
| 267 | drm_fb_helper_set_suspend(&priv->fbdev_helper, 0); |
| 268 | console_unlock(); |
| 269 | } |
| 270 | |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 271 | static int rockchip_drm_sys_suspend(struct device *dev) |
| 272 | { |
| 273 | struct drm_device *drm = dev_get_drvdata(dev); |
Tomeu Vizoso | 5a58738 | 2016-06-06 16:53:32 +0200 | [diff] [blame] | 274 | struct rockchip_drm_private *priv = drm->dev_private; |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 275 | |
Tomeu Vizoso | 5a58738 | 2016-06-06 16:53:32 +0200 | [diff] [blame] | 276 | drm_kms_helper_poll_disable(drm); |
| 277 | rockchip_drm_fb_suspend(drm); |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 278 | |
Tomeu Vizoso | 5a58738 | 2016-06-06 16:53:32 +0200 | [diff] [blame] | 279 | priv->state = drm_atomic_helper_suspend(drm); |
| 280 | if (IS_ERR(priv->state)) { |
| 281 | rockchip_drm_fb_resume(drm); |
| 282 | drm_kms_helper_poll_enable(drm); |
| 283 | return PTR_ERR(priv->state); |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 284 | } |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 285 | |
| 286 | return 0; |
| 287 | } |
| 288 | |
| 289 | static int rockchip_drm_sys_resume(struct device *dev) |
| 290 | { |
| 291 | struct drm_device *drm = dev_get_drvdata(dev); |
Tomeu Vizoso | 5a58738 | 2016-06-06 16:53:32 +0200 | [diff] [blame] | 292 | struct rockchip_drm_private *priv = drm->dev_private; |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 293 | |
Tomeu Vizoso | 5a58738 | 2016-06-06 16:53:32 +0200 | [diff] [blame] | 294 | drm_atomic_helper_resume(drm, priv->state); |
| 295 | rockchip_drm_fb_resume(drm); |
| 296 | drm_kms_helper_poll_enable(drm); |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 297 | |
| 298 | return 0; |
| 299 | } |
| 300 | #endif |
| 301 | |
| 302 | static const struct dev_pm_ops rockchip_drm_pm_ops = { |
| 303 | SET_SYSTEM_SLEEP_PM_OPS(rockchip_drm_sys_suspend, |
| 304 | rockchip_drm_sys_resume) |
| 305 | }; |
| 306 | |
Jeffy Chen | 8820b68 | 2017-03-22 11:21:20 +0800 | [diff] [blame] | 307 | #define MAX_ROCKCHIP_SUB_DRIVERS 16 |
| 308 | static struct platform_driver *rockchip_sub_drivers[MAX_ROCKCHIP_SUB_DRIVERS]; |
| 309 | static int num_rockchip_sub_drivers; |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 310 | |
Jeffy Chen | 8820b68 | 2017-03-22 11:21:20 +0800 | [diff] [blame] | 311 | static int compare_dev(struct device *dev, void *data) |
| 312 | { |
| 313 | return dev == (struct device *)data; |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 314 | } |
| 315 | |
Jeffy Chen | 8820b68 | 2017-03-22 11:21:20 +0800 | [diff] [blame] | 316 | static struct component_match *rockchip_drm_match_add(struct device *dev) |
Mark Yao | 5bad7d2 | 2015-11-10 16:47:19 +0800 | [diff] [blame] | 317 | { |
Jeffy Chen | 8820b68 | 2017-03-22 11:21:20 +0800 | [diff] [blame] | 318 | struct component_match *match = NULL; |
| 319 | int i; |
Mark Yao | 5bad7d2 | 2015-11-10 16:47:19 +0800 | [diff] [blame] | 320 | |
Jeffy Chen | 8820b68 | 2017-03-22 11:21:20 +0800 | [diff] [blame] | 321 | for (i = 0; i < num_rockchip_sub_drivers; i++) { |
| 322 | struct platform_driver *drv = rockchip_sub_drivers[i]; |
| 323 | struct device *p = NULL, *d; |
Mark Yao | 5bad7d2 | 2015-11-10 16:47:19 +0800 | [diff] [blame] | 324 | |
Jeffy Chen | 8820b68 | 2017-03-22 11:21:20 +0800 | [diff] [blame] | 325 | do { |
| 326 | d = bus_find_device(&platform_bus_type, p, &drv->driver, |
| 327 | (void *)platform_bus_type.match); |
| 328 | put_device(p); |
| 329 | p = d; |
| 330 | |
| 331 | if (!d) |
| 332 | break; |
| 333 | component_match_add(dev, &match, compare_dev, d); |
| 334 | } while (true); |
Mark Yao | 5bad7d2 | 2015-11-10 16:47:19 +0800 | [diff] [blame] | 335 | } |
Jeffy Chen | 8820b68 | 2017-03-22 11:21:20 +0800 | [diff] [blame] | 336 | |
| 337 | return match ?: ERR_PTR(-ENODEV); |
Mark Yao | 5bad7d2 | 2015-11-10 16:47:19 +0800 | [diff] [blame] | 338 | } |
| 339 | |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 340 | static const struct component_master_ops rockchip_drm_ops = { |
| 341 | .bind = rockchip_drm_bind, |
| 342 | .unbind = rockchip_drm_unbind, |
| 343 | }; |
| 344 | |
Jeffy Chen | 8820b68 | 2017-03-22 11:21:20 +0800 | [diff] [blame] | 345 | static int rockchip_drm_platform_of_probe(struct device *dev) |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 346 | { |
Mark Yao | 5bad7d2 | 2015-11-10 16:47:19 +0800 | [diff] [blame] | 347 | struct device_node *np = dev->of_node; |
| 348 | struct device_node *port; |
Jeffy Chen | 8820b68 | 2017-03-22 11:21:20 +0800 | [diff] [blame] | 349 | bool found = false; |
Mark Yao | 5bad7d2 | 2015-11-10 16:47:19 +0800 | [diff] [blame] | 350 | int i; |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 351 | |
Mark Yao | 5bad7d2 | 2015-11-10 16:47:19 +0800 | [diff] [blame] | 352 | if (!np) |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 353 | return -ENODEV; |
Jeffy Chen | 8820b68 | 2017-03-22 11:21:20 +0800 | [diff] [blame] | 354 | |
Mark Yao | 5bad7d2 | 2015-11-10 16:47:19 +0800 | [diff] [blame] | 355 | for (i = 0;; i++) { |
Mark Yao | 2d90d47 | 2016-04-19 10:13:27 +0800 | [diff] [blame] | 356 | struct device_node *iommu; |
| 357 | |
Mark Yao | 5bad7d2 | 2015-11-10 16:47:19 +0800 | [diff] [blame] | 358 | port = of_parse_phandle(np, "ports", i); |
| 359 | if (!port) |
| 360 | break; |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 361 | |
Mark Yao | 5bad7d2 | 2015-11-10 16:47:19 +0800 | [diff] [blame] | 362 | if (!of_device_is_available(port->parent)) { |
| 363 | of_node_put(port); |
| 364 | continue; |
| 365 | } |
| 366 | |
Mark Yao | 2d90d47 | 2016-04-19 10:13:27 +0800 | [diff] [blame] | 367 | iommu = of_parse_phandle(port->parent, "iommus", 0); |
| 368 | if (!iommu || !of_device_is_available(iommu->parent)) { |
| 369 | dev_dbg(dev, "no iommu attached for %s, using non-iommu buffers\n", |
| 370 | port->parent->full_name); |
| 371 | /* |
| 372 | * if there is a crtc not support iommu, force set all |
| 373 | * crtc use non-iommu buffer. |
| 374 | */ |
| 375 | is_support_iommu = false; |
| 376 | } |
| 377 | |
Jeffy Chen | 8820b68 | 2017-03-22 11:21:20 +0800 | [diff] [blame] | 378 | found = true; |
| 379 | |
Peter Chen | 6d5fa28 | 2016-07-05 10:04:48 +0800 | [diff] [blame] | 380 | of_node_put(iommu); |
Mark Yao | 5bad7d2 | 2015-11-10 16:47:19 +0800 | [diff] [blame] | 381 | of_node_put(port); |
| 382 | } |
| 383 | |
| 384 | if (i == 0) { |
| 385 | dev_err(dev, "missing 'ports' property\n"); |
| 386 | return -ENODEV; |
| 387 | } |
| 388 | |
Jeffy Chen | 8820b68 | 2017-03-22 11:21:20 +0800 | [diff] [blame] | 389 | if (!found) { |
Mark Yao | 5bad7d2 | 2015-11-10 16:47:19 +0800 | [diff] [blame] | 390 | dev_err(dev, "No available vop found for display-subsystem.\n"); |
| 391 | return -ENODEV; |
| 392 | } |
Mark Yao | 5bad7d2 | 2015-11-10 16:47:19 +0800 | [diff] [blame] | 393 | |
Jeffy Chen | 8820b68 | 2017-03-22 11:21:20 +0800 | [diff] [blame] | 394 | return 0; |
| 395 | } |
Mark Yao | 5bad7d2 | 2015-11-10 16:47:19 +0800 | [diff] [blame] | 396 | |
Jeffy Chen | 8820b68 | 2017-03-22 11:21:20 +0800 | [diff] [blame] | 397 | static int rockchip_drm_platform_probe(struct platform_device *pdev) |
| 398 | { |
| 399 | struct device *dev = &pdev->dev; |
| 400 | struct component_match *match = NULL; |
| 401 | int ret; |
| 402 | |
| 403 | ret = rockchip_drm_platform_of_probe(dev); |
| 404 | if (ret) |
| 405 | return ret; |
| 406 | |
| 407 | match = rockchip_drm_match_add(dev); |
| 408 | if (IS_ERR(match)) |
| 409 | return PTR_ERR(match); |
Mark Yao | 5bad7d2 | 2015-11-10 16:47:19 +0800 | [diff] [blame] | 410 | |
| 411 | return component_master_add_with_match(dev, &rockchip_drm_ops, match); |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 412 | } |
| 413 | |
| 414 | static int rockchip_drm_platform_remove(struct platform_device *pdev) |
| 415 | { |
| 416 | component_master_del(&pdev->dev, &rockchip_drm_ops); |
| 417 | |
| 418 | return 0; |
| 419 | } |
| 420 | |
| 421 | static const struct of_device_id rockchip_drm_dt_ids[] = { |
| 422 | { .compatible = "rockchip,display-subsystem", }, |
| 423 | { /* sentinel */ }, |
| 424 | }; |
| 425 | MODULE_DEVICE_TABLE(of, rockchip_drm_dt_ids); |
| 426 | |
| 427 | static struct platform_driver rockchip_drm_platform_driver = { |
| 428 | .probe = rockchip_drm_platform_probe, |
| 429 | .remove = rockchip_drm_platform_remove, |
| 430 | .driver = { |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 431 | .name = "rockchip-drm", |
| 432 | .of_match_table = rockchip_drm_dt_ids, |
| 433 | .pm = &rockchip_drm_pm_ops, |
| 434 | }, |
| 435 | }; |
| 436 | |
Jeffy Chen | 8820b68 | 2017-03-22 11:21:20 +0800 | [diff] [blame] | 437 | #define ADD_ROCKCHIP_SUB_DRIVER(drv, cond) { \ |
| 438 | if (IS_ENABLED(cond) && \ |
| 439 | !WARN_ON(num_rockchip_sub_drivers >= MAX_ROCKCHIP_SUB_DRIVERS)) \ |
| 440 | rockchip_sub_drivers[num_rockchip_sub_drivers++] = &drv; \ |
| 441 | } |
| 442 | |
| 443 | static int __init rockchip_drm_init(void) |
| 444 | { |
| 445 | int ret; |
| 446 | |
| 447 | num_rockchip_sub_drivers = 0; |
| 448 | ADD_ROCKCHIP_SUB_DRIVER(vop_platform_driver, CONFIG_DRM_ROCKCHIP); |
| 449 | ADD_ROCKCHIP_SUB_DRIVER(rockchip_dp_driver, |
| 450 | CONFIG_ROCKCHIP_ANALOGIX_DP); |
| 451 | ADD_ROCKCHIP_SUB_DRIVER(cdn_dp_driver, CONFIG_ROCKCHIP_CDN_DP); |
| 452 | ADD_ROCKCHIP_SUB_DRIVER(dw_hdmi_rockchip_pltfm_driver, |
| 453 | CONFIG_ROCKCHIP_DW_HDMI); |
| 454 | ADD_ROCKCHIP_SUB_DRIVER(dw_mipi_dsi_driver, |
| 455 | CONFIG_ROCKCHIP_DW_MIPI_DSI); |
| 456 | ADD_ROCKCHIP_SUB_DRIVER(inno_hdmi_driver, CONFIG_ROCKCHIP_INNO_HDMI); |
| 457 | |
| 458 | ret = platform_register_drivers(rockchip_sub_drivers, |
| 459 | num_rockchip_sub_drivers); |
| 460 | if (ret) |
| 461 | return ret; |
| 462 | |
| 463 | ret = platform_driver_register(&rockchip_drm_platform_driver); |
| 464 | if (ret) |
| 465 | goto err_unreg_drivers; |
| 466 | |
| 467 | return 0; |
| 468 | |
| 469 | err_unreg_drivers: |
| 470 | platform_unregister_drivers(rockchip_sub_drivers, |
| 471 | num_rockchip_sub_drivers); |
| 472 | return ret; |
| 473 | } |
| 474 | |
| 475 | static void __exit rockchip_drm_fini(void) |
| 476 | { |
| 477 | platform_driver_unregister(&rockchip_drm_platform_driver); |
| 478 | |
| 479 | platform_unregister_drivers(rockchip_sub_drivers, |
| 480 | num_rockchip_sub_drivers); |
| 481 | } |
| 482 | |
| 483 | module_init(rockchip_drm_init); |
| 484 | module_exit(rockchip_drm_fini); |
Mark Yao | 2048e32 | 2014-08-22 18:36:26 +0800 | [diff] [blame] | 485 | |
| 486 | MODULE_AUTHOR("Mark Yao <mark.yao@rock-chips.com>"); |
| 487 | MODULE_DESCRIPTION("ROCKCHIP DRM Driver"); |
| 488 | MODULE_LICENSE("GPL v2"); |