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 = drm_of_encoder_active_endpoint_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 {} 365 }; 366 MODULE_DEVICE_TABLE(of, rockchip_dp_dt_ids); 367 368 static struct platform_driver rockchip_dp_driver = { 369 .probe = rockchip_dp_probe, 370 .remove = rockchip_dp_remove, 371 .driver = { 372 .name = "rockchip-dp", 373 .owner = THIS_MODULE, 374 .pm = &rockchip_dp_pm_ops, 375 .of_match_table = of_match_ptr(rockchip_dp_dt_ids), 376 }, 377 }; 378 379 module_platform_driver(rockchip_dp_driver); 380 381 MODULE_AUTHOR("Yakir Yang <ykk@rock-chips.com>"); 382 MODULE_AUTHOR("Jeff chen <jeff.chen@rock-chips.com>"); 383 MODULE_DESCRIPTION("Rockchip Specific Analogix-DP Driver Extension"); 384 MODULE_LICENSE("GPL v2"); 385