drm/vc4/vc4_drv.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Copyright (C) 2014-2015 Broadcom
0004  * Copyright (C) 2013 Red Hat
0005  */
0006
0007 /**
0008  * DOC: Broadcom VC4 Graphics Driver
0009  *
0010  * The Broadcom VideoCore 4 (present in the Raspberry Pi) contains a
0011  * OpenGL ES 2.0-compatible 3D engine called V3D, and a highly
0012  * configurable display output pipeline that supports HDMI, DSI, DPI,
0013  * and Composite TV output.
0014  *
0015  * The 3D engine also has an interface for submitting arbitrary
0016  * compute shader-style jobs using the same shader processor as is
0017  * used for vertex and fragment shaders in GLES 2.0.  However, given
0018  * that the hardware isn't able to expose any standard interfaces like
0019  * OpenGL compute shaders or OpenCL, it isn't supported by this
0020  * driver.
0021  */
0022
0023 #include <linux/clk.h>
0024 #include <linux/component.h>
0025 #include <linux/device.h>
0026 #include <linux/dma-mapping.h>
0027 #include <linux/io.h>
0028 #include <linux/module.h>
0029 #include <linux/of_platform.h>
0030 #include <linux/platform_device.h>
0031 #include <linux/pm_runtime.h>
0032
0033 #include <drm/drm_aperture.h>
0034 #include <drm/drm_atomic_helper.h>
0035 #include <drm/drm_drv.h>
0036 #include <drm/drm_fb_cma_helper.h>
0037 #include <drm/drm_fb_helper.h>
0038 #include <drm/drm_vblank.h>
0039
0040 #include <soc/bcm2835/raspberrypi-firmware.h>
0041
0042 #include "uapi/drm/vc4_drm.h"
0043
0044 #include "vc4_drv.h"
0045 #include "vc4_regs.h"
0046
0047 #define DRIVER_NAME "vc4"
0048 #define DRIVER_DESC "Broadcom VC4 graphics"
0049 #define DRIVER_DATE "20140616"
0050 #define DRIVER_MAJOR 0
0051 #define DRIVER_MINOR 0
0052 #define DRIVER_PATCHLEVEL 0
0053
0054 /* Helper function for mapping the regs on a platform device. */
0055 void __iomem *vc4_ioremap_regs(struct platform_device *pdev, int index)
0056 {
0057     void __iomem *map;
0058
0059     map = devm_platform_ioremap_resource(pdev, index);
0060     if (IS_ERR(map))
0061         return map;
0062
0063     return map;
0064 }
0065
0066 int vc4_dumb_fixup_args(struct drm_mode_create_dumb *args)
0067 {
0068     int min_pitch = DIV_ROUND_UP(args->width * args->bpp, 8);
0069
0070     if (args->pitch < min_pitch)
0071         args->pitch = min_pitch;
0072
0073     if (args->size < args->pitch * args->height)
0074         args->size = args->pitch * args->height;
0075
0076     return 0;
0077 }
0078
0079 static int vc5_dumb_create(struct drm_file *file_priv,
0080                struct drm_device *dev,
0081                struct drm_mode_create_dumb *args)
0082 {
0083     int ret;
0084
0085     ret = vc4_dumb_fixup_args(args);
0086     if (ret)
0087         return ret;
0088
0089     return drm_gem_cma_dumb_create_internal(file_priv, dev, args);
0090 }
0091
0092 static int vc4_get_param_ioctl(struct drm_device *dev, void *data,
0093                    struct drm_file *file_priv)
0094 {
0095     struct vc4_dev *vc4 = to_vc4_dev(dev);
0096     struct drm_vc4_get_param *args = data;
0097     int ret;
0098
0099     if (args->pad != 0)
0100         return -EINVAL;
0101
0102     if (WARN_ON_ONCE(vc4->is_vc5))
0103         return -ENODEV;
0104
0105     if (!vc4->v3d)
0106         return -ENODEV;
0107
0108     switch (args->param) {
0109     case DRM_VC4_PARAM_V3D_IDENT0:
0110         ret = vc4_v3d_pm_get(vc4);
0111         if (ret)
0112             return ret;
0113         args->value = V3D_READ(V3D_IDENT0);
0114         vc4_v3d_pm_put(vc4);
0115         break;
0116     case DRM_VC4_PARAM_V3D_IDENT1:
0117         ret = vc4_v3d_pm_get(vc4);
0118         if (ret)
0119             return ret;
0120         args->value = V3D_READ(V3D_IDENT1);
0121         vc4_v3d_pm_put(vc4);
0122         break;
0123     case DRM_VC4_PARAM_V3D_IDENT2:
0124         ret = vc4_v3d_pm_get(vc4);
0125         if (ret)
0126             return ret;
0127         args->value = V3D_READ(V3D_IDENT2);
0128         vc4_v3d_pm_put(vc4);
0129         break;
0130     case DRM_VC4_PARAM_SUPPORTS_BRANCHES:
0131     case DRM_VC4_PARAM_SUPPORTS_ETC1:
0132     case DRM_VC4_PARAM_SUPPORTS_THREADED_FS:
0133     case DRM_VC4_PARAM_SUPPORTS_FIXED_RCL_ORDER:
0134     case DRM_VC4_PARAM_SUPPORTS_MADVISE:
0135     case DRM_VC4_PARAM_SUPPORTS_PERFMON:
0136         args->value = true;
0137         break;
0138     default:
0139         DRM_DEBUG("Unknown parameter %d\n", args->param);
0140         return -EINVAL;
0141     }
0142
0143     return 0;
0144 }
0145
0146 static int vc4_open(struct drm_device *dev, struct drm_file *file)
0147 {
0148     struct vc4_dev *vc4 = to_vc4_dev(dev);
0149     struct vc4_file *vc4file;
0150
0151     if (WARN_ON_ONCE(vc4->is_vc5))
0152         return -ENODEV;
0153
0154     vc4file = kzalloc(sizeof(*vc4file), GFP_KERNEL);
0155     if (!vc4file)
0156         return -ENOMEM;
0157     vc4file->dev = vc4;
0158
0159     vc4_perfmon_open_file(vc4file);
0160     file->driver_priv = vc4file;
0161     return 0;
0162 }
0163
0164 static void vc4_close(struct drm_device *dev, struct drm_file *file)
0165 {
0166     struct vc4_dev *vc4 = to_vc4_dev(dev);
0167     struct vc4_file *vc4file = file->driver_priv;
0168
0169     if (WARN_ON_ONCE(vc4->is_vc5))
0170         return;
0171
0172     if (vc4file->bin_bo_used)
0173         vc4_v3d_bin_bo_put(vc4);
0174
0175     vc4_perfmon_close_file(vc4file);
0176     kfree(vc4file);
0177 }
0178
0179 DEFINE_DRM_GEM_FOPS(vc4_drm_fops);
0180
0181 static const struct drm_ioctl_desc vc4_drm_ioctls[] = {
0182     DRM_IOCTL_DEF_DRV(VC4_SUBMIT_CL, vc4_submit_cl_ioctl, DRM_RENDER_ALLOW),
0183     DRM_IOCTL_DEF_DRV(VC4_WAIT_SEQNO, vc4_wait_seqno_ioctl, DRM_RENDER_ALLOW),
0184     DRM_IOCTL_DEF_DRV(VC4_WAIT_BO, vc4_wait_bo_ioctl, DRM_RENDER_ALLOW),
0185     DRM_IOCTL_DEF_DRV(VC4_CREATE_BO, vc4_create_bo_ioctl, DRM_RENDER_ALLOW),
0186     DRM_IOCTL_DEF_DRV(VC4_MMAP_BO, vc4_mmap_bo_ioctl, DRM_RENDER_ALLOW),
0187     DRM_IOCTL_DEF_DRV(VC4_CREATE_SHADER_BO, vc4_create_shader_bo_ioctl, DRM_RENDER_ALLOW),
0188     DRM_IOCTL_DEF_DRV(VC4_GET_HANG_STATE, vc4_get_hang_state_ioctl,
0189               DRM_ROOT_ONLY),
0190     DRM_IOCTL_DEF_DRV(VC4_GET_PARAM, vc4_get_param_ioctl, DRM_RENDER_ALLOW),
0191     DRM_IOCTL_DEF_DRV(VC4_SET_TILING, vc4_set_tiling_ioctl, DRM_RENDER_ALLOW),
0192     DRM_IOCTL_DEF_DRV(VC4_GET_TILING, vc4_get_tiling_ioctl, DRM_RENDER_ALLOW),
0193     DRM_IOCTL_DEF_DRV(VC4_LABEL_BO, vc4_label_bo_ioctl, DRM_RENDER_ALLOW),
0194     DRM_IOCTL_DEF_DRV(VC4_GEM_MADVISE, vc4_gem_madvise_ioctl, DRM_RENDER_ALLOW),
0195     DRM_IOCTL_DEF_DRV(VC4_PERFMON_CREATE, vc4_perfmon_create_ioctl, DRM_RENDER_ALLOW),
0196     DRM_IOCTL_DEF_DRV(VC4_PERFMON_DESTROY, vc4_perfmon_destroy_ioctl, DRM_RENDER_ALLOW),
0197     DRM_IOCTL_DEF_DRV(VC4_PERFMON_GET_VALUES, vc4_perfmon_get_values_ioctl, DRM_RENDER_ALLOW),
0198 };
0199
0200 static const struct drm_driver vc4_drm_driver = {
0201     .driver_features = (DRIVER_MODESET |
0202                 DRIVER_ATOMIC |
0203                 DRIVER_GEM |
0204                 DRIVER_RENDER |
0205                 DRIVER_SYNCOBJ),
0206     .open = vc4_open,
0207     .postclose = vc4_close,
0208
0209 #if defined(CONFIG_DEBUG_FS)
0210     .debugfs_init = vc4_debugfs_init,
0211 #endif
0212
0213     .gem_create_object = vc4_create_object,
0214
0215     DRM_GEM_CMA_DRIVER_OPS_WITH_DUMB_CREATE(vc4_bo_dumb_create),
0216
0217     .ioctls = vc4_drm_ioctls,
0218     .num_ioctls = ARRAY_SIZE(vc4_drm_ioctls),
0219     .fops = &vc4_drm_fops,
0220
0221     .name = DRIVER_NAME,
0222     .desc = DRIVER_DESC,
0223     .date = DRIVER_DATE,
0224     .major = DRIVER_MAJOR,
0225     .minor = DRIVER_MINOR,
0226     .patchlevel = DRIVER_PATCHLEVEL,
0227 };
0228
0229 static const struct drm_driver vc5_drm_driver = {
0230     .driver_features = (DRIVER_MODESET |
0231                 DRIVER_ATOMIC |
0232                 DRIVER_GEM),
0233
0234 #if defined(CONFIG_DEBUG_FS)
0235     .debugfs_init = vc4_debugfs_init,
0236 #endif
0237
0238     DRM_GEM_CMA_DRIVER_OPS_WITH_DUMB_CREATE(vc5_dumb_create),
0239
0240     .fops = &vc4_drm_fops,
0241
0242     .name = DRIVER_NAME,
0243     .desc = DRIVER_DESC,
0244     .date = DRIVER_DATE,
0245     .major = DRIVER_MAJOR,
0246     .minor = DRIVER_MINOR,
0247     .patchlevel = DRIVER_PATCHLEVEL,
0248 };
0249
0250 static void vc4_match_add_drivers(struct device *dev,
0251                   struct component_match **match,
0252                   struct platform_driver *const *drivers,
0253                   int count)
0254 {
0255     int i;
0256
0257     for (i = 0; i < count; i++) {
0258         struct device_driver *drv = &drivers[i]->driver;
0259         struct device *p = NULL, *d;
0260
0261         while ((d = platform_find_device_by_driver(p, drv))) {
0262             put_device(p);
0263             component_match_add(dev, match, component_compare_dev, d);
0264             p = d;
0265         }
0266         put_device(p);
0267     }
0268 }
0269
0270 static const struct of_device_id vc4_dma_range_matches[] = {
0271     { .compatible = "brcm,bcm2711-hvs" },
0272     { .compatible = "brcm,bcm2835-hvs" },
0273     { .compatible = "brcm,bcm2835-v3d" },
0274     { .compatible = "brcm,cygnus-v3d" },
0275     { .compatible = "brcm,vc4-v3d" },
0276     {}
0277 };
0278
0279 static int vc4_drm_bind(struct device *dev)
0280 {
0281     struct platform_device *pdev = to_platform_device(dev);
0282     const struct drm_driver *driver;
0283     struct rpi_firmware *firmware = NULL;
0284     struct drm_device *drm;
0285     struct vc4_dev *vc4;
0286     struct device_node *node;
0287     struct drm_crtc *crtc;
0288     bool is_vc5;
0289     int ret = 0;
0290
0291     dev->coherent_dma_mask = DMA_BIT_MASK(32);
0292
0293     is_vc5 = of_device_is_compatible(dev->of_node, "brcm,bcm2711-vc5");
0294     if (is_vc5)
0295         driver = &vc5_drm_driver;
0296     else
0297         driver = &vc4_drm_driver;
0298
0299     node = of_find_matching_node_and_match(NULL, vc4_dma_range_matches,
0300                            NULL);
0301     if (node) {
0302         ret = of_dma_configure(dev, node, true);
0303         of_node_put(node);
0304
0305         if (ret)
0306             return ret;
0307     }
0308
0309     vc4 = devm_drm_dev_alloc(dev, driver, struct vc4_dev, base);
0310     if (IS_ERR(vc4))
0311         return PTR_ERR(vc4);
0312     vc4->is_vc5 = is_vc5;
0313
0314     drm = &vc4->base;
0315     platform_set_drvdata(pdev, drm);
0316     INIT_LIST_HEAD(&vc4->debugfs_list);
0317
0318     if (!is_vc5) {
0319         mutex_init(&vc4->bin_bo_lock);
0320
0321         ret = vc4_bo_cache_init(drm);
0322         if (ret)
0323             return ret;
0324     }
0325
0326     ret = drmm_mode_config_init(drm);
0327     if (ret)
0328         return ret;
0329
0330     if (!is_vc5) {
0331         ret = vc4_gem_init(drm);
0332         if (ret)
0333             return ret;
0334     }
0335
0336     node = of_find_compatible_node(NULL, NULL, "raspberrypi,bcm2835-firmware");
0337     if (node) {
0338         firmware = rpi_firmware_get(node);
0339         of_node_put(node);
0340
0341         if (!firmware)
0342             return -EPROBE_DEFER;
0343     }
0344
0345     ret = drm_aperture_remove_framebuffers(false, driver);
0346     if (ret)
0347         return ret;
0348
0349     if (firmware) {
0350         ret = rpi_firmware_property(firmware,
0351                         RPI_FIRMWARE_NOTIFY_DISPLAY_DONE,
0352                         NULL, 0);
0353         if (ret)
0354             drm_warn(drm, "Couldn't stop firmware display driver: %d\n", ret);
0355
0356         rpi_firmware_put(firmware);
0357     }
0358
0359     ret = component_bind_all(dev, drm);
0360     if (ret)
0361         return ret;
0362
0363     ret = vc4_plane_create_additional_planes(drm);
0364     if (ret)
0365         goto unbind_all;
0366
0367     ret = vc4_kms_load(drm);
0368     if (ret < 0)
0369         goto unbind_all;
0370
0371     drm_for_each_crtc(crtc, drm)
0372         vc4_crtc_disable_at_boot(crtc);
0373
0374     ret = drm_dev_register(drm, 0);
0375     if (ret < 0)
0376         goto unbind_all;
0377
0378     drm_fbdev_generic_setup(drm, 16);
0379
0380     return 0;
0381
0382 unbind_all:
0383     component_unbind_all(dev, drm);
0384
0385     return ret;
0386 }
0387
0388 static void vc4_drm_unbind(struct device *dev)
0389 {
0390     struct drm_device *drm = dev_get_drvdata(dev);
0391
0392     drm_dev_unregister(drm);
0393
0394     drm_atomic_helper_shutdown(drm);
0395 }
0396
0397 static const struct component_master_ops vc4_drm_ops = {
0398     .bind = vc4_drm_bind,
0399     .unbind = vc4_drm_unbind,
0400 };
0401
0402 /*
0403  * This list determines the binding order of our components, and we have
0404  * a few constraints:
0405  *   - The TXP driver needs to be bound before the PixelValves (CRTC)
0406  *     but after the HVS to set the possible_crtc field properly
0407  *   - The HDMI driver needs to be bound after the HVS so that we can
0408  *     lookup the HVS maximum core clock rate and figure out if we
0409  *     support 4kp60 or not.
0410  */
0411 static struct platform_driver *const component_drivers[] = {
0412     &vc4_hvs_driver,
0413     &vc4_hdmi_driver,
0414     &vc4_vec_driver,
0415     &vc4_dpi_driver,
0416     &vc4_dsi_driver,
0417     &vc4_txp_driver,
0418     &vc4_crtc_driver,
0419     &vc4_v3d_driver,
0420 };
0421
0422 static int vc4_platform_drm_probe(struct platform_device *pdev)
0423 {
0424     struct component_match *match = NULL;
0425     struct device *dev = &pdev->dev;
0426
0427     vc4_match_add_drivers(dev, &match,
0428                   component_drivers, ARRAY_SIZE(component_drivers));
0429
0430     return component_master_add_with_match(dev, &vc4_drm_ops, match);
0431 }
0432
0433 static int vc4_platform_drm_remove(struct platform_device *pdev)
0434 {
0435     component_master_del(&pdev->dev, &vc4_drm_ops);
0436
0437     return 0;
0438 }
0439
0440 static const struct of_device_id vc4_of_match[] = {
0441     { .compatible = "brcm,bcm2711-vc5", },
0442     { .compatible = "brcm,bcm2835-vc4", },
0443     { .compatible = "brcm,cygnus-vc4", },
0444     {},
0445 };
0446 MODULE_DEVICE_TABLE(of, vc4_of_match);
0447
0448 static struct platform_driver vc4_platform_driver = {
0449     .probe      = vc4_platform_drm_probe,
0450     .remove     = vc4_platform_drm_remove,
0451     .driver     = {
0452         .name   = "vc4-drm",
0453         .of_match_table = vc4_of_match,
0454     },
0455 };
0456
0457 static int __init vc4_drm_register(void)
0458 {
0459     int ret;
0460
0461     if (drm_firmware_drivers_only())
0462         return -ENODEV;
0463
0464     ret = platform_register_drivers(component_drivers,
0465                     ARRAY_SIZE(component_drivers));
0466     if (ret)
0467         return ret;
0468
0469     return platform_driver_register(&vc4_platform_driver);
0470 }
0471
0472 static void __exit vc4_drm_unregister(void)
0473 {
0474     platform_unregister_drivers(component_drivers,
0475                     ARRAY_SIZE(component_drivers));
0476     platform_driver_unregister(&vc4_platform_driver);
0477 }
0478
0479 module_init(vc4_drm_register);
0480 module_exit(vc4_drm_unregister);
0481
0482 MODULE_ALIAS("platform:vc4-drm");
0483 MODULE_DESCRIPTION("Broadcom VC4 DRM Driver");
0484 MODULE_AUTHOR("Eric Anholt <eric@anholt.net>");
0485 MODULE_LICENSE("GPL v2");