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(to_platform_device(dev->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(to_platform_device(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,
 173         .fops                   = &kirin_drm_fops,
 174
 175         .gem_free_object_unlocked = drm_gem_cma_free_object,
 176         .gem_vm_ops             = &drm_gem_cma_vm_ops,
 177         .dumb_create            = kirin_gem_cma_dumb_create,
 178         .dumb_map_offset        = drm_gem_cma_dumb_map_offset,
 179         .dumb_destroy           = drm_gem_dumb_destroy,
 180
 181         .prime_handle_to_fd     = drm_gem_prime_handle_to_fd,
 182         .prime_fd_to_handle     = drm_gem_prime_fd_to_handle,
 183         .gem_prime_export       = drm_gem_prime_export,
 184         .gem_prime_import       = drm_gem_prime_import,
 185         .gem_prime_get_sg_table = drm_gem_cma_prime_get_sg_table,
 186         .gem_prime_import_sg_table = drm_gem_cma_prime_import_sg_table,
 187         .gem_prime_vmap         = drm_gem_cma_prime_vmap,
 188         .gem_prime_vunmap       = drm_gem_cma_prime_vunmap,
 189         .gem_prime_mmap         = drm_gem_cma_prime_mmap,
 190
 191         .name                   = "kirin",
 192         .desc                   = "Hisilicon Kirin SoCs' DRM Driver",
 193         .date                   = "20150718",
 194         .major                  = 1,
 195         .minor                  = 0,
 196 };
 197
 198 static int compare_of(struct device *dev, void *data)
 199 {
 200         return dev->of_node == data;
 201 }
 202
 203 static int kirin_drm_bind(struct device *dev)
 204 {
 205         struct drm_driver *driver = &kirin_drm_driver;
 206         struct drm_device *drm_dev;
 207         int ret;
 208
 209         drm_dev = drm_dev_alloc(driver, dev);
 210         if (!drm_dev)
 211                 return -ENOMEM;
 212
 213         ret = kirin_drm_kms_init(drm_dev);
 214         if (ret)
 215                 goto err_drm_dev_unref;
 216
 217         ret = drm_dev_register(drm_dev, 0);
 218         if (ret)
 219                 goto err_kms_cleanup;
 220
 221         DRM_INFO("Initialized %s %d.%d.%d %s on minor %d\n",
 222                  driver->name, driver->major, driver->minor, driver->patchlevel,
 223                  driver->date, drm_dev->primary->index);
 224
 225         return 0;
 226
 227 err_kms_cleanup:
 228         kirin_drm_kms_cleanup(drm_dev);
 229 err_drm_dev_unref:
 230         drm_dev_unref(drm_dev);
 231
 232         return ret;
 233 }
 234
 235 static void kirin_drm_unbind(struct device *dev)
 236 {
 237         struct drm_device *drm_dev = dev_get_drvdata(dev);
 238
 239         drm_dev_unregister(drm_dev);
 240         kirin_drm_kms_cleanup(drm_dev);
 241         drm_dev_unref(drm_dev);
 242 }
 243
 244 static const struct component_master_ops kirin_drm_ops = {
 245         .bind = kirin_drm_bind,
 246         .unbind = kirin_drm_unbind,
 247 };
 248
 249 static struct device_node *kirin_get_remote_node(struct device_node *np)
 250 {
 251         struct device_node *endpoint, *remote;
 252
 253         /* get the first endpoint, in our case only one remote node
 254          * is connected to display controller.
 255          */
 256         endpoint = of_graph_get_next_endpoint(np, NULL);
 257         if (!endpoint) {
 258                 DRM_ERROR("no valid endpoint node\n");
 259                 return ERR_PTR(-ENODEV);
 260         }
 261         of_node_put(endpoint);
 262
 263         remote = of_graph_get_remote_port_parent(endpoint);
 264         if (!remote) {
 265                 DRM_ERROR("no valid remote node\n");
 266                 return ERR_PTR(-ENODEV);
 267         }
 268         of_node_put(remote);
 269
 270         if (!of_device_is_available(remote)) {
 271                 DRM_ERROR("not available for remote node\n");
 272                 return ERR_PTR(-ENODEV);
 273         }
 274
 275         return remote;
 276 }
 277
 278 static int kirin_drm_platform_probe(struct platform_device *pdev)
 279 {
 280         struct device *dev = &pdev->dev;
 281         struct device_node *np = dev->of_node;
 282         struct component_match *match = NULL;
 283         struct device_node *remote;
 284
 285         dc_ops = (struct kirin_dc_ops *)of_device_get_match_data(dev);
 286         if (!dc_ops) {
 287                 DRM_ERROR("failed to get dt id data\n");
 288                 return -EINVAL;
 289         }
 290
 291         remote = kirin_get_remote_node(np);
 292         if (IS_ERR(remote))
 293                 return PTR_ERR(remote);
 294
 295         component_match_add(dev, &match, compare_of, remote);
 296
 297         return component_master_add_with_match(dev, &kirin_drm_ops, match);
 298
 299         return 0;
 300 }
 301
 302 static int kirin_drm_platform_remove(struct platform_device *pdev)
 303 {
 304         component_master_del(&pdev->dev, &kirin_drm_ops);
 305         dc_ops = NULL;
 306         return 0;
 307 }
 308
 309 static const struct of_device_id kirin_drm_dt_ids[] = {
 310         { .compatible = "hisilicon,hi6220-ade",
 311           .data = &ade_dc_ops,
 312         },
 313         { /* end node */ },
 314 };
 315 MODULE_DEVICE_TABLE(of, kirin_drm_dt_ids);
 316
 317 static struct platform_driver kirin_drm_platform_driver = {
 318         .probe = kirin_drm_platform_probe,
 319         .remove = kirin_drm_platform_remove,
 320         .driver = {
 321                 .name = "kirin-drm",
 322                 .of_match_table = kirin_drm_dt_ids,
 323         },
 324 };
 325
 326 module_platform_driver(kirin_drm_platform_driver);
 327
 328 MODULE_AUTHOR("Xinliang Liu <xinliang.liu@linaro.org>");
 329 MODULE_AUTHOR("Xinliang Liu <z.liuxinliang@hisilicon.com>");
 330 MODULE_AUTHOR("Xinwei Kong <kong.kongxinwei@hisilicon.com>");
 331 MODULE_DESCRIPTION("hisilicon Kirin SoCs' DRM master driver");
 332 MODULE_LICENSE("GPL v2");