drivers/gpu/drm/rockchip/rockchip_lvds.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (C) Rockchip Electronics Co., Ltd.
   4  * Author:
   5  *      Mark Yao <[email protected]>
   6  *      Sandy Huang <[email protected]>
   7  */
   8
   9 #include <linux/clk.h>
  10 #include <linux/component.h>
  11 #include <linux/mfd/syscon.h>
  12 #include <linux/of_graph.h>
  13 #include <linux/phy/phy.h>
  14 #include <linux/pinctrl/devinfo.h>
  15 #include <linux/platform_device.h>
  16 #include <linux/pm_runtime.h>
  17 #include <linux/regmap.h>
  18 #include <linux/reset.h>
  19
  20 #include <drm/drm_atomic_helper.h>
  21 #include <drm/drm_bridge.h>
  22 #include <drm/drm_bridge_connector.h>
  23 #include <drm/drm_of.h>
  24 #include <drm/drm_panel.h>
  25 #include <drm/drm_probe_helper.h>
  26 #include <drm/drm_simple_kms_helper.h>
  27
  28 #include "rockchip_drm_drv.h"
  29 #include "rockchip_lvds.h"
  30
  31 #define DISPLAY_OUTPUT_RGB              0
  32 #define DISPLAY_OUTPUT_LVDS             1
  33 #define DISPLAY_OUTPUT_DUAL_LVDS        2
  34
  35 struct rockchip_lvds;
  36
  37 /**
  38  * struct rockchip_lvds_soc_data - rockchip lvds Soc private data
  39  * @probe: LVDS platform probe function
  40  * @helper_funcs: LVDS connector helper functions
  41  */
  42 struct rockchip_lvds_soc_data {
  43         int (*probe)(struct platform_device *pdev, struct rockchip_lvds *lvds);
  44         const struct drm_encoder_helper_funcs *helper_funcs;
  45 };
  46
  47 struct rockchip_lvds {
  48         struct device *dev;
  49         void __iomem *regs;
  50         struct regmap *grf;
  51         struct clk *pclk;
  52         struct phy *dphy;
  53         const struct rockchip_lvds_soc_data *soc_data;
  54         int output; /* rgb lvds or dual lvds output */
  55         int format; /* vesa or jeida format */
  56         struct drm_device *drm_dev;
  57         struct drm_panel *panel;
  58         struct drm_bridge *bridge;
  59         struct drm_connector connector;
  60         struct rockchip_encoder encoder;
  61         struct dev_pin_info *pins;
  62 };
  63
  64 static inline struct rockchip_lvds *connector_to_lvds(struct drm_connector *connector)
  65 {
  66         return container_of(connector, struct rockchip_lvds, connector);
  67 }
  68
  69 static inline struct rockchip_lvds *encoder_to_lvds(struct drm_encoder *encoder)
  70 {
  71         struct rockchip_encoder *rkencoder = to_rockchip_encoder(encoder);
  72
  73         return container_of(rkencoder, struct rockchip_lvds, encoder);
  74 }
  75
  76 static inline void rk3288_writel(struct rockchip_lvds *lvds, u32 offset,
  77                                  u32 val)
  78 {
  79         writel_relaxed(val, lvds->regs + offset);
  80         if (lvds->output == DISPLAY_OUTPUT_LVDS)
  81                 return;
  82         writel_relaxed(val, lvds->regs + offset + RK3288_LVDS_CH1_OFFSET);
  83 }
  84
  85 static inline int rockchip_lvds_name_to_format(const char *s)
  86 {
  87         if (strncmp(s, "jeida-18", 8) == 0)
  88                 return LVDS_JEIDA_18;
  89         else if (strncmp(s, "jeida-24", 8) == 0)
  90                 return LVDS_JEIDA_24;
  91         else if (strncmp(s, "vesa-24", 7) == 0)
  92                 return LVDS_VESA_24;
  93
  94         return -EINVAL;
  95 }
  96
  97 static inline int rockchip_lvds_name_to_output(const char *s)
  98 {
  99         if (strncmp(s, "rgb", 3) == 0)
 100                 return DISPLAY_OUTPUT_RGB;
 101         else if (strncmp(s, "lvds", 4) == 0)
 102                 return DISPLAY_OUTPUT_LVDS;
 103         else if (strncmp(s, "duallvds", 8) == 0)
 104                 return DISPLAY_OUTPUT_DUAL_LVDS;
 105
 106         return -EINVAL;
 107 }
 108
 109 static const struct drm_connector_funcs rockchip_lvds_connector_funcs = {
 110         .fill_modes = drm_helper_probe_single_connector_modes,
 111         .destroy = drm_connector_cleanup,
 112         .reset = drm_atomic_helper_connector_reset,
 113         .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
 114         .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
 115 };
 116
 117 static int rockchip_lvds_connector_get_modes(struct drm_connector *connector)
 118 {
 119         struct rockchip_lvds *lvds = connector_to_lvds(connector);
 120         struct drm_panel *panel = lvds->panel;
 121
 122         return drm_panel_get_modes(panel, connector);
 123 }
 124
 125 static const
 126 struct drm_connector_helper_funcs rockchip_lvds_connector_helper_funcs = {
 127         .get_modes = rockchip_lvds_connector_get_modes,
 128 };
 129
 130 static int
 131 rockchip_lvds_encoder_atomic_check(struct drm_encoder *encoder,
 132                                    struct drm_crtc_state *crtc_state,
 133                                    struct drm_connector_state *conn_state)
 134 {
 135         struct rockchip_crtc_state *s = to_rockchip_crtc_state(crtc_state);
 136
 137         s->output_mode = ROCKCHIP_OUT_MODE_P888;
 138         s->output_type = DRM_MODE_CONNECTOR_LVDS;
 139
 140         return 0;
 141 }
 142
 143 static int rk3288_lvds_poweron(struct rockchip_lvds *lvds)
 144 {
 145         int ret;
 146         u32 val;
 147
 148         ret = clk_enable(lvds->pclk);
 149         if (ret < 0) {
 150                 DRM_DEV_ERROR(lvds->dev, "failed to enable lvds pclk %d\n", ret);
 151                 return ret;
 152         }
 153         ret = pm_runtime_resume_and_get(lvds->dev);
 154         if (ret < 0) {
 155                 DRM_DEV_ERROR(lvds->dev, "failed to get pm runtime: %d\n", ret);
 156                 clk_disable(lvds->pclk);
 157                 return ret;
 158         }
 159         val = RK3288_LVDS_CH0_REG0_LANE4_EN | RK3288_LVDS_CH0_REG0_LANE3_EN |
 160                 RK3288_LVDS_CH0_REG0_LANE2_EN | RK3288_LVDS_CH0_REG0_LANE1_EN |
 161                 RK3288_LVDS_CH0_REG0_LANE0_EN;
 162         if (lvds->output == DISPLAY_OUTPUT_RGB) {
 163                 val |= RK3288_LVDS_CH0_REG0_TTL_EN |
 164                         RK3288_LVDS_CH0_REG0_LANECK_EN;
 165                 rk3288_writel(lvds, RK3288_LVDS_CH0_REG0, val);
 166                 rk3288_writel(lvds, RK3288_LVDS_CH0_REG2,
 167                               RK3288_LVDS_PLL_FBDIV_REG2(0x46));
 168                 rk3288_writel(lvds, RK3288_LVDS_CH0_REG4,
 169                               RK3288_LVDS_CH0_REG4_LANECK_TTL_MODE |
 170                               RK3288_LVDS_CH0_REG4_LANE4_TTL_MODE |
 171                               RK3288_LVDS_CH0_REG4_LANE3_TTL_MODE |
 172                               RK3288_LVDS_CH0_REG4_LANE2_TTL_MODE |
 173                               RK3288_LVDS_CH0_REG4_LANE1_TTL_MODE |
 174                               RK3288_LVDS_CH0_REG4_LANE0_TTL_MODE);
 175                 rk3288_writel(lvds, RK3288_LVDS_CH0_REG5,
 176                               RK3288_LVDS_CH0_REG5_LANECK_TTL_DATA |
 177                               RK3288_LVDS_CH0_REG5_LANE4_TTL_DATA |
 178                               RK3288_LVDS_CH0_REG5_LANE3_TTL_DATA |
 179                               RK3288_LVDS_CH0_REG5_LANE2_TTL_DATA |
 180                               RK3288_LVDS_CH0_REG5_LANE1_TTL_DATA |
 181                               RK3288_LVDS_CH0_REG5_LANE0_TTL_DATA);
 182         } else {
 183                 val |= RK3288_LVDS_CH0_REG0_LVDS_EN |
 184                             RK3288_LVDS_CH0_REG0_LANECK_EN;
 185                 rk3288_writel(lvds, RK3288_LVDS_CH0_REG0, val);
 186                 rk3288_writel(lvds, RK3288_LVDS_CH0_REG1,
 187                               RK3288_LVDS_CH0_REG1_LANECK_BIAS |
 188                               RK3288_LVDS_CH0_REG1_LANE4_BIAS |
 189                               RK3288_LVDS_CH0_REG1_LANE3_BIAS |
 190                               RK3288_LVDS_CH0_REG1_LANE2_BIAS |
 191                               RK3288_LVDS_CH0_REG1_LANE1_BIAS |
 192                               RK3288_LVDS_CH0_REG1_LANE0_BIAS);
 193                 rk3288_writel(lvds, RK3288_LVDS_CH0_REG2,
 194                               RK3288_LVDS_CH0_REG2_RESERVE_ON |
 195                               RK3288_LVDS_CH0_REG2_LANECK_LVDS_MODE |
 196                               RK3288_LVDS_CH0_REG2_LANE4_LVDS_MODE |
 197                               RK3288_LVDS_CH0_REG2_LANE3_LVDS_MODE |
 198                               RK3288_LVDS_CH0_REG2_LANE2_LVDS_MODE |
 199                               RK3288_LVDS_CH0_REG2_LANE1_LVDS_MODE |
 200                               RK3288_LVDS_CH0_REG2_LANE0_LVDS_MODE |
 201                               RK3288_LVDS_PLL_FBDIV_REG2(0x46));
 202                 rk3288_writel(lvds, RK3288_LVDS_CH0_REG4, 0x00);
 203                 rk3288_writel(lvds, RK3288_LVDS_CH0_REG5, 0x00);
 204         }
 205         rk3288_writel(lvds, RK3288_LVDS_CH0_REG3,
 206                       RK3288_LVDS_PLL_FBDIV_REG3(0x46));
 207         rk3288_writel(lvds, RK3288_LVDS_CH0_REGD,
 208                       RK3288_LVDS_PLL_PREDIV_REGD(0x0a));
 209         rk3288_writel(lvds, RK3288_LVDS_CH0_REG20,
 210                       RK3288_LVDS_CH0_REG20_LSB);
 211
 212         rk3288_writel(lvds, RK3288_LVDS_CFG_REGC,
 213                       RK3288_LVDS_CFG_REGC_PLL_ENABLE);
 214         rk3288_writel(lvds, RK3288_LVDS_CFG_REG21,
 215                       RK3288_LVDS_CFG_REG21_TX_ENABLE);
 216
 217         return 0;
 218 }
 219
 220 static void rk3288_lvds_poweroff(struct rockchip_lvds *lvds)
 221 {
 222         int ret;
 223         u32 val;
 224
 225         rk3288_writel(lvds, RK3288_LVDS_CFG_REG21,
 226                       RK3288_LVDS_CFG_REG21_TX_ENABLE);
 227         rk3288_writel(lvds, RK3288_LVDS_CFG_REGC,
 228                       RK3288_LVDS_CFG_REGC_PLL_ENABLE);
 229         val = LVDS_DUAL | LVDS_TTL_EN | LVDS_CH0_EN | LVDS_CH1_EN | LVDS_PWRDN;
 230         val |= val << 16;
 231         ret = regmap_write(lvds->grf, RK3288_LVDS_GRF_SOC_CON7, val);
 232         if (ret != 0)
 233                 DRM_DEV_ERROR(lvds->dev, "Could not write to GRF: %d\n", ret);
 234
 235         pm_runtime_put(lvds->dev);
 236         clk_disable(lvds->pclk);
 237 }
 238
 239 static int rk3288_lvds_grf_config(struct drm_encoder *encoder,
 240                                   struct drm_display_mode *mode)
 241 {
 242         struct rockchip_lvds *lvds = encoder_to_lvds(encoder);
 243         u8 pin_hsync = (mode->flags & DRM_MODE_FLAG_PHSYNC) ? 1 : 0;
 244         u8 pin_dclk = (mode->flags & DRM_MODE_FLAG_PCSYNC) ? 1 : 0;
 245         u32 val;
 246         int ret;
 247
 248         /* iomux to LCD data/sync mode */
 249         if (lvds->output == DISPLAY_OUTPUT_RGB)
 250                 if (lvds->pins && !IS_ERR(lvds->pins->default_state))
 251                         pinctrl_select_state(lvds->pins->p,
 252                                              lvds->pins->default_state);
 253         val = lvds->format | LVDS_CH0_EN;
 254         if (lvds->output == DISPLAY_OUTPUT_RGB)
 255                 val |= LVDS_TTL_EN | LVDS_CH1_EN;
 256         else if (lvds->output == DISPLAY_OUTPUT_DUAL_LVDS)
 257                 val |= LVDS_DUAL | LVDS_CH1_EN;
 258
 259         if ((mode->htotal - mode->hsync_start) & 0x01)
 260                 val |= LVDS_START_PHASE_RST_1;
 261
 262         val |= (pin_dclk << 8) | (pin_hsync << 9);
 263         val |= (0xffff << 16);
 264         ret = regmap_write(lvds->grf, RK3288_LVDS_GRF_SOC_CON7, val);
 265         if (ret)
 266                 DRM_DEV_ERROR(lvds->dev, "Could not write to GRF: %d\n", ret);
 267
 268         return ret;
 269 }
 270
 271 static int rk3288_lvds_set_vop_source(struct rockchip_lvds *lvds,
 272                                       struct drm_encoder *encoder)
 273 {
 274         u32 val;
 275         int ret;
 276
 277         ret = drm_of_encoder_active_endpoint_id(lvds->dev->of_node, encoder);
 278         if (ret < 0)
 279                 return ret;
 280
 281         val = RK3288_LVDS_SOC_CON6_SEL_VOP_LIT << 16;
 282         if (ret)
 283                 val |= RK3288_LVDS_SOC_CON6_SEL_VOP_LIT;
 284
 285         ret = regmap_write(lvds->grf, RK3288_LVDS_GRF_SOC_CON6, val);
 286         if (ret < 0)
 287                 return ret;
 288
 289         return 0;
 290 }
 291
 292 static void rk3288_lvds_encoder_enable(struct drm_encoder *encoder)
 293 {
 294         struct rockchip_lvds *lvds = encoder_to_lvds(encoder);
 295         struct drm_display_mode *mode = &encoder->crtc->state->adjusted_mode;
 296         int ret;
 297
 298         drm_panel_prepare(lvds->panel);
 299
 300         ret = rk3288_lvds_poweron(lvds);
 301         if (ret < 0) {
 302                 DRM_DEV_ERROR(lvds->dev, "failed to power on LVDS: %d\n", ret);
 303                 drm_panel_unprepare(lvds->panel);
 304                 return;
 305         }
 306
 307         ret = rk3288_lvds_grf_config(encoder, mode);
 308         if (ret) {
 309                 DRM_DEV_ERROR(lvds->dev, "failed to configure LVDS: %d\n", ret);
 310                 drm_panel_unprepare(lvds->panel);
 311                 return;
 312         }
 313
 314         ret = rk3288_lvds_set_vop_source(lvds, encoder);
 315         if (ret) {
 316                 DRM_DEV_ERROR(lvds->dev, "failed to set VOP source: %d\n", ret);
 317                 drm_panel_unprepare(lvds->panel);
 318                 return;
 319         }
 320
 321         drm_panel_enable(lvds->panel);
 322 }
 323
 324 static void rk3288_lvds_encoder_disable(struct drm_encoder *encoder)
 325 {
 326         struct rockchip_lvds *lvds = encoder_to_lvds(encoder);
 327
 328         drm_panel_disable(lvds->panel);
 329         rk3288_lvds_poweroff(lvds);
 330         drm_panel_unprepare(lvds->panel);
 331 }
 332
 333 static int px30_lvds_poweron(struct rockchip_lvds *lvds)
 334 {
 335         int ret;
 336
 337         ret = pm_runtime_resume_and_get(lvds->dev);
 338         if (ret < 0) {
 339                 DRM_DEV_ERROR(lvds->dev, "failed to get pm runtime: %d\n", ret);
 340                 return ret;
 341         }
 342
 343         /* Enable LVDS mode */
 344         ret = regmap_update_bits(lvds->grf, PX30_LVDS_GRF_PD_VO_CON1,
 345                                   PX30_LVDS_MODE_EN(1) | PX30_LVDS_P2S_EN(1),
 346                                   PX30_LVDS_MODE_EN(1) | PX30_LVDS_P2S_EN(1));
 347         if (ret)
 348                 pm_runtime_put(lvds->dev);
 349
 350         return ret;
 351 }
 352
 353 static void px30_lvds_poweroff(struct rockchip_lvds *lvds)
 354 {
 355         regmap_update_bits(lvds->grf, PX30_LVDS_GRF_PD_VO_CON1,
 356                            PX30_LVDS_MODE_EN(1) | PX30_LVDS_P2S_EN(1),
 357                            PX30_LVDS_MODE_EN(0) | PX30_LVDS_P2S_EN(0));
 358
 359         pm_runtime_put(lvds->dev);
 360 }
 361
 362 static int px30_lvds_grf_config(struct drm_encoder *encoder,
 363                                 struct drm_display_mode *mode)
 364 {
 365         struct rockchip_lvds *lvds = encoder_to_lvds(encoder);
 366
 367         if (lvds->output != DISPLAY_OUTPUT_LVDS) {
 368                 DRM_DEV_ERROR(lvds->dev, "Unsupported display output %d\n",
 369                               lvds->output);
 370                 return -EINVAL;
 371         }
 372
 373         /* Set format */
 374         return regmap_update_bits(lvds->grf, PX30_LVDS_GRF_PD_VO_CON1,
 375                                   PX30_LVDS_FORMAT(lvds->format),
 376                                   PX30_LVDS_FORMAT(lvds->format));
 377 }
 378
 379 static int px30_lvds_set_vop_source(struct rockchip_lvds *lvds,
 380                                     struct drm_encoder *encoder)
 381 {
 382         int vop;
 383
 384         vop = drm_of_encoder_active_endpoint_id(lvds->dev->of_node, encoder);
 385         if (vop < 0)
 386                 return vop;
 387
 388         return regmap_update_bits(lvds->grf, PX30_LVDS_GRF_PD_VO_CON1,
 389                                   PX30_LVDS_VOP_SEL(1),
 390                                   PX30_LVDS_VOP_SEL(vop));
 391 }
 392
 393 static void px30_lvds_encoder_enable(struct drm_encoder *encoder)
 394 {
 395         struct rockchip_lvds *lvds = encoder_to_lvds(encoder);
 396         struct drm_display_mode *mode = &encoder->crtc->state->adjusted_mode;
 397         int ret;
 398
 399         drm_panel_prepare(lvds->panel);
 400
 401         ret = px30_lvds_poweron(lvds);
 402         if (ret) {
 403                 DRM_DEV_ERROR(lvds->dev, "failed to power on LVDS: %d\n", ret);
 404                 drm_panel_unprepare(lvds->panel);
 405                 return;
 406         }
 407
 408         ret = px30_lvds_grf_config(encoder, mode);
 409         if (ret) {
 410                 DRM_DEV_ERROR(lvds->dev, "failed to configure LVDS: %d\n", ret);
 411                 drm_panel_unprepare(lvds->panel);
 412                 return;
 413         }
 414
 415         ret = px30_lvds_set_vop_source(lvds, encoder);
 416         if (ret) {
 417                 DRM_DEV_ERROR(lvds->dev, "failed to set VOP source: %d\n", ret);
 418                 drm_panel_unprepare(lvds->panel);
 419                 return;
 420         }
 421
 422         drm_panel_enable(lvds->panel);
 423 }
 424
 425 static void px30_lvds_encoder_disable(struct drm_encoder *encoder)
 426 {
 427         struct rockchip_lvds *lvds = encoder_to_lvds(encoder);
 428
 429         drm_panel_disable(lvds->panel);
 430         px30_lvds_poweroff(lvds);
 431         drm_panel_unprepare(lvds->panel);
 432 }
 433
 434 static const
 435 struct drm_encoder_helper_funcs rk3288_lvds_encoder_helper_funcs = {
 436         .enable = rk3288_lvds_encoder_enable,
 437         .disable = rk3288_lvds_encoder_disable,
 438         .atomic_check = rockchip_lvds_encoder_atomic_check,
 439 };
 440
 441 static const
 442 struct drm_encoder_helper_funcs px30_lvds_encoder_helper_funcs = {
 443         .enable = px30_lvds_encoder_enable,
 444         .disable = px30_lvds_encoder_disable,
 445         .atomic_check = rockchip_lvds_encoder_atomic_check,
 446 };
 447
 448 static int rk3288_lvds_probe(struct platform_device *pdev,
 449                              struct rockchip_lvds *lvds)
 450 {
 451         int ret;
 452
 453         lvds->regs = devm_platform_ioremap_resource(pdev, 0);
 454         if (IS_ERR(lvds->regs))
 455                 return PTR_ERR(lvds->regs);
 456
 457         lvds->pclk = devm_clk_get(lvds->dev, "pclk_lvds");
 458         if (IS_ERR(lvds->pclk)) {
 459                 DRM_DEV_ERROR(lvds->dev, "could not get pclk_lvds\n");
 460                 return PTR_ERR(lvds->pclk);
 461         }
 462
 463         lvds->pins = devm_kzalloc(lvds->dev, sizeof(*lvds->pins),
 464                                   GFP_KERNEL);
 465         if (!lvds->pins)
 466                 return -ENOMEM;
 467
 468         lvds->pins->p = devm_pinctrl_get(lvds->dev);
 469         if (IS_ERR(lvds->pins->p)) {
 470                 DRM_DEV_ERROR(lvds->dev, "no pinctrl handle\n");
 471                 devm_kfree(lvds->dev, lvds->pins);
 472                 lvds->pins = NULL;
 473         } else {
 474                 lvds->pins->default_state =
 475                         pinctrl_lookup_state(lvds->pins->p, "lcdc");
 476                 if (IS_ERR(lvds->pins->default_state)) {
 477                         DRM_DEV_ERROR(lvds->dev, "no default pinctrl state\n");
 478                         devm_kfree(lvds->dev, lvds->pins);
 479                         lvds->pins = NULL;
 480                 }
 481         }
 482
 483         ret = clk_prepare(lvds->pclk);
 484         if (ret < 0) {
 485                 DRM_DEV_ERROR(lvds->dev, "failed to prepare pclk_lvds\n");
 486                 return ret;
 487         }
 488
 489         return 0;
 490 }
 491
 492 static int px30_lvds_probe(struct platform_device *pdev,
 493                            struct rockchip_lvds *lvds)
 494 {
 495         int ret;
 496
 497         /* MSB */
 498         ret =  regmap_update_bits(lvds->grf, PX30_LVDS_GRF_PD_VO_CON1,
 499                                   PX30_LVDS_MSBSEL(1),
 500                                   PX30_LVDS_MSBSEL(1));
 501         if (ret)
 502                 return ret;
 503
 504         /* PHY */
 505         lvds->dphy = devm_phy_get(&pdev->dev, "dphy");
 506         if (IS_ERR(lvds->dphy))
 507                 return PTR_ERR(lvds->dphy);
 508
 509         ret = phy_init(lvds->dphy);
 510         if (ret)
 511                 return ret;
 512
 513         ret = phy_set_mode(lvds->dphy, PHY_MODE_LVDS);
 514         if (ret)
 515                 return ret;
 516
 517         return phy_power_on(lvds->dphy);
 518 }
 519
 520 static const struct rockchip_lvds_soc_data rk3288_lvds_data = {
 521         .probe = rk3288_lvds_probe,
 522         .helper_funcs = &rk3288_lvds_encoder_helper_funcs,
 523 };
 524
 525 static const struct rockchip_lvds_soc_data px30_lvds_data = {
 526         .probe = px30_lvds_probe,
 527         .helper_funcs = &px30_lvds_encoder_helper_funcs,
 528 };
 529
 530 static const struct of_device_id rockchip_lvds_dt_ids[] = {
 531         {
 532                 .compatible = "rockchip,rk3288-lvds",
 533                 .data = &rk3288_lvds_data
 534         },
 535         {
 536                 .compatible = "rockchip,px30-lvds",
 537                 .data = &px30_lvds_data
 538         },
 539         {}
 540 };
 541 MODULE_DEVICE_TABLE(of, rockchip_lvds_dt_ids);
 542
 543 static int rockchip_lvds_bind(struct device *dev, struct device *master,
 544                               void *data)
 545 {
 546         struct rockchip_lvds *lvds = dev_get_drvdata(dev);
 547         struct drm_device *drm_dev = data;
 548         struct drm_encoder *encoder;
 549         struct drm_connector *connector;
 550         struct device_node *remote = NULL;
 551         struct device_node  *port, *endpoint;
 552         int ret = 0, child_count = 0;
 553         const char *name;
 554         u32 endpoint_id = 0;
 555
 556         lvds->drm_dev = drm_dev;
 557         port = of_graph_get_port_by_id(dev->of_node, 1);
 558         if (!port) {
 559                 DRM_DEV_ERROR(dev,
 560                               "can't found port point, please init lvds panel port!\n");
 561                 return -EINVAL;
 562         }
 563         for_each_child_of_node(port, endpoint) {
 564                 child_count++;
 565                 of_property_read_u32(endpoint, "reg", &endpoint_id);
 566                 ret = drm_of_find_panel_or_bridge(dev->of_node, 1, endpoint_id,
 567                                                   &lvds->panel, &lvds->bridge);
 568                 if (!ret) {
 569                         of_node_put(endpoint);
 570                         break;
 571                 }
 572         }
 573         if (!child_count) {
 574                 DRM_DEV_ERROR(dev, "lvds port does not have any children\n");
 575                 ret = -EINVAL;
 576                 goto err_put_port;
 577         } else if (ret) {
 578                 dev_err_probe(dev, ret, "failed to find panel and bridge node\n");
 579                 goto err_put_port;
 580         }
 581         if (lvds->panel)
 582                 remote = lvds->panel->dev->of_node;
 583         else
 584                 remote = lvds->bridge->of_node;
 585         if (of_property_read_string(dev->of_node, "rockchip,output", &name))
 586                 /* default set it as output rgb */
 587                 lvds->output = DISPLAY_OUTPUT_RGB;
 588         else
 589                 lvds->output = rockchip_lvds_name_to_output(name);
 590
 591         if (lvds->output < 0) {
 592                 DRM_DEV_ERROR(dev, "invalid output type [%s]\n", name);
 593                 ret = lvds->output;
 594                 goto err_put_remote;
 595         }
 596
 597         if (of_property_read_string(remote, "data-mapping", &name))
 598                 /* default set it as format vesa 18 */
 599                 lvds->format = LVDS_VESA_18;
 600         else
 601                 lvds->format = rockchip_lvds_name_to_format(name);
 602
 603         if (lvds->format < 0) {
 604                 DRM_DEV_ERROR(dev, "invalid data-mapping format [%s]\n", name);
 605                 ret = lvds->format;
 606                 goto err_put_remote;
 607         }
 608
 609         encoder = &lvds->encoder.encoder;
 610         encoder->possible_crtcs = drm_of_find_possible_crtcs(drm_dev,
 611                                                              dev->of_node);
 612
 613         ret = drm_simple_encoder_init(drm_dev, encoder, DRM_MODE_ENCODER_LVDS);
 614         if (ret < 0) {
 615                 DRM_DEV_ERROR(drm_dev->dev,
 616                               "failed to initialize encoder: %d\n", ret);
 617                 goto err_put_remote;
 618         }
 619
 620         drm_encoder_helper_add(encoder, lvds->soc_data->helper_funcs);
 621         connector = &lvds->connector;
 622
 623         if (lvds->panel) {
 624                 connector->dpms = DRM_MODE_DPMS_OFF;
 625                 ret = drm_connector_init(drm_dev, connector,
 626                                          &rockchip_lvds_connector_funcs,
 627                                          DRM_MODE_CONNECTOR_LVDS);
 628                 if (ret < 0) {
 629                         DRM_DEV_ERROR(drm_dev->dev,
 630                                       "failed to initialize connector: %d\n", ret);
 631                         goto err_free_encoder;
 632                 }
 633
 634                 drm_connector_helper_add(connector,
 635                                          &rockchip_lvds_connector_helper_funcs);
 636         } else {
 637                 ret = drm_bridge_attach(encoder, lvds->bridge, NULL,
 638                                         DRM_BRIDGE_ATTACH_NO_CONNECTOR);
 639                 if (ret)
 640                         goto err_free_encoder;
 641
 642                 connector = drm_bridge_connector_init(lvds->drm_dev, encoder);
 643                 if (IS_ERR(connector)) {
 644                         DRM_DEV_ERROR(drm_dev->dev,
 645                                       "failed to initialize bridge connector: %pe\n",
 646                                       connector);
 647                         ret = PTR_ERR(connector);
 648                         goto err_free_encoder;
 649                 }
 650         }
 651
 652         ret = drm_connector_attach_encoder(connector, encoder);
 653         if (ret < 0) {
 654                 DRM_DEV_ERROR(drm_dev->dev,
 655                               "failed to attach encoder: %d\n", ret);
 656                 goto err_free_connector;
 657         }
 658
 659         pm_runtime_enable(dev);
 660         of_node_put(remote);
 661         of_node_put(port);
 662
 663         return 0;
 664
 665 err_free_connector:
 666         drm_connector_cleanup(connector);
 667 err_free_encoder:
 668         drm_encoder_cleanup(encoder);
 669 err_put_remote:
 670         of_node_put(remote);
 671 err_put_port:
 672         of_node_put(port);
 673
 674         return ret;
 675 }
 676
 677 static void rockchip_lvds_unbind(struct device *dev, struct device *master,
 678                                 void *data)
 679 {
 680         struct rockchip_lvds *lvds = dev_get_drvdata(dev);
 681         const struct drm_encoder_helper_funcs *encoder_funcs;
 682
 683         encoder_funcs = lvds->soc_data->helper_funcs;
 684         encoder_funcs->disable(&lvds->encoder.encoder);
 685         pm_runtime_disable(dev);
 686         drm_connector_cleanup(&lvds->connector);
 687         drm_encoder_cleanup(&lvds->encoder.encoder);
 688 }
 689
 690 static const struct component_ops rockchip_lvds_component_ops = {
 691         .bind = rockchip_lvds_bind,
 692         .unbind = rockchip_lvds_unbind,
 693 };
 694
 695 static int rockchip_lvds_probe(struct platform_device *pdev)
 696 {
 697         struct device *dev = &pdev->dev;
 698         struct rockchip_lvds *lvds;
 699         const struct of_device_id *match;
 700         int ret;
 701
 702         if (!dev->of_node)
 703                 return -ENODEV;
 704
 705         lvds = devm_kzalloc(&pdev->dev, sizeof(*lvds), GFP_KERNEL);
 706         if (!lvds)
 707                 return -ENOMEM;
 708
 709         lvds->dev = dev;
 710         match = of_match_node(rockchip_lvds_dt_ids, dev->of_node);
 711         if (!match)
 712                 return -ENODEV;
 713         lvds->soc_data = match->data;
 714
 715         lvds->grf = syscon_regmap_lookup_by_phandle(dev->of_node,
 716                                                     "rockchip,grf");
 717         if (IS_ERR(lvds->grf)) {
 718                 DRM_DEV_ERROR(dev, "missing rockchip,grf property\n");
 719                 return PTR_ERR(lvds->grf);
 720         }
 721
 722         ret = lvds->soc_data->probe(pdev, lvds);
 723         if (ret) {
 724                 DRM_DEV_ERROR(dev, "Platform initialization failed\n");
 725                 return ret;
 726         }
 727
 728         dev_set_drvdata(dev, lvds);
 729
 730         ret = component_add(&pdev->dev, &rockchip_lvds_component_ops);
 731         if (ret < 0) {
 732                 DRM_DEV_ERROR(dev, "failed to add component\n");
 733                 clk_unprepare(lvds->pclk);
 734         }
 735
 736         return ret;
 737 }
 738
 739 static void rockchip_lvds_remove(struct platform_device *pdev)
 740 {
 741         struct rockchip_lvds *lvds = platform_get_drvdata(pdev);
 742
 743         component_del(&pdev->dev, &rockchip_lvds_component_ops);
 744         clk_unprepare(lvds->pclk);
 745 }
 746
 747 struct platform_driver rockchip_lvds_driver = {
 748         .probe = rockchip_lvds_probe,
 749         .remove = rockchip_lvds_remove,
 750         .driver = {
 751                    .name = "rockchip-lvds",
 752                    .of_match_table = rockchip_lvds_dt_ids,
 753         },
 754 };