drivers/gpu/drm/hisilicon/kirin/kirin_drm_drv.c

   1 /*
   2  * Hisilicon Kirin SoCs drm master driver
   3  *
   4  * Copyright (c) 2016 Linaro Limited.
   5  * Copyright (c) 2014-2016 Hisilicon Limited.
   6  *
   7  * Author:
   8  *      Xinliang Liu <z.liuxinliang@hisilicon.com>
   9  *      Xinliang Liu <xinliang.liu@linaro.org>
  10  *      Xinwei Kong <kong.kongxinwei@hisilicon.com>
  11  *
  12  * This program is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License version 2 as
  14  * published by the Free Software Foundation.
  15  *
  16  */
  17
  18 #include <linux/of_platform.h>
  19 #include <linux/component.h>
  20 #include <linux/of_graph.h>
  21
  22 #include <drm/drmP.h>
  23 #include <drm/drm_gem_cma_helper.h>
  24 #include <drm/drm_fb_cma_helper.h>
  25 #include <drm/drm_atomic_helper.h>
  26 #include <drm/drm_crtc_helper.h>
  27
  28 #include "kirin_drm_drv.h"
  29
  30 static struct kirin_dc_ops *dc_ops;
  31
  32 static int kirin_drm_kms_cleanup(struct drm_device *dev)
  33 {
  34         struct kirin_drm_private *priv = dev->dev_private;
  35
  36 #ifdef CONFIG_DRM_FBDEV_EMULATION
  37         if (priv->fbdev) {
  38                 drm_fbdev_cma_fini(priv->fbdev);
  39                 priv->fbdev = NULL;
  40         }
  41 #endif
  42         drm_kms_helper_poll_fini(dev);
  43         drm_vblank_cleanup(dev);
  44         dc_ops->cleanup(dev);
  45         drm_mode_config_cleanup(dev);
  46         devm_kfree(dev->dev, priv);
  47         dev->dev_private = NULL;
  48
  49         return 0;
  50 }
  51
  52 #ifdef CONFIG_DRM_FBDEV_EMULATION
  53 static void kirin_fbdev_output_poll_changed(struct drm_device *dev)
  54 {
  55         struct kirin_drm_private *priv = dev->dev_private;
  56
  57         if (priv->fbdev) {
  58                 drm_fbdev_cma_hotplug_event(priv->fbdev);
  59         } else {
  60                 priv->fbdev = drm_fbdev_cma_init(dev, 32,
  61                                 dev->mode_config.num_crtc,
  62                                 dev->mode_config.num_connector);
  63                 if (IS_ERR(priv->fbdev))
  64                         priv->fbdev = NULL;
  65         }
  66 }
  67 #endif
  68
  69 static const struct drm_mode_config_funcs kirin_drm_mode_config_funcs = {
  70         .fb_create = drm_fb_cma_create,
  71 #ifdef CONFIG_DRM_FBDEV_EMULATION
  72         .output_poll_changed = kirin_fbdev_output_poll_changed,
  73 #endif
  74         .atomic_check = drm_atomic_helper_check,
  75         .atomic_commit = drm_atomic_helper_commit,
  76 };
  77
  78 static void kirin_drm_mode_config_init(struct drm_device *dev)
  79 {
  80         dev->mode_config.min_width = 0;
  81         dev->mode_config.min_height = 0;
  82
  83         dev->mode_config.max_width = 2048;
  84         dev->mode_config.max_height = 2048;
  85
  86         dev->mode_config.funcs = &kirin_drm_mode_config_funcs;
  87 }
  88
  89 static int kirin_drm_kms_init(struct drm_device *dev)
  90 {
  91         struct kirin_drm_private *priv;
  92         int ret;
  93
  94         priv = devm_kzalloc(dev->dev, sizeof(*priv), GFP_KERNEL);
  95         if (!priv)
  96                 return -ENOMEM;
  97
  98         dev->dev_private = priv;
  99         dev_set_drvdata(dev->dev, dev);
 100
 101         /* dev->mode_config initialization */
 102         drm_mode_config_init(dev);
 103         kirin_drm_mode_config_init(dev);
 104
 105         /* display controller init */
 106         ret = dc_ops->init(dev);
 107         if (ret)
 108                 goto err_mode_config_cleanup;
 109
 110         /* bind and init sub drivers */
 111         ret = component_bind_all(dev->dev, dev);
 112         if (ret) {
 113                 DRM_ERROR("failed to bind all component.\n");
 114                 goto err_dc_cleanup;
 115         }
 116
 117         /* vblank init */
 118         ret = drm_vblank_init(dev, dev->mode_config.num_crtc);
 119         if (ret) {
 120                 DRM_ERROR("failed to initialize vblank.\n");
 121                 goto err_unbind_all;
 122         }
 123         /* with irq_enabled = true, we can use the vblank feature. */
 124         dev->irq_enabled = true;
 125
 126         /* reset all the states of crtc/plane/encoder/connector */
 127         drm_mode_config_reset(dev);
 128
 129         /* init kms poll for handling hpd */
 130         drm_kms_helper_poll_init(dev);
 131
 132         /* force detection after connectors init */
 133         (void)drm_helper_hpd_irq_event(dev);
 134
 135         return 0;
 136
 137 err_unbind_all:
 138         component_unbind_all(dev->dev, dev);
 139 err_dc_cleanup:
 140         dc_ops->cleanup(dev);
 141 err_mode_config_cleanup:
 142         drm_mode_config_cleanup(dev);
 143         devm_kfree(dev->dev, priv);
 144         dev->dev_private = NULL;
 145
 146         return ret;
 147 }
 148
 149 static const struct file_operations kirin_drm_fops = {
 150         .owner          = THIS_MODULE,
 151         .open           = drm_open,
 152         .release        = drm_release,
 153         .unlocked_ioctl = drm_ioctl,
 154 #ifdef CONFIG_COMPAT
 155         .compat_ioctl   = drm_compat_ioctl,
 156 #endif
 157         .poll           = drm_poll,
 158         .read           = drm_read,
 159         .llseek         = no_llseek,
 160         .mmap           = drm_gem_cma_mmap,
 161 };
 162
 163 static int kirin_gem_cma_dumb_create(struct drm_file *file,
 164                                      struct drm_device *dev,
 165                                      struct drm_mode_create_dumb *args)
 166 {
 167         return drm_gem_cma_dumb_create_internal(file, dev, args);
 168 }
 169
 170 static struct drm_driver kirin_drm_driver = {
 171         .driver_features        = DRIVER_GEM | DRIVER_MODESET | DRIVER_PRIME |
 172                                   DRIVER_ATOMIC | DRIVER_HAVE_IRQ,
 173         .fops                   = &kirin_drm_fops,
 174         .set_busid              = drm_platform_set_busid,
 175
 176         .gem_free_object        = drm_gem_cma_free_object,
 177         .gem_vm_ops             = &drm_gem_cma_vm_ops,
 178         .dumb_create            = kirin_gem_cma_dumb_create,
 179         .dumb_map_offset        = drm_gem_cma_dumb_map_offset,
 180         .dumb_destroy           = drm_gem_dumb_destroy,
 181
 182         .prime_handle_to_fd     = drm_gem_prime_handle_to_fd,
 183         .prime_fd_to_handle     = drm_gem_prime_fd_to_handle,
 184         .gem_prime_export       = drm_gem_prime_export,
 185         .gem_prime_import       = drm_gem_prime_import,
 186         .gem_prime_get_sg_table = drm_gem_cma_prime_get_sg_table,
 187         .gem_prime_import_sg_table = drm_gem_cma_prime_import_sg_table,
 188         .gem_prime_vmap         = drm_gem_cma_prime_vmap,
 189         .gem_prime_vunmap       = drm_gem_cma_prime_vunmap,
 190         .gem_prime_mmap         = drm_gem_cma_prime_mmap,
 191
 192         .name                   = "kirin",
 193         .desc                   = "Hisilicon Kirin SoCs' DRM Driver",
 194         .date                   = "20150718",
 195         .major                  = 1,
 196         .minor                  = 0,
 197 };
 198
 199 static int compare_of(struct device *dev, void *data)
 200 {
 201         return dev->of_node == data;
 202 }
 203
 204 static int kirin_drm_connectors_register(struct drm_device *dev)
 205 {
 206         struct drm_connector *connector;
 207         struct drm_connector *failed_connector;
 208         int ret;
 209
 210         mutex_lock(&dev->mode_config.mutex);
 211         drm_for_each_connector(connector, dev) {
 212                 ret = drm_connector_register(connector);
 213                 if (ret) {
 214                         failed_connector = connector;
 215                         goto err;
 216                 }
 217         }
 218         mutex_unlock(&dev->mode_config.mutex);
 219
 220         return 0;
 221
 222 err:
 223         drm_for_each_connector(connector, dev) {
 224                 if (failed_connector == connector)
 225                         break;
 226                 drm_connector_unregister(connector);
 227         }
 228         mutex_unlock(&dev->mode_config.mutex);
 229
 230         return ret;
 231 }
 232
 233 static int kirin_drm_bind(struct device *dev)
 234 {
 235         struct drm_driver *driver = &kirin_drm_driver;
 236         struct drm_device *drm_dev;
 237         int ret;
 238
 239         drm_dev = drm_dev_alloc(driver, dev);
 240         if (!drm_dev)
 241                 return -ENOMEM;
 242
 243         drm_dev->platformdev = to_platform_device(dev);
 244
 245         ret = kirin_drm_kms_init(drm_dev);
 246         if (ret)
 247                 goto err_drm_dev_unref;
 248
 249         ret = drm_dev_register(drm_dev, 0);
 250         if (ret)
 251                 goto err_kms_cleanup;
 252
 253         /* connectors should be registered after drm device register */
 254         ret = kirin_drm_connectors_register(drm_dev);
 255         if (ret)
 256                 goto err_drm_dev_unregister;
 257
 258         DRM_INFO("Initialized %s %d.%d.%d %s on minor %d\n",
 259                  driver->name, driver->major, driver->minor, driver->patchlevel,
 260                  driver->date, drm_dev->primary->index);
 261
 262         return 0;
 263
 264 err_drm_dev_unregister:
 265         drm_dev_unregister(drm_dev);
 266 err_kms_cleanup:
 267         kirin_drm_kms_cleanup(drm_dev);
 268 err_drm_dev_unref:
 269         drm_dev_unref(drm_dev);
 270
 271         return ret;
 272 }
 273
 274 static void kirin_drm_unbind(struct device *dev)
 275 {
 276         drm_put_dev(dev_get_drvdata(dev));
 277 }
 278
 279 static const struct component_master_ops kirin_drm_ops = {
 280         .bind = kirin_drm_bind,
 281         .unbind = kirin_drm_unbind,
 282 };
 283
 284 static struct device_node *kirin_get_remote_node(struct device_node *np)
 285 {
 286         struct device_node *endpoint, *remote;
 287
 288         /* get the first endpoint, in our case only one remote node
 289          * is connected to display controller.
 290          */
 291         endpoint = of_graph_get_next_endpoint(np, NULL);
 292         if (!endpoint) {
 293                 DRM_ERROR("no valid endpoint node\n");
 294                 return ERR_PTR(-ENODEV);
 295         }
 296         of_node_put(endpoint);
 297
 298         remote = of_graph_get_remote_port_parent(endpoint);
 299         if (!remote) {
 300                 DRM_ERROR("no valid remote node\n");
 301                 return ERR_PTR(-ENODEV);
 302         }
 303         of_node_put(remote);
 304
 305         if (!of_device_is_available(remote)) {
 306                 DRM_ERROR("not available for remote node\n");
 307                 return ERR_PTR(-ENODEV);
 308         }
 309
 310         return remote;
 311 }
 312
 313 static int kirin_drm_platform_probe(struct platform_device *pdev)
 314 {
 315         struct device *dev = &pdev->dev;
 316         struct device_node *np = dev->of_node;
 317         struct component_match *match = NULL;
 318         struct device_node *remote;
 319
 320         dc_ops = (struct kirin_dc_ops *)of_device_get_match_data(dev);
 321         if (!dc_ops) {
 322                 DRM_ERROR("failed to get dt id data\n");
 323                 return -EINVAL;
 324         }
 325
 326         remote = kirin_get_remote_node(np);
 327         if (IS_ERR(remote))
 328                 return PTR_ERR(remote);
 329
 330         component_match_add(dev, &match, compare_of, remote);
 331
 332         return component_master_add_with_match(dev, &kirin_drm_ops, match);
 333
 334         return 0;
 335 }
 336
 337 static int kirin_drm_platform_remove(struct platform_device *pdev)
 338 {
 339         component_master_del(&pdev->dev, &kirin_drm_ops);
 340         dc_ops = NULL;
 341         return 0;
 342 }
 343
 344 static const struct of_device_id kirin_drm_dt_ids[] = {
 345         { .compatible = "hisilicon,hi6220-ade",
 346           .data = &ade_dc_ops,
 347         },
 348         { /* end node */ },
 349 };
 350 MODULE_DEVICE_TABLE(of, kirin_drm_dt_ids);
 351
 352 static struct platform_driver kirin_drm_platform_driver = {
 353         .probe = kirin_drm_platform_probe,
 354         .remove = kirin_drm_platform_remove,
 355         .driver = {
 356                 .name = "kirin-drm",
 357                 .of_match_table = kirin_drm_dt_ids,
 358         },
 359 };
 360
 361 module_platform_driver(kirin_drm_platform_driver);
 362
 363 MODULE_AUTHOR("Xinliang Liu <xinliang.liu@linaro.org>");
 364 MODULE_AUTHOR("Xinliang Liu <z.liuxinliang@hisilicon.com>");
 365 MODULE_AUTHOR("Xinwei Kong <kong.kongxinwei@hisilicon.com>");
 366 MODULE_DESCRIPTION("hisilicon Kirin SoCs' DRM master driver");
 367 MODULE_LICENSE("GPL v2");