drivers/gpu/drm/rockchip/analogix_dp-rockchip.c

   1 /*
   2  * Rockchip SoC DP (Display Port) interface driver.
   3  *
   4  * Copyright (C) Fuzhou Rockchip Electronics Co., Ltd.
   5  * Author: Andy Yan <andy.yan@rock-chips.com>
   6  *         Yakir Yang <ykk@rock-chips.com>
   7  *         Jeff Chen <jeff.chen@rock-chips.com>
   8  *
   9  * This program is free software; you can redistribute it and/or modify it
  10  * under the terms of the GNU General Public License as published by the
  11  * Free Software Foundation; either version 2 of the License, or (at your
  12  * option) any later version.
  13  */
  14
  15 #include <linux/component.h>
  16 #include <linux/mfd/syscon.h>
  17 #include <linux/of_graph.h>
  18 #include <linux/regmap.h>
  19 #include <linux/reset.h>
  20 #include <linux/clk.h>
  21
  22 #include <drm/drmP.h>
  23 #include <drm/drm_crtc_helper.h>
  24 #include <drm/drm_dp_helper.h>
  25 #include <drm/drm_of.h>
  26 #include <drm/drm_panel.h>
  27
  28 #include <video/of_videomode.h>
  29 #include <video/videomode.h>
  30
  31 #include <drm/bridge/analogix_dp.h>
  32
  33 #include "rockchip_drm_drv.h"
  34 #include "rockchip_drm_vop.h"
  35
  36 #define to_dp(nm)       container_of(nm, struct rockchip_dp_device, nm)
  37
  38 /* dp grf register offset */
  39 #define GRF_SOC_CON6                            0x025c
  40 #define GRF_EDP_LCD_SEL_MASK                    BIT(5)
  41 #define GRF_EDP_SEL_VOP_LIT                     BIT(5)
  42 #define GRF_EDP_SEL_VOP_BIG                     0
  43
  44 struct rockchip_dp_device {
  45         struct drm_device        *drm_dev;
  46         struct device            *dev;
  47         struct drm_encoder       encoder;
  48         struct drm_display_mode  mode;
  49
  50         struct clk               *pclk;
  51         struct regmap            *grf;
  52         struct reset_control     *rst;
  53
  54         struct analogix_dp_plat_data plat_data;
  55 };
  56
  57 static int rockchip_dp_pre_init(struct rockchip_dp_device *dp)
  58 {
  59         reset_control_assert(dp->rst);
  60         usleep_range(10, 20);
  61         reset_control_deassert(dp->rst);
  62
  63         return 0;
  64 }
  65
  66 static int rockchip_dp_poweron(struct analogix_dp_plat_data *plat_data)
  67 {
  68         struct rockchip_dp_device *dp = to_dp(plat_data);
  69         int ret;
  70
  71         ret = clk_prepare_enable(dp->pclk);
  72         if (ret < 0) {
  73                 dev_err(dp->dev, "failed to enable pclk %d\n", ret);
  74                 return ret;
  75         }
  76
  77         ret = rockchip_dp_pre_init(dp);
  78         if (ret < 0) {
  79                 dev_err(dp->dev, "failed to dp pre init %d\n", ret);
  80                 return ret;
  81         }
  82
  83         return 0;
  84 }
  85
  86 static int rockchip_dp_powerdown(struct analogix_dp_plat_data *plat_data)
  87 {
  88         struct rockchip_dp_device *dp = to_dp(plat_data);
  89
  90         clk_disable_unprepare(dp->pclk);
  91
  92         return 0;
  93 }
  94
  95 static bool
  96 rockchip_dp_drm_encoder_mode_fixup(struct drm_encoder *encoder,
  97                                    const struct drm_display_mode *mode,
  98                                    struct drm_display_mode *adjusted_mode)
  99 {
 100         /* do nothing */
 101         return true;
 102 }
 103
 104 static void rockchip_dp_drm_encoder_mode_set(struct drm_encoder *encoder,
 105                                              struct drm_display_mode *mode,
 106                                              struct drm_display_mode *adjusted)
 107 {
 108         /* do nothing */
 109 }
 110
 111 static void rockchip_dp_drm_encoder_enable(struct drm_encoder *encoder)
 112 {
 113         struct rockchip_dp_device *dp = to_dp(encoder);
 114         int ret;
 115         u32 val;
 116
 117         /*
 118          * FIXME(Yakir): driver should configure the CRTC output video
 119          * mode with the display information which indicated the monitor
 120          * support colorimetry.
 121          *
 122          * But don't know why the CRTC driver seems could only output the
 123          * RGBaaa rightly. For example, if connect the "innolux,n116bge"
 124          * eDP screen, EDID would indicated that screen only accepted the
 125          * 6bpc mode. But if I configure CRTC to RGB666 output, then eDP
 126          * screen would show a blue picture (RGB888 show a green picture).
 127          * But if I configure CTRC to RGBaaa, and eDP driver still keep
 128          * RGB666 input video mode, then screen would works prefect.
 129          */
 130         ret = rockchip_drm_crtc_mode_config(encoder->crtc,
 131                                             DRM_MODE_CONNECTOR_eDP,
 132                                             ROCKCHIP_OUT_MODE_AAAA);
 133         if (ret < 0) {
 134                 dev_err(dp->dev, "Could not set crtc mode config (%d)\n", ret);
 135                 return;
 136         }
 137
 138         ret = rockchip_drm_encoder_get_mux_id(dp->dev->of_node, encoder);
 139         if (ret < 0)
 140                 return;
 141
 142         if (ret)
 143                 val = GRF_EDP_SEL_VOP_LIT | (GRF_EDP_LCD_SEL_MASK << 16);
 144         else
 145                 val = GRF_EDP_SEL_VOP_BIG | (GRF_EDP_LCD_SEL_MASK << 16);
 146
 147         dev_dbg(dp->dev, "vop %s output to dp\n", (ret) ? "LIT" : "BIG");
 148
 149         ret = regmap_write(dp->grf, GRF_SOC_CON6, val);
 150         if (ret != 0) {
 151                 dev_err(dp->dev, "Could not write to GRF: %d\n", ret);
 152                 return;
 153         }
 154 }
 155
 156 static void rockchip_dp_drm_encoder_nop(struct drm_encoder *encoder)
 157 {
 158         /* do nothing */
 159 }
 160
 161 static struct drm_encoder_helper_funcs rockchip_dp_encoder_helper_funcs = {
 162         .mode_fixup = rockchip_dp_drm_encoder_mode_fixup,
 163         .mode_set = rockchip_dp_drm_encoder_mode_set,
 164         .enable = rockchip_dp_drm_encoder_enable,
 165         .disable = rockchip_dp_drm_encoder_nop,
 166 };
 167
 168 static void rockchip_dp_drm_encoder_destroy(struct drm_encoder *encoder)
 169 {
 170         drm_encoder_cleanup(encoder);
 171 }
 172
 173 static struct drm_encoder_funcs rockchip_dp_encoder_funcs = {
 174         .destroy = rockchip_dp_drm_encoder_destroy,
 175 };
 176
 177 static int rockchip_dp_init(struct rockchip_dp_device *dp)
 178 {
 179         struct device *dev = dp->dev;
 180         struct device_node *np = dev->of_node;
 181         int ret;
 182
 183         dp->grf = syscon_regmap_lookup_by_phandle(np, "rockchip,grf");
 184         if (IS_ERR(dp->grf)) {
 185                 dev_err(dev, "failed to get rockchip,grf property\n");
 186                 return PTR_ERR(dp->grf);
 187         }
 188
 189         dp->pclk = devm_clk_get(dev, "pclk");
 190         if (IS_ERR(dp->pclk)) {
 191                 dev_err(dev, "failed to get pclk property\n");
 192                 return PTR_ERR(dp->pclk);
 193         }
 194
 195         dp->rst = devm_reset_control_get(dev, "dp");
 196         if (IS_ERR(dp->rst)) {
 197                 dev_err(dev, "failed to get dp reset control\n");
 198                 return PTR_ERR(dp->rst);
 199         }
 200
 201         ret = clk_prepare_enable(dp->pclk);
 202         if (ret < 0) {
 203                 dev_err(dp->dev, "failed to enable pclk %d\n", ret);
 204                 return ret;
 205         }
 206
 207         ret = rockchip_dp_pre_init(dp);
 208         if (ret < 0) {
 209                 dev_err(dp->dev, "failed to pre init %d\n", ret);
 210                 return ret;
 211         }
 212
 213         return 0;
 214 }
 215
 216 static int rockchip_dp_drm_create_encoder(struct rockchip_dp_device *dp)
 217 {
 218         struct drm_encoder *encoder = &dp->encoder;
 219         struct drm_device *drm_dev = dp->drm_dev;
 220         struct device *dev = dp->dev;
 221         int ret;
 222
 223         encoder->possible_crtcs = drm_of_find_possible_crtcs(drm_dev,
 224                                                              dev->of_node);
 225         DRM_DEBUG_KMS("possible_crtcs = 0x%x\n", encoder->possible_crtcs);
 226
 227         ret = drm_encoder_init(drm_dev, encoder, &rockchip_dp_encoder_funcs,
 228                                DRM_MODE_ENCODER_TMDS, NULL);
 229         if (ret) {
 230                 DRM_ERROR("failed to initialize encoder with drm\n");
 231                 return ret;
 232         }
 233
 234         drm_encoder_helper_add(encoder, &rockchip_dp_encoder_helper_funcs);
 235
 236         return 0;
 237 }
 238
 239 static int rockchip_dp_bind(struct device *dev, struct device *master,
 240                             void *data)
 241 {
 242         struct rockchip_dp_device *dp = dev_get_drvdata(dev);
 243         struct drm_device *drm_dev = data;
 244         int ret;
 245
 246         /*
 247          * Just like the probe function said, we don't need the
 248          * device drvrate anymore, we should leave the charge to
 249          * analogix dp driver, set the device drvdata to NULL.
 250          */
 251         dev_set_drvdata(dev, NULL);
 252
 253         ret = rockchip_dp_init(dp);
 254         if (ret < 0)
 255                 return ret;
 256
 257         dp->drm_dev = drm_dev;
 258
 259         ret = rockchip_dp_drm_create_encoder(dp);
 260         if (ret) {
 261                 DRM_ERROR("failed to create drm encoder\n");
 262                 return ret;
 263         }
 264
 265         dp->plat_data.encoder = &dp->encoder;
 266
 267         dp->plat_data.dev_type = RK3288_DP;
 268         dp->plat_data.power_on = rockchip_dp_poweron;
 269         dp->plat_data.power_off = rockchip_dp_powerdown;
 270
 271         return analogix_dp_bind(dev, dp->drm_dev, &dp->plat_data);
 272 }
 273
 274 static void rockchip_dp_unbind(struct device *dev, struct device *master,
 275                                void *data)
 276 {
 277         return analogix_dp_unbind(dev, master, data);
 278 }
 279
 280 static const struct component_ops rockchip_dp_component_ops = {
 281         .bind = rockchip_dp_bind,
 282         .unbind = rockchip_dp_unbind,
 283 };
 284
 285 static int rockchip_dp_probe(struct platform_device *pdev)
 286 {
 287         struct device *dev = &pdev->dev;
 288         struct device_node *panel_node, *port, *endpoint;
 289         struct rockchip_dp_device *dp;
 290         struct drm_panel *panel;
 291
 292         port = of_graph_get_port_by_id(dev->of_node, 1);
 293         if (!port) {
 294                 dev_err(dev, "can't find output port\n");
 295                 return -EINVAL;
 296         }
 297
 298         endpoint = of_get_child_by_name(port, "endpoint");
 299         of_node_put(port);
 300         if (!endpoint) {
 301                 dev_err(dev, "no output endpoint found\n");
 302                 return -EINVAL;
 303         }
 304
 305         panel_node = of_graph_get_remote_port_parent(endpoint);
 306         of_node_put(endpoint);
 307         if (!panel_node) {
 308                 dev_err(dev, "no output node found\n");
 309                 return -EINVAL;
 310         }
 311
 312         panel = of_drm_find_panel(panel_node);
 313         if (!panel) {
 314                 DRM_ERROR("failed to find panel\n");
 315                 of_node_put(panel_node);
 316                 return -EPROBE_DEFER;
 317         }
 318
 319         of_node_put(panel_node);
 320
 321         dp = devm_kzalloc(dev, sizeof(*dp), GFP_KERNEL);
 322         if (!dp)
 323                 return -ENOMEM;
 324
 325         dp->dev = dev;
 326
 327         dp->plat_data.panel = panel;
 328
 329         /*
 330          * We just use the drvdata until driver run into component
 331          * add function, and then we would set drvdata to null, so
 332          * that analogix dp driver could take charge of the drvdata.
 333          */
 334         platform_set_drvdata(pdev, dp);
 335
 336         return component_add(dev, &rockchip_dp_component_ops);
 337 }
 338
 339 static int rockchip_dp_remove(struct platform_device *pdev)
 340 {
 341         component_del(&pdev->dev, &rockchip_dp_component_ops);
 342
 343         return 0;
 344 }
 345
 346 #ifdef CONFIG_PM_SLEEP
 347 static int rockchip_dp_suspend(struct device *dev)
 348 {
 349         return analogix_dp_suspend(dev);
 350 }
 351
 352 static int rockchip_dp_resume(struct device *dev)
 353 {
 354         return analogix_dp_resume(dev);
 355 }
 356 #endif
 357
 358 static const struct dev_pm_ops rockchip_dp_pm_ops = {
 359         SET_SYSTEM_SLEEP_PM_OPS(rockchip_dp_suspend, rockchip_dp_resume)
 360 };
 361
 362 static const struct of_device_id rockchip_dp_dt_ids[] = {
 363         {.compatible = "rockchip,rk3288-dp",},
 364         {.compatible = "rockchip,rk3399-edp",},
 365         {}
 366 };
 367 MODULE_DEVICE_TABLE(of, rockchip_dp_dt_ids);
 368
 369 static struct platform_driver rockchip_dp_driver = {
 370         .probe = rockchip_dp_probe,
 371         .remove = rockchip_dp_remove,
 372         .driver = {
 373                    .name = "rockchip-dp",
 374                    .owner = THIS_MODULE,
 375                    .pm = &rockchip_dp_pm_ops,
 376                    .of_match_table = of_match_ptr(rockchip_dp_dt_ids),
 377         },
 378 };
 379
 380 module_platform_driver(rockchip_dp_driver);
 381
 382 MODULE_AUTHOR("Yakir Yang <ykk@rock-chips.com>");
 383 MODULE_AUTHOR("Jeff chen <jeff.chen@rock-chips.com>");
 384 MODULE_DESCRIPTION("Rockchip Specific Analogix-DP Driver Extension");
 385 MODULE_LICENSE("GPL v2");