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         /*
 101          * FIXME(Yakir): driver should configure the CRTC output video
 102          * mode with the display information which indicated the monitor
 103          * support colorimetry.
 104          *
 105          * But don't know why the CRTC driver seems could only output the
 106          * RGBaaa rightly. For example, if connect the "innolux,n116bge"
 107          * eDP screen, EDID would indicated that screen only accepted the
 108          * 6bpc mode. But if I configure CRTC to RGB666 output, then eDP
 109          * screen would show a blue picture (RGB888 show a green picture).
 110          * But if I configure CTRC to RGBaaa, and eDP driver still keep
 111          * RGB666 input video mode, then screen would works prefect.
 112          */
 113         adjusted_mode->private_flags = ROCKCHIP_DSP_MODE(eDP, AAAA);
 114
 115         /* do nothing */
 116         return true;
 117 }
 118
 119 static void rockchip_dp_drm_encoder_mode_set(struct drm_encoder *encoder,
 120                                              struct drm_display_mode *mode,
 121                                              struct drm_display_mode *adjusted)
 122 {
 123         /* do nothing */
 124 }
 125
 126 static void rockchip_dp_drm_encoder_enable(struct drm_encoder *encoder)
 127 {
 128         struct rockchip_dp_device *dp = to_dp(encoder);
 129         int ret;
 130         u32 val;
 131
 132         ret = rockchip_drm_encoder_get_mux_id(dp->dev->of_node, encoder);
 133         if (ret < 0)
 134                 return;
 135
 136         if (ret)
 137                 val = GRF_EDP_SEL_VOP_LIT | (GRF_EDP_LCD_SEL_MASK << 16);
 138         else
 139                 val = GRF_EDP_SEL_VOP_BIG | (GRF_EDP_LCD_SEL_MASK << 16);
 140
 141         dev_dbg(dp->dev, "vop %s output to dp\n", (ret) ? "LIT" : "BIG");
 142
 143         ret = regmap_write(dp->grf, GRF_SOC_CON6, val);
 144         if (ret != 0) {
 145                 dev_err(dp->dev, "Could not write to GRF: %d\n", ret);
 146                 return;
 147         }
 148 }
 149
 150 static void rockchip_dp_drm_encoder_nop(struct drm_encoder *encoder)
 151 {
 152         /* do nothing */
 153 }
 154
 155 static struct drm_encoder_helper_funcs rockchip_dp_encoder_helper_funcs = {
 156         .mode_fixup = rockchip_dp_drm_encoder_mode_fixup,
 157         .mode_set = rockchip_dp_drm_encoder_mode_set,
 158         .enable = rockchip_dp_drm_encoder_enable,
 159         .disable = rockchip_dp_drm_encoder_nop,
 160 };
 161
 162 static void rockchip_dp_drm_encoder_destroy(struct drm_encoder *encoder)
 163 {
 164         drm_encoder_cleanup(encoder);
 165 }
 166
 167 static struct drm_encoder_funcs rockchip_dp_encoder_funcs = {
 168         .destroy = rockchip_dp_drm_encoder_destroy,
 169 };
 170
 171 static int rockchip_dp_init(struct rockchip_dp_device *dp)
 172 {
 173         struct device *dev = dp->dev;
 174         struct device_node *np = dev->of_node;
 175         int ret;
 176
 177         dp->grf = syscon_regmap_lookup_by_phandle(np, "rockchip,grf");
 178         if (IS_ERR(dp->grf)) {
 179                 dev_err(dev, "failed to get rockchip,grf property\n");
 180                 return PTR_ERR(dp->grf);
 181         }
 182
 183         dp->pclk = devm_clk_get(dev, "pclk");
 184         if (IS_ERR(dp->pclk)) {
 185                 dev_err(dev, "failed to get pclk property\n");
 186                 return PTR_ERR(dp->pclk);
 187         }
 188
 189         dp->rst = devm_reset_control_get(dev, "dp");
 190         if (IS_ERR(dp->rst)) {
 191                 dev_err(dev, "failed to get dp reset control\n");
 192                 return PTR_ERR(dp->rst);
 193         }
 194
 195         ret = clk_prepare_enable(dp->pclk);
 196         if (ret < 0) {
 197                 dev_err(dp->dev, "failed to enable pclk %d\n", ret);
 198                 return ret;
 199         }
 200
 201         ret = rockchip_dp_pre_init(dp);
 202         if (ret < 0) {
 203                 dev_err(dp->dev, "failed to pre init %d\n", ret);
 204                 return ret;
 205         }
 206
 207         return 0;
 208 }
 209
 210 static int rockchip_dp_drm_create_encoder(struct rockchip_dp_device *dp)
 211 {
 212         struct drm_encoder *encoder = &dp->encoder;
 213         struct drm_device *drm_dev = dp->drm_dev;
 214         struct device *dev = dp->dev;
 215         int ret;
 216
 217         encoder->possible_crtcs = drm_of_find_possible_crtcs(drm_dev,
 218                                                              dev->of_node);
 219         DRM_DEBUG_KMS("possible_crtcs = 0x%x\n", encoder->possible_crtcs);
 220
 221         ret = drm_encoder_init(drm_dev, encoder, &rockchip_dp_encoder_funcs,
 222                                DRM_MODE_ENCODER_TMDS, NULL);
 223         if (ret) {
 224                 DRM_ERROR("failed to initialize encoder with drm\n");
 225                 return ret;
 226         }
 227
 228         drm_encoder_helper_add(encoder, &rockchip_dp_encoder_helper_funcs);
 229
 230         return 0;
 231 }
 232
 233 static int rockchip_dp_bind(struct device *dev, struct device *master,
 234                             void *data)
 235 {
 236         struct rockchip_dp_device *dp = dev_get_drvdata(dev);
 237         struct drm_device *drm_dev = data;
 238         int ret;
 239
 240         /*
 241          * Just like the probe function said, we don't need the
 242          * device drvrate anymore, we should leave the charge to
 243          * analogix dp driver, set the device drvdata to NULL.
 244          */
 245         dev_set_drvdata(dev, NULL);
 246
 247         ret = rockchip_dp_init(dp);
 248         if (ret < 0)
 249                 return ret;
 250
 251         dp->drm_dev = drm_dev;
 252
 253         ret = rockchip_dp_drm_create_encoder(dp);
 254         if (ret) {
 255                 DRM_ERROR("failed to create drm encoder\n");
 256                 return ret;
 257         }
 258
 259         dp->plat_data.encoder = &dp->encoder;
 260
 261         dp->plat_data.dev_type = RK3288_DP;
 262         dp->plat_data.power_on = rockchip_dp_poweron;
 263         dp->plat_data.power_off = rockchip_dp_powerdown;
 264
 265         return analogix_dp_bind(dev, dp->drm_dev, &dp->plat_data);
 266 }
 267
 268 static void rockchip_dp_unbind(struct device *dev, struct device *master,
 269                                void *data)
 270 {
 271         return analogix_dp_unbind(dev, master, data);
 272 }
 273
 274 static const struct component_ops rockchip_dp_component_ops = {
 275         .bind = rockchip_dp_bind,
 276         .unbind = rockchip_dp_unbind,
 277 };
 278
 279 static int rockchip_dp_probe(struct platform_device *pdev)
 280 {
 281         struct device *dev = &pdev->dev;
 282         struct device_node *panel_node, *port, *endpoint;
 283         struct rockchip_dp_device *dp;
 284         struct drm_panel *panel;
 285
 286         port = of_graph_get_port_by_id(dev->of_node, 1);
 287         if (!port) {
 288                 dev_err(dev, "can't find output port\n");
 289                 return -EINVAL;
 290         }
 291
 292         endpoint = of_get_child_by_name(port, "endpoint");
 293         of_node_put(port);
 294         if (!endpoint) {
 295                 dev_err(dev, "no output endpoint found\n");
 296                 return -EINVAL;
 297         }
 298
 299         panel_node = of_graph_get_remote_port_parent(endpoint);
 300         of_node_put(endpoint);
 301         if (!panel_node) {
 302                 dev_err(dev, "no output node found\n");
 303                 return -EINVAL;
 304         }
 305
 306         panel = of_drm_find_panel(panel_node);
 307         if (!panel) {
 308                 DRM_ERROR("failed to find panel\n");
 309                 of_node_put(panel_node);
 310                 return -EPROBE_DEFER;
 311         }
 312
 313         of_node_put(panel_node);
 314
 315         dp = devm_kzalloc(dev, sizeof(*dp), GFP_KERNEL);
 316         if (!dp)
 317                 return -ENOMEM;
 318
 319         dp->dev = dev;
 320
 321         dp->plat_data.panel = panel;
 322
 323         /*
 324          * We just use the drvdata until driver run into component
 325          * add function, and then we would set drvdata to null, so
 326          * that analogix dp driver could take charge of the drvdata.
 327          */
 328         platform_set_drvdata(pdev, dp);
 329
 330         return component_add(dev, &rockchip_dp_component_ops);
 331 }
 332
 333 static int rockchip_dp_remove(struct platform_device *pdev)
 334 {
 335         component_del(&pdev->dev, &rockchip_dp_component_ops);
 336
 337         return 0;
 338 }
 339
 340 #ifdef CONFIG_PM_SLEEP
 341 static int rockchip_dp_suspend(struct device *dev)
 342 {
 343         return analogix_dp_suspend(dev);
 344 }
 345
 346 static int rockchip_dp_resume(struct device *dev)
 347 {
 348         return analogix_dp_resume(dev);
 349 }
 350 #endif
 351
 352 static const struct dev_pm_ops rockchip_dp_pm_ops = {
 353         SET_SYSTEM_SLEEP_PM_OPS(rockchip_dp_suspend, rockchip_dp_resume)
 354 };
 355
 356 static const struct of_device_id rockchip_dp_dt_ids[] = {
 357         {.compatible = "rockchip,rk3288-dp",},
 358         {.compatible = "rockchip,rk3399-edp",},
 359         {}
 360 };
 361 MODULE_DEVICE_TABLE(of, rockchip_dp_dt_ids);
 362
 363 static struct platform_driver rockchip_dp_driver = {
 364         .probe = rockchip_dp_probe,
 365         .remove = rockchip_dp_remove,
 366         .driver = {
 367                    .name = "rockchip-dp",
 368                    .owner = THIS_MODULE,
 369                    .pm = &rockchip_dp_pm_ops,
 370                    .of_match_table = of_match_ptr(rockchip_dp_dt_ids),
 371         },
 372 };
 373
 374 module_platform_driver(rockchip_dp_driver);
 375
 376 MODULE_AUTHOR("Yakir Yang <ykk@rock-chips.com>");
 377 MODULE_AUTHOR("Jeff chen <jeff.chen@rock-chips.com>");
 378 MODULE_DESCRIPTION("Rockchip Specific Analogix-DP Driver Extension");
 379 MODULE_LICENSE("GPL v2");