drivers/gpu/drm/vc4/vc4_drv.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (C) 2014-2015 Broadcom
   4  * Copyright (C) 2013 Red Hat
   5  */
   6
   7 /**
   8  * DOC: Broadcom VC4 Graphics Driver
   9  *
  10  * The Broadcom VideoCore 4 (present in the Raspberry Pi) contains a
  11  * OpenGL ES 2.0-compatible 3D engine called V3D, and a highly
  12  * configurable display output pipeline that supports HDMI, DSI, DPI,
  13  * and Composite TV output.
  14  *
  15  * The 3D engine also has an interface for submitting arbitrary
  16  * compute shader-style jobs using the same shader processor as is
  17  * used for vertex and fragment shaders in GLES 2.0.  However, given
  18  * that the hardware isn't able to expose any standard interfaces like
  19  * OpenGL compute shaders or OpenCL, it isn't supported by this
  20  * driver.
  21  */
  22
  23 #include <linux/clk.h>
  24 #include <linux/component.h>
  25 #include <linux/device.h>
  26 #include <linux/dma-mapping.h>
  27 #include <linux/io.h>
  28 #include <linux/module.h>
  29 #include <linux/of_platform.h>
  30 #include <linux/platform_device.h>
  31 #include <linux/pm_runtime.h>
  32
  33 #include <drm/drm_aperture.h>
  34 #include <drm/drm_atomic_helper.h>
  35 #include <drm/drm_drv.h>
  36 #include <drm/drm_fb_cma_helper.h>
  37 #include <drm/drm_fb_helper.h>
  38 #include <drm/drm_vblank.h>
  39
  40 #include <soc/bcm2835/raspberrypi-firmware.h>
  41
  42 #include "uapi/drm/vc4_drm.h"
  43
  44 #include "vc4_drv.h"
  45 #include "vc4_regs.h"
  46
  47 #define DRIVER_NAME "vc4"
  48 #define DRIVER_DESC "Broadcom VC4 graphics"
  49 #define DRIVER_DATE "20140616"
  50 #define DRIVER_MAJOR 0
  51 #define DRIVER_MINOR 0
  52 #define DRIVER_PATCHLEVEL 0
  53
  54 /* Helper function for mapping the regs on a platform device. */
  55 void __iomem *vc4_ioremap_regs(struct platform_device *dev, int index)
  56 {
  57         struct resource *res;
  58         void __iomem *map;
  59
  60         res = platform_get_resource(dev, IORESOURCE_MEM, index);
  61         map = devm_ioremap_resource(&dev->dev, res);
  62         if (IS_ERR(map))
  63                 return map;
  64
  65         return map;
  66 }
  67
  68 int vc4_dumb_fixup_args(struct drm_mode_create_dumb *args)
  69 {
  70         int min_pitch = DIV_ROUND_UP(args->width * args->bpp, 8);
  71
  72         if (args->pitch < min_pitch)
  73                 args->pitch = min_pitch;
  74
  75         if (args->size < args->pitch * args->height)
  76                 args->size = args->pitch * args->height;
  77
  78         return 0;
  79 }
  80
  81 static void vc5_gem_register_pid(struct drm_file *file_priv)
  82 {
  83         struct vc4_file *vc4file = file_priv->driver_priv;
  84         struct drm_vc5_file_private *driver_priv = &vc4file->priv;
  85
  86         if (!driver_priv->pid && !driver_priv->tgid) {
  87                 driver_priv->pid = task_pid_nr(current);
  88                 driver_priv->tgid = task_tgid_nr(current);
  89         } else {
  90                 if (driver_priv->pid != task_pid_nr(current))
  91                         DRM_DEBUG_KMS("wrong pid: %ld, %ld\n",
  92                                         (unsigned long)driver_priv->pid,
  93                                         (unsigned long)task_pid_nr(current));
  94                 if (driver_priv->tgid != task_tgid_nr(current))
  95                         DRM_DEBUG_KMS("wrong tgid: %ld, %ld\n",
  96                                         (unsigned long)driver_priv->tgid,
  97                                         (unsigned long)task_tgid_nr(current));
  98         }
  99 }
 100
 101 int vc5_drm_gem_prime_fd_to_handle(struct drm_device *dev,
 102                                    struct drm_file *file_priv, int prime_fd,
 103                                    uint32_t *handle)
 104 {
 105         int ret;
 106
 107         ret = drm_gem_prime_fd_to_handle(dev, file_priv, prime_fd, handle);
 108         if (ret < 0)
 109                 return ret;
 110
 111         vc5_gem_register_pid(file_priv);
 112
 113         return ret;
 114 }
 115
 116 static int vc4_dumb_create(struct drm_file *file_priv,
 117                            struct drm_device *dev,
 118                            struct drm_mode_create_dumb *args)
 119 {
 120         int ret;
 121
 122         ret = vc4_dumb_fixup_args(args);
 123         if (ret)
 124                 return ret;
 125
 126         ret = drm_gem_cma_dumb_create_internal(file_priv, dev, args);
 127         if (!ret)
 128                 vc5_gem_register_pid(file_priv);
 129
 130         return ret;
 131 }
 132
 133 static int vc4_get_param_ioctl(struct drm_device *dev, void *data,
 134                                struct drm_file *file_priv)
 135 {
 136         struct vc4_dev *vc4 = to_vc4_dev(dev);
 137         struct drm_vc4_get_param *args = data;
 138         int ret;
 139
 140         if (args->pad != 0)
 141                 return -EINVAL;
 142
 143         if (WARN_ON_ONCE(vc4->is_vc5))
 144                 return -ENODEV;
 145
 146         if (!vc4->v3d)
 147                 return -ENODEV;
 148
 149         switch (args->param) {
 150         case DRM_VC4_PARAM_V3D_IDENT0:
 151                 ret = vc4_v3d_pm_get(vc4);
 152                 if (ret)
 153                         return ret;
 154                 args->value = V3D_READ(V3D_IDENT0);
 155                 vc4_v3d_pm_put(vc4);
 156                 break;
 157         case DRM_VC4_PARAM_V3D_IDENT1:
 158                 ret = vc4_v3d_pm_get(vc4);
 159                 if (ret)
 160                         return ret;
 161                 args->value = V3D_READ(V3D_IDENT1);
 162                 vc4_v3d_pm_put(vc4);
 163                 break;
 164         case DRM_VC4_PARAM_V3D_IDENT2:
 165                 ret = vc4_v3d_pm_get(vc4);
 166                 if (ret)
 167                         return ret;
 168                 args->value = V3D_READ(V3D_IDENT2);
 169                 vc4_v3d_pm_put(vc4);
 170                 break;
 171         case DRM_VC4_PARAM_SUPPORTS_BRANCHES:
 172         case DRM_VC4_PARAM_SUPPORTS_ETC1:
 173         case DRM_VC4_PARAM_SUPPORTS_THREADED_FS:
 174         case DRM_VC4_PARAM_SUPPORTS_FIXED_RCL_ORDER:
 175         case DRM_VC4_PARAM_SUPPORTS_MADVISE:
 176         case DRM_VC4_PARAM_SUPPORTS_PERFMON:
 177                 args->value = true;
 178                 break;
 179         default:
 180                 DRM_DEBUG("Unknown parameter %d\n", args->param);
 181                 return -EINVAL;
 182         }
 183
 184         return 0;
 185 }
 186
 187 static int vc4_open(struct drm_device *dev, struct drm_file *file)
 188 {
 189         struct vc4_dev *vc4 = to_vc4_dev(dev);
 190         struct vc4_file *vc4file;
 191
 192         if (WARN_ON_ONCE(vc4->is_vc5))
 193                 return -ENODEV;
 194
 195         vc4file = kzalloc(sizeof(*vc4file), GFP_KERNEL);
 196         if (!vc4file)
 197                 return -ENOMEM;
 198         vc4file->dev = vc4;
 199
 200         vc4_perfmon_open_file(vc4file);
 201         file->driver_priv = vc4file;
 202         return 0;
 203 }
 204
 205 static void vc4_close(struct drm_device *dev, struct drm_file *file)
 206 {
 207         struct vc4_dev *vc4 = to_vc4_dev(dev);
 208         struct vc4_file *vc4file = file->driver_priv;
 209
 210         if (WARN_ON_ONCE(vc4->is_vc5))
 211                 return;
 212
 213         if (vc4file->bin_bo_used)
 214                 vc4_v3d_bin_bo_put(vc4);
 215
 216         vc4_perfmon_close_file(vc4file);
 217         kfree(vc4file);
 218 }
 219
 220 static int vc5_open(struct drm_device *dev, struct drm_file *file)
 221 {
 222         struct vc4_dev *vc4 = to_vc4_dev(dev);
 223         struct vc4_file *vc4file;
 224
 225         vc4file = kzalloc(sizeof(*vc4file), GFP_KERNEL);
 226         if (!vc4file)
 227                 return -ENOMEM;
 228         vc4file->dev = vc4;
 229
 230         file->driver_priv = vc4file;
 231         return 0;
 232 }
 233
 234 static void vc5_close(struct drm_device *dev, struct drm_file *file)
 235 {
 236         struct vc4_file *vc4file = file->driver_priv;
 237
 238         kfree(vc4file);
 239 }
 240
 241 DEFINE_DRM_GEM_FOPS(vc4_drm_fops);
 242
 243 static const struct drm_ioctl_desc vc4_drm_ioctls[] = {
 244         DRM_IOCTL_DEF_DRV(VC4_SUBMIT_CL, vc4_submit_cl_ioctl, DRM_RENDER_ALLOW),
 245         DRM_IOCTL_DEF_DRV(VC4_WAIT_SEQNO, vc4_wait_seqno_ioctl, DRM_RENDER_ALLOW),
 246         DRM_IOCTL_DEF_DRV(VC4_WAIT_BO, vc4_wait_bo_ioctl, DRM_RENDER_ALLOW),
 247         DRM_IOCTL_DEF_DRV(VC4_CREATE_BO, vc4_create_bo_ioctl, DRM_RENDER_ALLOW),
 248         DRM_IOCTL_DEF_DRV(VC4_MMAP_BO, vc4_mmap_bo_ioctl, DRM_RENDER_ALLOW),
 249         DRM_IOCTL_DEF_DRV(VC4_CREATE_SHADER_BO, vc4_create_shader_bo_ioctl, DRM_RENDER_ALLOW),
 250         DRM_IOCTL_DEF_DRV(VC4_GET_HANG_STATE, vc4_get_hang_state_ioctl,
 251                           DRM_ROOT_ONLY),
 252         DRM_IOCTL_DEF_DRV(VC4_GET_PARAM, vc4_get_param_ioctl, DRM_RENDER_ALLOW),
 253         DRM_IOCTL_DEF_DRV(VC4_SET_TILING, vc4_set_tiling_ioctl, DRM_RENDER_ALLOW),
 254         DRM_IOCTL_DEF_DRV(VC4_GET_TILING, vc4_get_tiling_ioctl, DRM_RENDER_ALLOW),
 255         DRM_IOCTL_DEF_DRV(VC4_LABEL_BO, vc4_label_bo_ioctl, DRM_RENDER_ALLOW),
 256         DRM_IOCTL_DEF_DRV(VC4_GEM_MADVISE, vc4_gem_madvise_ioctl, DRM_RENDER_ALLOW),
 257         DRM_IOCTL_DEF_DRV(VC4_PERFMON_CREATE, vc4_perfmon_create_ioctl, DRM_RENDER_ALLOW),
 258         DRM_IOCTL_DEF_DRV(VC4_PERFMON_DESTROY, vc4_perfmon_destroy_ioctl, DRM_RENDER_ALLOW),
 259         DRM_IOCTL_DEF_DRV(VC4_PERFMON_GET_VALUES, vc4_perfmon_get_values_ioctl, DRM_RENDER_ALLOW),
 260 };
 261
 262 static const struct drm_driver vc4_drm_driver = {
 263         .driver_features = (DRIVER_MODESET |
 264                             DRIVER_ATOMIC |
 265                             DRIVER_GEM |
 266                             DRIVER_RENDER |
 267                             DRIVER_SYNCOBJ),
 268         .open = vc4_open,
 269         .postclose = vc4_close,
 270
 271 #if defined(CONFIG_DEBUG_FS)
 272         .debugfs_init = vc4_debugfs_init,
 273 #endif
 274
 275         .gem_create_object = vc4_create_object,
 276
 277         DRM_GEM_CMA_DRIVER_OPS_WITH_DUMB_CREATE(vc4_bo_dumb_create),
 278
 279         .ioctls = vc4_drm_ioctls,
 280         .num_ioctls = ARRAY_SIZE(vc4_drm_ioctls),
 281         .fops = &vc4_drm_fops,
 282
 283         .name = DRIVER_NAME,
 284         .desc = DRIVER_DESC,
 285         .date = DRIVER_DATE,
 286         .major = DRIVER_MAJOR,
 287         .minor = DRIVER_MINOR,
 288         .patchlevel = DRIVER_PATCHLEVEL,
 289 };
 290
 291 static const struct drm_driver vc5_drm_driver = {
 292         .driver_features = (DRIVER_MODESET |
 293                             DRIVER_ATOMIC |
 294                             DRIVER_GEM),
 295
 296         .open = vc5_open,
 297         .postclose = vc5_close,
 298 #if defined(CONFIG_DEBUG_FS)
 299         .debugfs_init = vc4_debugfs_init,
 300 #endif
 301
 302         DRM_GEM_CMA_DRIVER_OPS_WITH_DUMB_CREATE(vc4_dumb_create),
 303
 304         .prime_fd_to_handle = vc5_drm_gem_prime_fd_to_handle,
 305         .fops = &vc4_drm_fops,
 306
 307         .name = DRIVER_NAME,
 308         .desc = DRIVER_DESC,
 309         .date = DRIVER_DATE,
 310         .major = DRIVER_MAJOR,
 311         .minor = DRIVER_MINOR,
 312         .patchlevel = DRIVER_PATCHLEVEL,
 313 };
 314
 315 static int compare_dev(struct device *dev, void *data)
 316 {
 317         return dev == data;
 318 }
 319
 320 static void vc4_match_add_drivers(struct device *dev,
 321                                   struct component_match **match,
 322                                   struct platform_driver *const *drivers,
 323                                   int count)
 324 {
 325         int i;
 326
 327         for (i = 0; i < count; i++) {
 328                 struct device_driver *drv = &drivers[i]->driver;
 329                 struct device *p = NULL, *d;
 330
 331                 while ((d = platform_find_device_by_driver(p, drv))) {
 332                         put_device(p);
 333                         component_match_add(dev, match, compare_dev, d);
 334                         p = d;
 335                 }
 336                 put_device(p);
 337         }
 338 }
 339
 340 static void vc4_component_unbind_all(void *ptr)
 341 {
 342         struct vc4_dev *vc4 = ptr;
 343
 344         component_unbind_all(vc4->dev, &vc4->base);
 345 }
 346
 347 const struct of_device_id vc4_dma_range_matches[] = {
 348         { .compatible = "brcm,bcm2835-hvs" },
 349         { .compatible = "brcm,bcm2711-hvs" },
 350         { .compatible = "raspberrypi,rpi-firmware-kms" },
 351         { .compatible = "brcm,bcm2835-v3d" },
 352         { .compatible = "brcm,cygnus-v3d" },
 353         { .compatible = "brcm,vc4-v3d" },
 354         {}
 355 };
 356
 357 /*
 358  * we need this helper function for determining presence of fkms
 359  * before it's been bound
 360  */
 361 static bool firmware_kms(void)
 362 {
 363         return of_device_is_available(of_find_compatible_node(NULL, NULL,
 364                "raspberrypi,rpi-firmware-kms")) ||
 365                of_device_is_available(of_find_compatible_node(NULL, NULL,
 366                "raspberrypi,rpi-firmware-kms-2711"));
 367 }
 368
 369 int vc5_bo_debugfs_init(struct drm_minor *minor)
 370 {
 371         struct drm_device *drm = minor->dev;
 372         struct vc4_dev *vc4 = to_vc4_dev(drm);
 373         int ret;
 374
 375         if (!vc4->is_vc5)
 376                 return -ENODEV;
 377
 378         ret = vc4_debugfs_add_file(minor, "gem_info",
 379                                    vc5_debugfs_gem_info, NULL);
 380         if (ret)
 381                 return ret;
 382
 383         return 0;
 384 }
 385
 386 static int vc4_drm_bind(struct device *dev)
 387 {
 388         struct platform_device *pdev = to_platform_device(dev);
 389         const struct drm_driver *driver;
 390         struct rpi_firmware *firmware = NULL;
 391         struct drm_device *drm;
 392         struct vc4_dev *vc4;
 393         struct device_node *node;
 394         struct drm_crtc *crtc;
 395         bool is_vc5;
 396         int ret = 0;
 397
 398         dev->coherent_dma_mask = DMA_BIT_MASK(32);
 399
 400         is_vc5 = of_device_is_compatible(dev->of_node, "brcm,bcm2711-vc5");
 401         if (is_vc5)
 402                 driver = &vc5_drm_driver;
 403         else
 404                 driver = &vc4_drm_driver;
 405
 406         node = of_find_matching_node_and_match(NULL, vc4_dma_range_matches,
 407                                                NULL);
 408         if (node) {
 409                 ret = of_dma_configure(dev, node, true);
 410                 of_node_put(node);
 411
 412                 if (ret)
 413                         return ret;
 414         }
 415
 416         vc4 = devm_drm_dev_alloc(dev, driver, struct vc4_dev, base);
 417         if (IS_ERR(vc4))
 418                 return PTR_ERR(vc4);
 419         vc4->is_vc5 = is_vc5;
 420         vc4->dev = dev;
 421
 422         drm = &vc4->base;
 423         platform_set_drvdata(pdev, drm);
 424         INIT_LIST_HEAD(&vc4->debugfs_list);
 425
 426         if (!is_vc5) {
 427                 ret = drmm_mutex_init(drm, &vc4->bin_bo_lock);
 428                 if (ret)
 429                         return ret;
 430
 431                 ret = vc4_bo_cache_init(drm);
 432                 if (ret)
 433                         return ret;
 434         }
 435
 436         ret = drmm_mode_config_init(drm);
 437         if (ret)
 438                 return ret;
 439
 440         if (!is_vc5) {
 441                 ret = vc4_gem_init(drm);
 442                 if (ret)
 443                         return ret;
 444         }
 445
 446         node = of_find_compatible_node(NULL, NULL, "raspberrypi,bcm2835-firmware");
 447         if (node) {
 448                 firmware = rpi_firmware_get(node);
 449                 of_node_put(node);
 450
 451                 if (!firmware)
 452                         return -EPROBE_DEFER;
 453         }
 454
 455         ret = drm_aperture_remove_framebuffers(false, driver);
 456         if (ret)
 457                 return ret;
 458
 459         if (firmware && !firmware_kms()) {
 460                 ret = rpi_firmware_property(firmware,
 461                                             RPI_FIRMWARE_NOTIFY_DISPLAY_DONE,
 462                                             NULL, 0);
 463                 if (ret)
 464                         drm_warn(drm, "Couldn't stop firmware display driver: %d\n", ret);
 465
 466                 rpi_firmware_put(firmware);
 467         }
 468
 469         ret = component_bind_all(dev, drm);
 470         if (ret)
 471                 return ret;
 472
 473         ret = devm_add_action_or_reset(dev, vc4_component_unbind_all, vc4);
 474         if (ret)
 475                 return ret;
 476
 477         if (!vc4->firmware_kms) {
 478                 ret = vc4_plane_create_additional_planes(drm);
 479                 if (ret)
 480                         goto unbind_all;
 481         }
 482
 483         ret = vc4_kms_load(drm);
 484         if (ret < 0)
 485                 goto unbind_all;
 486
 487         if (!vc4->firmware_kms) {
 488                 drm_for_each_crtc(crtc, drm)
 489                         vc4_crtc_disable_at_boot(crtc);
 490         }
 491
 492         ret = drm_dev_register(drm, 0);
 493         if (ret < 0)
 494                 goto unbind_all;
 495
 496         drm_fbdev_generic_setup(drm, 16);
 497
 498         return 0;
 499
 500 unbind_all:
 501         return ret;
 502 }
 503
 504 static void vc4_drm_unbind(struct device *dev)
 505 {
 506         struct drm_device *drm = dev_get_drvdata(dev);
 507
 508         drm_dev_unplug(drm);
 509         drm_atomic_helper_shutdown(drm);
 510 }
 511
 512 static const struct component_master_ops vc4_drm_ops = {
 513         .bind = vc4_drm_bind,
 514         .unbind = vc4_drm_unbind,
 515 };
 516
 517 /*
 518  * This list determines the binding order of our components, and we have
 519  * a few constraints:
 520  *   - The TXP driver needs to be bound before the PixelValves (CRTC)
 521  *     but after the HVS to set the possible_crtc field properly
 522  *   - The HDMI driver needs to be bound after the HVS so that we can
 523  *     lookup the HVS maximum core clock rate and figure out if we
 524  *     support 4kp60 or not.
 525  */
 526 static struct platform_driver *const component_drivers[] = {
 527         &vc4_hvs_driver,
 528         &vc4_hdmi_driver,
 529         &vc4_vec_driver,
 530         &vc4_dpi_driver,
 531         &vc4_dsi_driver,
 532         &vc4_txp_driver,
 533         &vc4_crtc_driver,
 534         &vc4_firmware_kms_driver,
 535         &vc4_v3d_driver,
 536 };
 537
 538 static int vc4_platform_drm_probe(struct platform_device *pdev)
 539 {
 540         struct component_match *match = NULL;
 541         struct device *dev = &pdev->dev;
 542
 543         vc4_match_add_drivers(dev, &match,
 544                               component_drivers, ARRAY_SIZE(component_drivers));
 545
 546         return component_master_add_with_match(dev, &vc4_drm_ops, match);
 547 }
 548
 549 static int vc4_platform_drm_remove(struct platform_device *pdev)
 550 {
 551         component_master_del(&pdev->dev, &vc4_drm_ops);
 552
 553         return 0;
 554 }
 555
 556 static const struct of_device_id vc4_of_match[] = {
 557         { .compatible = "brcm,bcm2711-vc5", },
 558         { .compatible = "brcm,bcm2835-vc4", },
 559         { .compatible = "brcm,cygnus-vc4", },
 560         {},
 561 };
 562 MODULE_DEVICE_TABLE(of, vc4_of_match);
 563
 564 static struct platform_driver vc4_platform_driver = {
 565         .probe          = vc4_platform_drm_probe,
 566         .remove         = vc4_platform_drm_remove,
 567         .driver         = {
 568                 .name   = "vc4-drm",
 569                 .of_match_table = vc4_of_match,
 570         },
 571 };
 572
 573 static int __init vc4_drm_register(void)
 574 {
 575         int ret;
 576
 577         ret = platform_register_drivers(component_drivers,
 578                                         ARRAY_SIZE(component_drivers));
 579         if (ret)
 580                 return ret;
 581
 582         ret = platform_driver_register(&vc4_platform_driver);
 583         if (ret)
 584                 platform_unregister_drivers(component_drivers,
 585                                             ARRAY_SIZE(component_drivers));
 586
 587         return ret;
 588 }
 589
 590 static void __exit vc4_drm_unregister(void)
 591 {
 592         platform_unregister_drivers(component_drivers,
 593                                     ARRAY_SIZE(component_drivers));
 594         platform_driver_unregister(&vc4_platform_driver);
 595 }
 596
 597 module_init(vc4_drm_register);
 598 module_exit(vc4_drm_unregister);
 599
 600 MODULE_ALIAS("platform:vc4-drm");
 601 MODULE_SOFTDEP("pre: snd-soc-hdmi-codec");
 602 MODULE_DESCRIPTION("Broadcom VC4 DRM Driver");
 603 MODULE_AUTHOR("Eric Anholt <eric@anholt.net>");
 604 MODULE_LICENSE("GPL v2");