hisilicon/kirin/kirin_drm_drv.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Hisilicon Kirin SoCs drm master driver
0004  *
0005  * Copyright (c) 2016 Linaro Limited.
0006  * Copyright (c) 2014-2016 HiSilicon Limited.
0007  *
0008  * Author:
0009  *  Xinliang Liu <z.liuxinliang@hisilicon.com>
0010  *  Xinliang Liu <xinliang.liu@linaro.org>
0011  *  Xinwei Kong <kong.kongxinwei@hisilicon.com>
0012  */
0013
0014 #include <linux/of_platform.h>
0015 #include <linux/component.h>
0016 #include <linux/module.h>
0017 #include <linux/of_graph.h>
0018 #include <linux/platform_device.h>
0019
0020 #include <drm/drm_atomic_helper.h>
0021 #include <drm/drm_drv.h>
0022 #include <drm/drm_fb_cma_helper.h>
0023 #include <drm/drm_fb_helper.h>
0024 #include <drm/drm_gem_cma_helper.h>
0025 #include <drm/drm_gem_framebuffer_helper.h>
0026 #include <drm/drm_module.h>
0027 #include <drm/drm_of.h>
0028 #include <drm/drm_probe_helper.h>
0029 #include <drm/drm_vblank.h>
0030
0031 #include "kirin_drm_drv.h"
0032
0033 #define KIRIN_MAX_PLANE 2
0034
0035 struct kirin_drm_private {
0036     struct kirin_crtc crtc;
0037     struct kirin_plane planes[KIRIN_MAX_PLANE];
0038     void *hw_ctx;
0039 };
0040
0041 static int kirin_drm_crtc_init(struct drm_device *dev, struct drm_crtc *crtc,
0042                    struct drm_plane *plane,
0043                    const struct kirin_drm_data *driver_data)
0044 {
0045     struct device_node *port;
0046     int ret;
0047
0048     /* set crtc port so that
0049      * drm_of_find_possible_crtcs call works
0050      */
0051     port = of_get_child_by_name(dev->dev->of_node, "port");
0052     if (!port) {
0053         DRM_ERROR("no port node found in %pOF\n", dev->dev->of_node);
0054         return -EINVAL;
0055     }
0056     of_node_put(port);
0057     crtc->port = port;
0058
0059     ret = drm_crtc_init_with_planes(dev, crtc, plane, NULL,
0060                     driver_data->crtc_funcs, NULL);
0061     if (ret) {
0062         DRM_ERROR("failed to init crtc.\n");
0063         return ret;
0064     }
0065
0066     drm_crtc_helper_add(crtc, driver_data->crtc_helper_funcs);
0067
0068     return 0;
0069 }
0070
0071 static int kirin_drm_plane_init(struct drm_device *dev, struct drm_plane *plane,
0072                 enum drm_plane_type type,
0073                 const struct kirin_drm_data *data)
0074 {
0075     int ret = 0;
0076
0077     ret = drm_universal_plane_init(dev, plane, 1, data->plane_funcs,
0078                        data->channel_formats,
0079                        data->channel_formats_cnt,
0080                        NULL, type, NULL);
0081     if (ret) {
0082         DRM_ERROR("fail to init plane, ch=%d\n", 0);
0083         return ret;
0084     }
0085
0086     drm_plane_helper_add(plane, data->plane_helper_funcs);
0087
0088     return 0;
0089 }
0090
0091 static void kirin_drm_private_cleanup(struct drm_device *dev)
0092 {
0093     struct kirin_drm_private *kirin_priv = dev->dev_private;
0094     struct kirin_drm_data *data;
0095
0096     data = (struct kirin_drm_data *)of_device_get_match_data(dev->dev);
0097     if (data->cleanup_hw_ctx)
0098         data->cleanup_hw_ctx(kirin_priv->hw_ctx);
0099
0100     devm_kfree(dev->dev, kirin_priv);
0101     dev->dev_private = NULL;
0102 }
0103
0104 static int kirin_drm_private_init(struct drm_device *dev,
0105                   const struct kirin_drm_data *driver_data)
0106 {
0107     struct platform_device *pdev = to_platform_device(dev->dev);
0108     struct kirin_drm_private *kirin_priv;
0109     struct drm_plane *prim_plane;
0110     enum drm_plane_type type;
0111     void *ctx;
0112     int ret;
0113     u32 ch;
0114
0115     kirin_priv = devm_kzalloc(dev->dev, sizeof(*kirin_priv), GFP_KERNEL);
0116     if (!kirin_priv) {
0117         DRM_ERROR("failed to alloc kirin_drm_private\n");
0118         return -ENOMEM;
0119     }
0120
0121     ctx = driver_data->alloc_hw_ctx(pdev, &kirin_priv->crtc.base);
0122     if (IS_ERR(ctx)) {
0123         DRM_ERROR("failed to initialize kirin_priv hw ctx\n");
0124         return -EINVAL;
0125     }
0126     kirin_priv->hw_ctx = ctx;
0127
0128     /*
0129      * plane init
0130      * TODO: Now only support primary plane, overlay planes
0131      * need to do.
0132      */
0133     for (ch = 0; ch < driver_data->num_planes; ch++) {
0134         if (ch == driver_data->prim_plane)
0135             type = DRM_PLANE_TYPE_PRIMARY;
0136         else
0137             type = DRM_PLANE_TYPE_OVERLAY;
0138         ret = kirin_drm_plane_init(dev, &kirin_priv->planes[ch].base,
0139                        type, driver_data);
0140         if (ret)
0141             return ret;
0142         kirin_priv->planes[ch].ch = ch;
0143         kirin_priv->planes[ch].hw_ctx = ctx;
0144     }
0145
0146     /* crtc init */
0147     prim_plane = &kirin_priv->planes[driver_data->prim_plane].base;
0148     ret = kirin_drm_crtc_init(dev, &kirin_priv->crtc.base,
0149                   prim_plane, driver_data);
0150     if (ret)
0151         return ret;
0152     kirin_priv->crtc.hw_ctx = ctx;
0153     dev->dev_private = kirin_priv;
0154
0155     return 0;
0156 }
0157
0158 static int kirin_drm_kms_init(struct drm_device *dev,
0159                   const struct kirin_drm_data *driver_data)
0160 {
0161     int ret;
0162
0163     /* dev->mode_config initialization */
0164     drm_mode_config_init(dev);
0165     dev->mode_config.min_width = 0;
0166     dev->mode_config.min_height = 0;
0167     dev->mode_config.max_width = driver_data->config_max_width;
0168     dev->mode_config.max_height = driver_data->config_max_width;
0169     dev->mode_config.funcs = driver_data->mode_config_funcs;
0170
0171     /* display controller init */
0172     ret = kirin_drm_private_init(dev, driver_data);
0173     if (ret)
0174         goto err_mode_config_cleanup;
0175
0176     /* bind and init sub drivers */
0177     ret = component_bind_all(dev->dev, dev);
0178     if (ret) {
0179         DRM_ERROR("failed to bind all component.\n");
0180         goto err_private_cleanup;
0181     }
0182
0183     /* vblank init */
0184     ret = drm_vblank_init(dev, dev->mode_config.num_crtc);
0185     if (ret) {
0186         DRM_ERROR("failed to initialize vblank.\n");
0187         goto err_unbind_all;
0188     }
0189
0190     /* reset all the states of crtc/plane/encoder/connector */
0191     drm_mode_config_reset(dev);
0192
0193     /* init kms poll for handling hpd */
0194     drm_kms_helper_poll_init(dev);
0195
0196     return 0;
0197
0198 err_unbind_all:
0199     component_unbind_all(dev->dev, dev);
0200 err_private_cleanup:
0201     kirin_drm_private_cleanup(dev);
0202 err_mode_config_cleanup:
0203     drm_mode_config_cleanup(dev);
0204     return ret;
0205 }
0206
0207 static int kirin_drm_kms_cleanup(struct drm_device *dev)
0208 {
0209     drm_kms_helper_poll_fini(dev);
0210     kirin_drm_private_cleanup(dev);
0211     drm_mode_config_cleanup(dev);
0212
0213     return 0;
0214 }
0215
0216 static int kirin_drm_bind(struct device *dev)
0217 {
0218     struct kirin_drm_data *driver_data;
0219     struct drm_device *drm_dev;
0220     int ret;
0221
0222     driver_data = (struct kirin_drm_data *)of_device_get_match_data(dev);
0223     if (!driver_data)
0224         return -EINVAL;
0225
0226     drm_dev = drm_dev_alloc(driver_data->driver, dev);
0227     if (IS_ERR(drm_dev))
0228         return PTR_ERR(drm_dev);
0229     dev_set_drvdata(dev, drm_dev);
0230
0231     /* display controller init */
0232     ret = kirin_drm_kms_init(drm_dev, driver_data);
0233     if (ret)
0234         goto err_drm_dev_put;
0235
0236     ret = drm_dev_register(drm_dev, 0);
0237     if (ret)
0238         goto err_kms_cleanup;
0239
0240     drm_fbdev_generic_setup(drm_dev, 32);
0241
0242     return 0;
0243
0244 err_kms_cleanup:
0245     kirin_drm_kms_cleanup(drm_dev);
0246 err_drm_dev_put:
0247     drm_dev_put(drm_dev);
0248
0249     return ret;
0250 }
0251
0252 static void kirin_drm_unbind(struct device *dev)
0253 {
0254     struct drm_device *drm_dev = dev_get_drvdata(dev);
0255
0256     drm_dev_unregister(drm_dev);
0257     kirin_drm_kms_cleanup(drm_dev);
0258     drm_dev_put(drm_dev);
0259 }
0260
0261 static const struct component_master_ops kirin_drm_ops = {
0262     .bind = kirin_drm_bind,
0263     .unbind = kirin_drm_unbind,
0264 };
0265
0266 static int kirin_drm_platform_probe(struct platform_device *pdev)
0267 {
0268     struct device *dev = &pdev->dev;
0269     struct device_node *np = dev->of_node;
0270     struct component_match *match = NULL;
0271     struct device_node *remote;
0272
0273     remote = of_graph_get_remote_node(np, 0, 0);
0274     if (!remote)
0275         return -ENODEV;
0276
0277     drm_of_component_match_add(dev, &match, component_compare_of, remote);
0278     of_node_put(remote);
0279
0280     return component_master_add_with_match(dev, &kirin_drm_ops, match);
0281 }
0282
0283 static int kirin_drm_platform_remove(struct platform_device *pdev)
0284 {
0285     component_master_del(&pdev->dev, &kirin_drm_ops);
0286     return 0;
0287 }
0288
0289 static const struct of_device_id kirin_drm_dt_ids[] = {
0290     { .compatible = "hisilicon,hi6220-ade",
0291       .data = &ade_driver_data,
0292     },
0293     { /* end node */ },
0294 };
0295 MODULE_DEVICE_TABLE(of, kirin_drm_dt_ids);
0296
0297 static struct platform_driver kirin_drm_platform_driver = {
0298     .probe = kirin_drm_platform_probe,
0299     .remove = kirin_drm_platform_remove,
0300     .driver = {
0301         .name = "kirin-drm",
0302         .of_match_table = kirin_drm_dt_ids,
0303     },
0304 };
0305
0306 drm_module_platform_driver(kirin_drm_platform_driver);
0307
0308 MODULE_AUTHOR("Xinliang Liu <xinliang.liu@linaro.org>");
0309 MODULE_AUTHOR("Xinliang Liu <z.liuxinliang@hisilicon.com>");
0310 MODULE_AUTHOR("Xinwei Kong <kong.kongxinwei@hisilicon.com>");
0311 MODULE_DESCRIPTION("hisilicon Kirin SoCs' DRM master driver");
0312 MODULE_LICENSE("GPL v2");