drivers/gpu/drm/mediatek/mtk_dsi.c

   1 /*
   2  * Copyright (c) 2015 MediaTek Inc.
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License version 2 as
   6  * published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  */
  13
  14 #include <drm/drmP.h>
  15 #include <drm/drm_atomic_helper.h>
  16 #include <drm/drm_crtc_helper.h>
  17 #include <drm/drm_mipi_dsi.h>
  18 #include <drm/drm_panel.h>
  19 #include <linux/clk.h>
  20 #include <linux/component.h>
  21 #include <linux/of.h>
  22 #include <linux/of_platform.h>
  23 #include <linux/of_graph.h>
  24 #include <linux/phy/phy.h>
  25 #include <linux/platform_device.h>
  26 #include <video/videomode.h>
  27
  28 #include "mtk_drm_ddp_comp.h"
  29
  30 #define DSI_VIDEO_FIFO_DEPTH    (1920 / 4)
  31 #define DSI_HOST_FIFO_DEPTH     64
  32
  33 #define DSI_START               0x00
  34
  35 #define DSI_CON_CTRL            0x10
  36 #define DSI_RESET                       BIT(0)
  37 #define DSI_EN                          BIT(1)
  38
  39 #define DSI_MODE_CTRL           0x14
  40 #define MODE                            (3)
  41 #define CMD_MODE                        0
  42 #define SYNC_PULSE_MODE                 1
  43 #define SYNC_EVENT_MODE                 2
  44 #define BURST_MODE                      3
  45 #define FRM_MODE                        BIT(16)
  46 #define MIX_MODE                        BIT(17)
  47
  48 #define DSI_TXRX_CTRL           0x18
  49 #define VC_NUM                          (2 << 0)
  50 #define LANE_NUM                        (0xf << 2)
  51 #define DIS_EOT                         BIT(6)
  52 #define NULL_EN                         BIT(7)
  53 #define TE_FREERUN                      BIT(8)
  54 #define EXT_TE_EN                       BIT(9)
  55 #define EXT_TE_EDGE                     BIT(10)
  56 #define MAX_RTN_SIZE                    (0xf << 12)
  57 #define HSTX_CKLP_EN                    BIT(16)
  58
  59 #define DSI_PSCTRL              0x1c
  60 #define DSI_PS_WC                       0x3fff
  61 #define DSI_PS_SEL                      (3 << 16)
  62 #define PACKED_PS_16BIT_RGB565          (0 << 16)
  63 #define LOOSELY_PS_18BIT_RGB666         (1 << 16)
  64 #define PACKED_PS_18BIT_RGB666          (2 << 16)
  65 #define PACKED_PS_24BIT_RGB888          (3 << 16)
  66
  67 #define DSI_VSA_NL              0x20
  68 #define DSI_VBP_NL              0x24
  69 #define DSI_VFP_NL              0x28
  70 #define DSI_VACT_NL             0x2C
  71 #define DSI_HSA_WC              0x50
  72 #define DSI_HBP_WC              0x54
  73 #define DSI_HFP_WC              0x58
  74
  75 #define DSI_HSTX_CKL_WC         0x64
  76
  77 #define DSI_PHY_LCCON           0x104
  78 #define LC_HS_TX_EN                     BIT(0)
  79 #define LC_ULPM_EN                      BIT(1)
  80 #define LC_WAKEUP_EN                    BIT(2)
  81
  82 #define DSI_PHY_LD0CON          0x108
  83 #define LD0_HS_TX_EN                    BIT(0)
  84 #define LD0_ULPM_EN                     BIT(1)
  85 #define LD0_WAKEUP_EN                   BIT(2)
  86
  87 #define DSI_PHY_TIMECON0        0x110
  88 #define LPX                             (0xff << 0)
  89 #define HS_PREP                         (0xff << 8)
  90 #define HS_ZERO                         (0xff << 16)
  91 #define HS_TRAIL                        (0xff << 24)
  92
  93 #define DSI_PHY_TIMECON1        0x114
  94 #define TA_GO                           (0xff << 0)
  95 #define TA_SURE                         (0xff << 8)
  96 #define TA_GET                          (0xff << 16)
  97 #define DA_HS_EXIT                      (0xff << 24)
  98
  99 #define DSI_PHY_TIMECON2        0x118
 100 #define CONT_DET                        (0xff << 0)
 101 #define CLK_ZERO                        (0xff << 16)
 102 #define CLK_TRAIL                       (0xff << 24)
 103
 104 #define DSI_PHY_TIMECON3        0x11c
 105 #define CLK_HS_PREP                     (0xff << 0)
 106 #define CLK_HS_POST                     (0xff << 8)
 107 #define CLK_HS_EXIT                     (0xff << 16)
 108
 109 #define T_LPX           5
 110 #define T_HS_PREP       6
 111 #define T_HS_TRAIL      8
 112 #define T_HS_EXIT       7
 113 #define T_HS_ZERO       10
 114
 115 #define NS_TO_CYCLE(n, c)    ((n) / (c) + (((n) % (c)) ? 1 : 0))
 116
 117 struct phy;
 118
 119 struct mtk_dsi {
 120         struct mtk_ddp_comp ddp_comp;
 121         struct device *dev;
 122         struct mipi_dsi_host host;
 123         struct drm_encoder encoder;
 124         struct drm_connector conn;
 125         struct drm_panel *panel;
 126         struct drm_bridge *bridge;
 127         struct phy *phy;
 128
 129         void __iomem *regs;
 130
 131         struct clk *engine_clk;
 132         struct clk *digital_clk;
 133         struct clk *hs_clk;
 134
 135         u32 data_rate;
 136
 137         unsigned long mode_flags;
 138         enum mipi_dsi_pixel_format format;
 139         unsigned int lanes;
 140         struct videomode vm;
 141         int refcount;
 142         bool enabled;
 143 };
 144
 145 static inline struct mtk_dsi *encoder_to_dsi(struct drm_encoder *e)
 146 {
 147         return container_of(e, struct mtk_dsi, encoder);
 148 }
 149
 150 static inline struct mtk_dsi *connector_to_dsi(struct drm_connector *c)
 151 {
 152         return container_of(c, struct mtk_dsi, conn);
 153 }
 154
 155 static inline struct mtk_dsi *host_to_dsi(struct mipi_dsi_host *h)
 156 {
 157         return container_of(h, struct mtk_dsi, host);
 158 }
 159
 160 static void mtk_dsi_mask(struct mtk_dsi *dsi, u32 offset, u32 mask, u32 data)
 161 {
 162         u32 temp = readl(dsi->regs + offset);
 163
 164         writel((temp & ~mask) | (data & mask), dsi->regs + offset);
 165 }
 166
 167 static void dsi_phy_timconfig(struct mtk_dsi *dsi)
 168 {
 169         u32 timcon0, timcon1, timcon2, timcon3;
 170         u32 ui, cycle_time;
 171
 172         ui = 1000 / dsi->data_rate + 0x01;
 173         cycle_time = 8000 / dsi->data_rate + 0x01;
 174
 175         timcon0 = T_LPX | T_HS_PREP << 8 | T_HS_ZERO << 16 | T_HS_TRAIL << 24;
 176         timcon1 = 4 * T_LPX | (3 * T_LPX / 2) << 8 | 5 * T_LPX << 16 |
 177                   T_HS_EXIT << 24;
 178         timcon2 = ((NS_TO_CYCLE(0x64, cycle_time) + 0xa) << 24) |
 179                   (NS_TO_CYCLE(0x150, cycle_time) << 16);
 180         timcon3 = NS_TO_CYCLE(0x40, cycle_time) | (2 * T_LPX) << 16 |
 181                   NS_TO_CYCLE(80 + 52 * ui, cycle_time) << 8;
 182
 183         writel(timcon0, dsi->regs + DSI_PHY_TIMECON0);
 184         writel(timcon1, dsi->regs + DSI_PHY_TIMECON1);
 185         writel(timcon2, dsi->regs + DSI_PHY_TIMECON2);
 186         writel(timcon3, dsi->regs + DSI_PHY_TIMECON3);
 187 }
 188
 189 static void mtk_dsi_enable(struct mtk_dsi *dsi)
 190 {
 191         mtk_dsi_mask(dsi, DSI_CON_CTRL, DSI_EN, DSI_EN);
 192 }
 193
 194 static void mtk_dsi_disable(struct mtk_dsi *dsi)
 195 {
 196         mtk_dsi_mask(dsi, DSI_CON_CTRL, DSI_EN, 0);
 197 }
 198
 199 static void mtk_dsi_reset(struct mtk_dsi *dsi)
 200 {
 201         mtk_dsi_mask(dsi, DSI_CON_CTRL, DSI_RESET, DSI_RESET);
 202         mtk_dsi_mask(dsi, DSI_CON_CTRL, DSI_RESET, 0);
 203 }
 204
 205 static int mtk_dsi_poweron(struct mtk_dsi *dsi)
 206 {
 207         struct device *dev = dsi->dev;
 208         int ret;
 209         u64 pixel_clock, total_bits;
 210         u32 htotal, htotal_bits, bit_per_pixel, overhead_cycles, overhead_bits;
 211
 212         if (++dsi->refcount != 1)
 213                 return 0;
 214
 215         switch (dsi->format) {
 216         case MIPI_DSI_FMT_RGB565:
 217                 bit_per_pixel = 16;
 218                 break;
 219         case MIPI_DSI_FMT_RGB666_PACKED:
 220                 bit_per_pixel = 18;
 221                 break;
 222         case MIPI_DSI_FMT_RGB666:
 223         case MIPI_DSI_FMT_RGB888:
 224         default:
 225                 bit_per_pixel = 24;
 226                 break;
 227         }
 228
 229         /**
 230          * vm.pixelclock is in kHz, pixel_clock unit is Hz, so multiply by 1000
 231          * htotal_time = htotal * byte_per_pixel / num_lanes
 232          * overhead_time = lpx + hs_prepare + hs_zero + hs_trail + hs_exit
 233          * mipi_ratio = (htotal_time + overhead_time) / htotal_time
 234          * data_rate = pixel_clock * bit_per_pixel * mipi_ratio / num_lanes;
 235          */
 236         pixel_clock = dsi->vm.pixelclock * 1000;
 237         htotal = dsi->vm.hactive + dsi->vm.hback_porch + dsi->vm.hfront_porch +
 238                         dsi->vm.hsync_len;
 239         htotal_bits = htotal * bit_per_pixel;
 240
 241         overhead_cycles = T_LPX + T_HS_PREP + T_HS_ZERO + T_HS_TRAIL +
 242                         T_HS_EXIT;
 243         overhead_bits = overhead_cycles * dsi->lanes * 8;
 244         total_bits = htotal_bits + overhead_bits;
 245
 246         dsi->data_rate = DIV_ROUND_UP_ULL(pixel_clock * total_bits,
 247                                           htotal * dsi->lanes);
 248
 249         ret = clk_set_rate(dsi->hs_clk, dsi->data_rate);
 250         if (ret < 0) {
 251                 dev_err(dev, "Failed to set data rate: %d\n", ret);
 252                 goto err_refcount;
 253         }
 254
 255         phy_power_on(dsi->phy);
 256
 257         ret = clk_prepare_enable(dsi->engine_clk);
 258         if (ret < 0) {
 259                 dev_err(dev, "Failed to enable engine clock: %d\n", ret);
 260                 goto err_phy_power_off;
 261         }
 262
 263         ret = clk_prepare_enable(dsi->digital_clk);
 264         if (ret < 0) {
 265                 dev_err(dev, "Failed to enable digital clock: %d\n", ret);
 266                 goto err_disable_engine_clk;
 267         }
 268
 269         mtk_dsi_enable(dsi);
 270         mtk_dsi_reset(dsi);
 271         dsi_phy_timconfig(dsi);
 272
 273         return 0;
 274
 275 err_disable_engine_clk:
 276         clk_disable_unprepare(dsi->engine_clk);
 277 err_phy_power_off:
 278         phy_power_off(dsi->phy);
 279 err_refcount:
 280         dsi->refcount--;
 281         return ret;
 282 }
 283
 284 static void dsi_clk_ulp_mode_enter(struct mtk_dsi *dsi)
 285 {
 286         mtk_dsi_mask(dsi, DSI_PHY_LCCON, LC_HS_TX_EN, 0);
 287         mtk_dsi_mask(dsi, DSI_PHY_LCCON, LC_ULPM_EN, 0);
 288 }
 289
 290 static void dsi_clk_ulp_mode_leave(struct mtk_dsi *dsi)
 291 {
 292         mtk_dsi_mask(dsi, DSI_PHY_LCCON, LC_ULPM_EN, 0);
 293         mtk_dsi_mask(dsi, DSI_PHY_LCCON, LC_WAKEUP_EN, LC_WAKEUP_EN);
 294         mtk_dsi_mask(dsi, DSI_PHY_LCCON, LC_WAKEUP_EN, 0);
 295 }
 296
 297 static void dsi_lane0_ulp_mode_enter(struct mtk_dsi *dsi)
 298 {
 299         mtk_dsi_mask(dsi, DSI_PHY_LD0CON, LD0_HS_TX_EN, 0);
 300         mtk_dsi_mask(dsi, DSI_PHY_LD0CON, LD0_ULPM_EN, 0);
 301 }
 302
 303 static void dsi_lane0_ulp_mode_leave(struct mtk_dsi *dsi)
 304 {
 305         mtk_dsi_mask(dsi, DSI_PHY_LD0CON, LD0_ULPM_EN, 0);
 306         mtk_dsi_mask(dsi, DSI_PHY_LD0CON, LD0_WAKEUP_EN, LD0_WAKEUP_EN);
 307         mtk_dsi_mask(dsi, DSI_PHY_LD0CON, LD0_WAKEUP_EN, 0);
 308 }
 309
 310 static bool dsi_clk_hs_state(struct mtk_dsi *dsi)
 311 {
 312         u32 tmp_reg1;
 313
 314         tmp_reg1 = readl(dsi->regs + DSI_PHY_LCCON);
 315         return ((tmp_reg1 & LC_HS_TX_EN) == 1) ? true : false;
 316 }
 317
 318 static void dsi_clk_hs_mode(struct mtk_dsi *dsi, bool enter)
 319 {
 320         if (enter && !dsi_clk_hs_state(dsi))
 321                 mtk_dsi_mask(dsi, DSI_PHY_LCCON, LC_HS_TX_EN, LC_HS_TX_EN);
 322         else if (!enter && dsi_clk_hs_state(dsi))
 323                 mtk_dsi_mask(dsi, DSI_PHY_LCCON, LC_HS_TX_EN, 0);
 324 }
 325
 326 static void dsi_set_mode(struct mtk_dsi *dsi)
 327 {
 328         u32 vid_mode = CMD_MODE;
 329
 330         if (dsi->mode_flags & MIPI_DSI_MODE_VIDEO) {
 331                 vid_mode = SYNC_PULSE_MODE;
 332
 333                 if ((dsi->mode_flags & MIPI_DSI_MODE_VIDEO_BURST) &&
 334                     !(dsi->mode_flags & MIPI_DSI_MODE_VIDEO_SYNC_PULSE))
 335                         vid_mode = BURST_MODE;
 336         }
 337
 338         writel(vid_mode, dsi->regs + DSI_MODE_CTRL);
 339 }
 340
 341 static void dsi_ps_control_vact(struct mtk_dsi *dsi)
 342 {
 343         struct videomode *vm = &dsi->vm;
 344         u32 dsi_buf_bpp, ps_wc;
 345         u32 ps_bpp_mode;
 346
 347         if (dsi->format == MIPI_DSI_FMT_RGB565)
 348                 dsi_buf_bpp = 2;
 349         else
 350                 dsi_buf_bpp = 3;
 351
 352         ps_wc = vm->hactive * dsi_buf_bpp;
 353         ps_bpp_mode = ps_wc;
 354
 355         switch (dsi->format) {
 356         case MIPI_DSI_FMT_RGB888:
 357                 ps_bpp_mode |= PACKED_PS_24BIT_RGB888;
 358                 break;
 359         case MIPI_DSI_FMT_RGB666:
 360                 ps_bpp_mode |= PACKED_PS_18BIT_RGB666;
 361                 break;
 362         case MIPI_DSI_FMT_RGB666_PACKED:
 363                 ps_bpp_mode |= LOOSELY_PS_18BIT_RGB666;
 364                 break;
 365         case MIPI_DSI_FMT_RGB565:
 366                 ps_bpp_mode |= PACKED_PS_16BIT_RGB565;
 367                 break;
 368         }
 369
 370         writel(vm->vactive, dsi->regs + DSI_VACT_NL);
 371         writel(ps_bpp_mode, dsi->regs + DSI_PSCTRL);
 372         writel(ps_wc, dsi->regs + DSI_HSTX_CKL_WC);
 373 }
 374
 375 static void dsi_rxtx_control(struct mtk_dsi *dsi)
 376 {
 377         u32 tmp_reg;
 378
 379         switch (dsi->lanes) {
 380         case 1:
 381                 tmp_reg = 1 << 2;
 382                 break;
 383         case 2:
 384                 tmp_reg = 3 << 2;
 385                 break;
 386         case 3:
 387                 tmp_reg = 7 << 2;
 388                 break;
 389         case 4:
 390                 tmp_reg = 0xf << 2;
 391                 break;
 392         default:
 393                 tmp_reg = 0xf << 2;
 394                 break;
 395         }
 396
 397         writel(tmp_reg, dsi->regs + DSI_TXRX_CTRL);
 398 }
 399
 400 static void dsi_ps_control(struct mtk_dsi *dsi)
 401 {
 402         unsigned int dsi_tmp_buf_bpp;
 403         u32 tmp_reg;
 404
 405         switch (dsi->format) {
 406         case MIPI_DSI_FMT_RGB888:
 407                 tmp_reg = PACKED_PS_24BIT_RGB888;
 408                 dsi_tmp_buf_bpp = 3;
 409                 break;
 410         case MIPI_DSI_FMT_RGB666:
 411                 tmp_reg = LOOSELY_PS_18BIT_RGB666;
 412                 dsi_tmp_buf_bpp = 3;
 413                 break;
 414         case MIPI_DSI_FMT_RGB666_PACKED:
 415                 tmp_reg = PACKED_PS_18BIT_RGB666;
 416                 dsi_tmp_buf_bpp = 3;
 417                 break;
 418         case MIPI_DSI_FMT_RGB565:
 419                 tmp_reg = PACKED_PS_16BIT_RGB565;
 420                 dsi_tmp_buf_bpp = 2;
 421                 break;
 422         default:
 423                 tmp_reg = PACKED_PS_24BIT_RGB888;
 424                 dsi_tmp_buf_bpp = 3;
 425                 break;
 426         }
 427
 428         tmp_reg += dsi->vm.hactive * dsi_tmp_buf_bpp & DSI_PS_WC;
 429         writel(tmp_reg, dsi->regs + DSI_PSCTRL);
 430 }
 431
 432 static void dsi_config_vdo_timing(struct mtk_dsi *dsi)
 433 {
 434         unsigned int horizontal_sync_active_byte;
 435         unsigned int horizontal_backporch_byte;
 436         unsigned int horizontal_frontporch_byte;
 437         unsigned int dsi_tmp_buf_bpp;
 438
 439         struct videomode *vm = &dsi->vm;
 440
 441         if (dsi->format == MIPI_DSI_FMT_RGB565)
 442                 dsi_tmp_buf_bpp = 2;
 443         else
 444                 dsi_tmp_buf_bpp = 3;
 445
 446         writel(vm->vsync_len, dsi->regs + DSI_VSA_NL);
 447         writel(vm->vback_porch, dsi->regs + DSI_VBP_NL);
 448         writel(vm->vfront_porch, dsi->regs + DSI_VFP_NL);
 449         writel(vm->vactive, dsi->regs + DSI_VACT_NL);
 450
 451         horizontal_sync_active_byte = (vm->hsync_len * dsi_tmp_buf_bpp - 10);
 452
 453         if (dsi->mode_flags & MIPI_DSI_MODE_VIDEO_SYNC_PULSE)
 454                 horizontal_backporch_byte =
 455                         (vm->hback_porch * dsi_tmp_buf_bpp - 10);
 456         else
 457                 horizontal_backporch_byte = ((vm->hback_porch + vm->hsync_len) *
 458                         dsi_tmp_buf_bpp - 10);
 459
 460         horizontal_frontporch_byte = (vm->hfront_porch * dsi_tmp_buf_bpp - 12);
 461
 462         writel(horizontal_sync_active_byte, dsi->regs + DSI_HSA_WC);
 463         writel(horizontal_backporch_byte, dsi->regs + DSI_HBP_WC);
 464         writel(horizontal_frontporch_byte, dsi->regs + DSI_HFP_WC);
 465
 466         dsi_ps_control(dsi);
 467 }
 468
 469 static void mtk_dsi_start(struct mtk_dsi *dsi)
 470 {
 471         writel(0, dsi->regs + DSI_START);
 472         writel(1, dsi->regs + DSI_START);
 473 }
 474
 475 static void mtk_dsi_poweroff(struct mtk_dsi *dsi)
 476 {
 477         if (WARN_ON(dsi->refcount == 0))
 478                 return;
 479
 480         if (--dsi->refcount != 0)
 481                 return;
 482
 483         dsi_lane0_ulp_mode_enter(dsi);
 484         dsi_clk_ulp_mode_enter(dsi);
 485
 486         mtk_dsi_disable(dsi);
 487
 488         clk_disable_unprepare(dsi->engine_clk);
 489         clk_disable_unprepare(dsi->digital_clk);
 490
 491         phy_power_off(dsi->phy);
 492 }
 493
 494 static void mtk_output_dsi_enable(struct mtk_dsi *dsi)
 495 {
 496         int ret;
 497
 498         if (dsi->enabled)
 499                 return;
 500
 501         if (dsi->panel) {
 502                 if (drm_panel_prepare(dsi->panel)) {
 503                         DRM_ERROR("failed to setup the panel\n");
 504                         return;
 505                 }
 506         }
 507
 508         ret = mtk_dsi_poweron(dsi);
 509         if (ret < 0) {
 510                 DRM_ERROR("failed to power on dsi\n");
 511                 return;
 512         }
 513
 514         dsi_rxtx_control(dsi);
 515
 516         dsi_clk_ulp_mode_leave(dsi);
 517         dsi_lane0_ulp_mode_leave(dsi);
 518         dsi_clk_hs_mode(dsi, 0);
 519         dsi_set_mode(dsi);
 520
 521         dsi_ps_control_vact(dsi);
 522         dsi_config_vdo_timing(dsi);
 523
 524         dsi_set_mode(dsi);
 525         dsi_clk_hs_mode(dsi, 1);
 526
 527         mtk_dsi_start(dsi);
 528
 529         dsi->enabled = true;
 530 }
 531
 532 static void mtk_output_dsi_disable(struct mtk_dsi *dsi)
 533 {
 534         if (!dsi->enabled)
 535                 return;
 536
 537         if (dsi->panel) {
 538                 if (drm_panel_disable(dsi->panel)) {
 539                         DRM_ERROR("failed to disable the panel\n");
 540                         return;
 541                 }
 542         }
 543
 544         mtk_dsi_poweroff(dsi);
 545
 546         dsi->enabled = false;
 547 }
 548
 549 static void mtk_dsi_encoder_destroy(struct drm_encoder *encoder)
 550 {
 551         drm_encoder_cleanup(encoder);
 552 }
 553
 554 static const struct drm_encoder_funcs mtk_dsi_encoder_funcs = {
 555         .destroy = mtk_dsi_encoder_destroy,
 556 };
 557
 558 static bool mtk_dsi_encoder_mode_fixup(struct drm_encoder *encoder,
 559                                        const struct drm_display_mode *mode,
 560                                        struct drm_display_mode *adjusted_mode)
 561 {
 562         return true;
 563 }
 564
 565 static void mtk_dsi_encoder_mode_set(struct drm_encoder *encoder,
 566                                      struct drm_display_mode *mode,
 567                                      struct drm_display_mode *adjusted)
 568 {
 569         struct mtk_dsi *dsi = encoder_to_dsi(encoder);
 570
 571         dsi->vm.pixelclock = adjusted->clock;
 572         dsi->vm.hactive = adjusted->hdisplay;
 573         dsi->vm.hback_porch = adjusted->htotal - adjusted->hsync_end;
 574         dsi->vm.hfront_porch = adjusted->hsync_start - adjusted->hdisplay;
 575         dsi->vm.hsync_len = adjusted->hsync_end - adjusted->hsync_start;
 576
 577         dsi->vm.vactive = adjusted->vdisplay;
 578         dsi->vm.vback_porch = adjusted->vtotal - adjusted->vsync_end;
 579         dsi->vm.vfront_porch = adjusted->vsync_start - adjusted->vdisplay;
 580         dsi->vm.vsync_len = adjusted->vsync_end - adjusted->vsync_start;
 581 }
 582
 583 static void mtk_dsi_encoder_disable(struct drm_encoder *encoder)
 584 {
 585         struct mtk_dsi *dsi = encoder_to_dsi(encoder);
 586
 587         mtk_output_dsi_disable(dsi);
 588 }
 589
 590 static void mtk_dsi_encoder_enable(struct drm_encoder *encoder)
 591 {
 592         struct mtk_dsi *dsi = encoder_to_dsi(encoder);
 593
 594         mtk_output_dsi_enable(dsi);
 595 }
 596
 597 static enum drm_connector_status mtk_dsi_connector_detect(
 598         struct drm_connector *connector, bool force)
 599 {
 600         return connector_status_connected;
 601 }
 602
 603 static int mtk_dsi_connector_get_modes(struct drm_connector *connector)
 604 {
 605         struct mtk_dsi *dsi = connector_to_dsi(connector);
 606
 607         return drm_panel_get_modes(dsi->panel);
 608 }
 609
 610 static const struct drm_encoder_helper_funcs mtk_dsi_encoder_helper_funcs = {
 611         .mode_fixup = mtk_dsi_encoder_mode_fixup,
 612         .mode_set = mtk_dsi_encoder_mode_set,
 613         .disable = mtk_dsi_encoder_disable,
 614         .enable = mtk_dsi_encoder_enable,
 615 };
 616
 617 static const struct drm_connector_funcs mtk_dsi_connector_funcs = {
 618         .dpms = drm_atomic_helper_connector_dpms,
 619         .detect = mtk_dsi_connector_detect,
 620         .fill_modes = drm_helper_probe_single_connector_modes,
 621         .destroy = drm_connector_cleanup,
 622         .reset = drm_atomic_helper_connector_reset,
 623         .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
 624         .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
 625 };
 626
 627 static const struct drm_connector_helper_funcs
 628         mtk_dsi_connector_helper_funcs = {
 629         .get_modes = mtk_dsi_connector_get_modes,
 630 };
 631
 632 static int mtk_drm_attach_bridge(struct drm_bridge *bridge,
 633                                  struct drm_encoder *encoder)
 634 {
 635         int ret;
 636
 637         if (!bridge)
 638                 return -ENOENT;
 639
 640         encoder->bridge = bridge;
 641         bridge->encoder = encoder;
 642         ret = drm_bridge_attach(encoder->dev, bridge);
 643         if (ret) {
 644                 DRM_ERROR("Failed to attach bridge to drm\n");
 645                 encoder->bridge = NULL;
 646                 bridge->encoder = NULL;
 647         }
 648
 649         return ret;
 650 }
 651
 652 static int mtk_dsi_create_connector(struct drm_device *drm, struct mtk_dsi *dsi)
 653 {
 654         int ret;
 655
 656         ret = drm_connector_init(drm, &dsi->conn, &mtk_dsi_connector_funcs,
 657                                  DRM_MODE_CONNECTOR_DSI);
 658         if (ret) {
 659                 DRM_ERROR("Failed to connector init to drm\n");
 660                 return ret;
 661         }
 662
 663         drm_connector_helper_add(&dsi->conn, &mtk_dsi_connector_helper_funcs);
 664
 665         dsi->conn.dpms = DRM_MODE_DPMS_OFF;
 666         drm_mode_connector_attach_encoder(&dsi->conn, &dsi->encoder);
 667
 668         if (dsi->panel) {
 669                 ret = drm_panel_attach(dsi->panel, &dsi->conn);
 670                 if (ret) {
 671                         DRM_ERROR("Failed to attach panel to drm\n");
 672                         goto err_connector_cleanup;
 673                 }
 674         }
 675
 676         return 0;
 677
 678 err_connector_cleanup:
 679         drm_connector_cleanup(&dsi->conn);
 680         return ret;
 681 }
 682
 683 static int mtk_dsi_create_conn_enc(struct drm_device *drm, struct mtk_dsi *dsi)
 684 {
 685         int ret;
 686
 687         ret = drm_encoder_init(drm, &dsi->encoder, &mtk_dsi_encoder_funcs,
 688                                DRM_MODE_ENCODER_DSI, NULL);
 689         if (ret) {
 690                 DRM_ERROR("Failed to encoder init to drm\n");
 691                 return ret;
 692         }
 693         drm_encoder_helper_add(&dsi->encoder, &mtk_dsi_encoder_helper_funcs);
 694
 695         /*
 696          * Currently display data paths are statically assigned to a crtc each.
 697          * crtc 0 is OVL0 -> COLOR0 -> AAL -> OD -> RDMA0 -> UFOE -> DSI0
 698          */
 699         dsi->encoder.possible_crtcs = 1;
 700
 701         /* If there's a bridge, attach to it and let it create the connector */
 702         ret = mtk_drm_attach_bridge(dsi->bridge, &dsi->encoder);
 703         if (ret) {
 704                 /* Otherwise create our own connector and attach to a panel */
 705                 ret = mtk_dsi_create_connector(drm, dsi);
 706                 if (ret)
 707                         goto err_encoder_cleanup;
 708         }
 709
 710         return 0;
 711
 712 err_encoder_cleanup:
 713         drm_encoder_cleanup(&dsi->encoder);
 714         return ret;
 715 }
 716
 717 static void mtk_dsi_destroy_conn_enc(struct mtk_dsi *dsi)
 718 {
 719         drm_encoder_cleanup(&dsi->encoder);
 720         /* Skip connector cleanup if creation was delegated to the bridge */
 721         if (dsi->conn.dev)
 722                 drm_connector_cleanup(&dsi->conn);
 723         if (dsi->panel)
 724                 drm_panel_detach(dsi->panel);
 725 }
 726
 727 static void mtk_dsi_ddp_start(struct mtk_ddp_comp *comp)
 728 {
 729         struct mtk_dsi *dsi = container_of(comp, struct mtk_dsi, ddp_comp);
 730
 731         mtk_dsi_poweron(dsi);
 732 }
 733
 734 static void mtk_dsi_ddp_stop(struct mtk_ddp_comp *comp)
 735 {
 736         struct mtk_dsi *dsi = container_of(comp, struct mtk_dsi, ddp_comp);
 737
 738         mtk_dsi_poweroff(dsi);
 739 }
 740
 741 static const struct mtk_ddp_comp_funcs mtk_dsi_funcs = {
 742         .start = mtk_dsi_ddp_start,
 743         .stop = mtk_dsi_ddp_stop,
 744 };
 745
 746 static int mtk_dsi_host_attach(struct mipi_dsi_host *host,
 747                                struct mipi_dsi_device *device)
 748 {
 749         struct mtk_dsi *dsi = host_to_dsi(host);
 750
 751         dsi->lanes = device->lanes;
 752         dsi->format = device->format;
 753         dsi->mode_flags = device->mode_flags;
 754
 755         if (dsi->conn.dev)
 756                 drm_helper_hpd_irq_event(dsi->conn.dev);
 757
 758         return 0;
 759 }
 760
 761 static int mtk_dsi_host_detach(struct mipi_dsi_host *host,
 762                                struct mipi_dsi_device *device)
 763 {
 764         struct mtk_dsi *dsi = host_to_dsi(host);
 765
 766         if (dsi->conn.dev)
 767                 drm_helper_hpd_irq_event(dsi->conn.dev);
 768
 769         return 0;
 770 }
 771
 772 static const struct mipi_dsi_host_ops mtk_dsi_ops = {
 773         .attach = mtk_dsi_host_attach,
 774         .detach = mtk_dsi_host_detach,
 775 };
 776
 777 static int mtk_dsi_bind(struct device *dev, struct device *master, void *data)
 778 {
 779         int ret;
 780         struct drm_device *drm = data;
 781         struct mtk_dsi *dsi = dev_get_drvdata(dev);
 782
 783         ret = mtk_ddp_comp_register(drm, &dsi->ddp_comp);
 784         if (ret < 0) {
 785                 dev_err(dev, "Failed to register component %s: %d\n",
 786                         dev->of_node->full_name, ret);
 787                 return ret;
 788         }
 789
 790         ret = mipi_dsi_host_register(&dsi->host);
 791         if (ret < 0) {
 792                 dev_err(dev, "failed to register DSI host: %d\n", ret);
 793                 goto err_ddp_comp_unregister;
 794         }
 795
 796         ret = mtk_dsi_create_conn_enc(drm, dsi);
 797         if (ret) {
 798                 DRM_ERROR("Encoder create failed with %d\n", ret);
 799                 goto err_unregister;
 800         }
 801
 802         return 0;
 803
 804 err_unregister:
 805         mipi_dsi_host_unregister(&dsi->host);
 806 err_ddp_comp_unregister:
 807         mtk_ddp_comp_unregister(drm, &dsi->ddp_comp);
 808         return ret;
 809 }
 810
 811 static void mtk_dsi_unbind(struct device *dev, struct device *master,
 812                            void *data)
 813 {
 814         struct drm_device *drm = data;
 815         struct mtk_dsi *dsi = dev_get_drvdata(dev);
 816
 817         mtk_dsi_destroy_conn_enc(dsi);
 818         mipi_dsi_host_unregister(&dsi->host);
 819         mtk_ddp_comp_unregister(drm, &dsi->ddp_comp);
 820 }
 821
 822 static const struct component_ops mtk_dsi_component_ops = {
 823         .bind = mtk_dsi_bind,
 824         .unbind = mtk_dsi_unbind,
 825 };
 826
 827 static int mtk_dsi_probe(struct platform_device *pdev)
 828 {
 829         struct mtk_dsi *dsi;
 830         struct device *dev = &pdev->dev;
 831         struct device_node *remote_node, *endpoint;
 832         struct resource *regs;
 833         int comp_id;
 834         int ret;
 835
 836         dsi = devm_kzalloc(dev, sizeof(*dsi), GFP_KERNEL);
 837         if (!dsi)
 838                 return -ENOMEM;
 839
 840         dsi->host.ops = &mtk_dsi_ops;
 841         dsi->host.dev = dev;
 842
 843         endpoint = of_graph_get_next_endpoint(dev->of_node, NULL);
 844         if (endpoint) {
 845                 remote_node = of_graph_get_remote_port_parent(endpoint);
 846                 if (!remote_node) {
 847                         dev_err(dev, "No panel connected\n");
 848                         return -ENODEV;
 849                 }
 850
 851                 dsi->bridge = of_drm_find_bridge(remote_node);
 852                 dsi->panel = of_drm_find_panel(remote_node);
 853                 of_node_put(remote_node);
 854                 if (!dsi->bridge && !dsi->panel) {
 855                         dev_info(dev, "Waiting for bridge or panel driver\n");
 856                         return -EPROBE_DEFER;
 857                 }
 858         }
 859
 860         dsi->engine_clk = devm_clk_get(dev, "engine");
 861         if (IS_ERR(dsi->engine_clk)) {
 862                 ret = PTR_ERR(dsi->engine_clk);
 863                 dev_err(dev, "Failed to get engine clock: %d\n", ret);
 864                 return ret;
 865         }
 866
 867         dsi->digital_clk = devm_clk_get(dev, "digital");
 868         if (IS_ERR(dsi->digital_clk)) {
 869                 ret = PTR_ERR(dsi->digital_clk);
 870                 dev_err(dev, "Failed to get digital clock: %d\n", ret);
 871                 return ret;
 872         }
 873
 874         dsi->hs_clk = devm_clk_get(dev, "hs");
 875         if (IS_ERR(dsi->hs_clk)) {
 876                 ret = PTR_ERR(dsi->hs_clk);
 877                 dev_err(dev, "Failed to get hs clock: %d\n", ret);
 878                 return ret;
 879         }
 880
 881         regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 882         dsi->regs = devm_ioremap_resource(dev, regs);
 883         if (IS_ERR(dsi->regs)) {
 884                 ret = PTR_ERR(dsi->regs);
 885                 dev_err(dev, "Failed to ioremap memory: %d\n", ret);
 886                 return ret;
 887         }
 888
 889         dsi->phy = devm_phy_get(dev, "dphy");
 890         if (IS_ERR(dsi->phy)) {
 891                 ret = PTR_ERR(dsi->phy);
 892                 dev_err(dev, "Failed to get MIPI-DPHY: %d\n", ret);
 893                 return ret;
 894         }
 895
 896         comp_id = mtk_ddp_comp_get_id(dev->of_node, MTK_DSI);
 897         if (comp_id < 0) {
 898                 dev_err(dev, "Failed to identify by alias: %d\n", comp_id);
 899                 return comp_id;
 900         }
 901
 902         ret = mtk_ddp_comp_init(dev, dev->of_node, &dsi->ddp_comp, comp_id,
 903                                 &mtk_dsi_funcs);
 904         if (ret) {
 905                 dev_err(dev, "Failed to initialize component: %d\n", ret);
 906                 return ret;
 907         }
 908
 909         platform_set_drvdata(pdev, dsi);
 910
 911         return component_add(&pdev->dev, &mtk_dsi_component_ops);
 912 }
 913
 914 static int mtk_dsi_remove(struct platform_device *pdev)
 915 {
 916         struct mtk_dsi *dsi = platform_get_drvdata(pdev);
 917
 918         mtk_output_dsi_disable(dsi);
 919         component_del(&pdev->dev, &mtk_dsi_component_ops);
 920
 921         return 0;
 922 }
 923
 924 static const struct of_device_id mtk_dsi_of_match[] = {
 925         { .compatible = "mediatek,mt8173-dsi" },
 926         { },
 927 };
 928
 929 struct platform_driver mtk_dsi_driver = {
 930         .probe = mtk_dsi_probe,
 931         .remove = mtk_dsi_remove,
 932         .driver = {
 933                 .name = "mtk-dsi",
 934                 .of_match_table = mtk_dsi_of_match,
 935         },
 936 };