drivers/gpu/drm/bridge/imx/imx93-mipi-dsi.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2
   3 /*
   4  * Copyright 2022,2023 NXP
   5  */
   6
   7 #include <linux/bitfield.h>
   8 #include <linux/bits.h>
   9 #include <linux/clk.h>
  10 #include <linux/delay.h>
  11 #include <linux/math.h>
  12 #include <linux/media-bus-format.h>
  13 #include <linux/mfd/syscon.h>
  14 #include <linux/module.h>
  15 #include <linux/of.h>
  16 #include <linux/phy/phy.h>
  17 #include <linux/phy/phy-mipi-dphy.h>
  18 #include <linux/platform_device.h>
  19 #include <linux/regmap.h>
  20
  21 #include <drm/bridge/dw_mipi_dsi.h>
  22 #include <drm/drm_bridge.h>
  23 #include <drm/drm_mipi_dsi.h>
  24 #include <drm/drm_modes.h>
  25
  26 /* DPHY PLL configuration registers */
  27 #define DSI_REG                         0x4c
  28 #define  CFGCLKFREQRANGE_MASK           GENMASK(5, 0)
  29 #define  CFGCLKFREQRANGE(x)             FIELD_PREP(CFGCLKFREQRANGE_MASK, (x))
  30 #define  CLKSEL_MASK                    GENMASK(7, 6)
  31 #define  CLKSEL_STOP                    FIELD_PREP(CLKSEL_MASK, 0)
  32 #define  CLKSEL_GEN                     FIELD_PREP(CLKSEL_MASK, 1)
  33 #define  CLKSEL_EXT                     FIELD_PREP(CLKSEL_MASK, 2)
  34 #define  HSFREQRANGE_MASK               GENMASK(14, 8)
  35 #define  HSFREQRANGE(x)                 FIELD_PREP(HSFREQRANGE_MASK, (x))
  36 #define  UPDATE_PLL                     BIT(17)
  37 #define  SHADOW_CLR                     BIT(18)
  38 #define  CLK_EXT                        BIT(19)
  39
  40 #define DSI_WRITE_REG0                  0x50
  41 #define  M_MASK                         GENMASK(9, 0)
  42 #define  M(x)                           FIELD_PREP(M_MASK, ((x) - 2))
  43 #define  N_MASK                         GENMASK(13, 10)
  44 #define  N(x)                           FIELD_PREP(N_MASK, ((x) - 1))
  45 #define  VCO_CTRL_MASK                  GENMASK(19, 14)
  46 #define  VCO_CTRL(x)                    FIELD_PREP(VCO_CTRL_MASK, (x))
  47 #define  PROP_CTRL_MASK                 GENMASK(25, 20)
  48 #define  PROP_CTRL(x)                   FIELD_PREP(PROP_CTRL_MASK, (x))
  49 #define  INT_CTRL_MASK                  GENMASK(31, 26)
  50 #define  INT_CTRL(x)                    FIELD_PREP(INT_CTRL_MASK, (x))
  51
  52 #define DSI_WRITE_REG1                  0x54
  53 #define  GMP_CTRL_MASK                  GENMASK(1, 0)
  54 #define  GMP_CTRL(x)                    FIELD_PREP(GMP_CTRL_MASK, (x))
  55 #define  CPBIAS_CTRL_MASK               GENMASK(8, 2)
  56 #define  CPBIAS_CTRL(x)                 FIELD_PREP(CPBIAS_CTRL_MASK, (x))
  57 #define  PLL_SHADOW_CTRL                BIT(9)
  58
  59 /* display mux control register */
  60 #define DISPLAY_MUX                     0x60
  61 #define  MIPI_DSI_RGB666_MAP_CFG        GENMASK(7, 6)
  62 #define  RGB666_CONFIG1                 FIELD_PREP(MIPI_DSI_RGB666_MAP_CFG, 0)
  63 #define  RGB666_CONFIG2                 FIELD_PREP(MIPI_DSI_RGB666_MAP_CFG, 1)
  64 #define  MIPI_DSI_RGB565_MAP_CFG        GENMASK(5, 4)
  65 #define  RGB565_CONFIG1                 FIELD_PREP(MIPI_DSI_RGB565_MAP_CFG, 0)
  66 #define  RGB565_CONFIG2                 FIELD_PREP(MIPI_DSI_RGB565_MAP_CFG, 1)
  67 #define  RGB565_CONFIG3                 FIELD_PREP(MIPI_DSI_RGB565_MAP_CFG, 2)
  68 #define  LCDIF_CROSS_LINE_PATTERN       GENMASK(3, 0)
  69 #define  RGB888_TO_RGB888               FIELD_PREP(LCDIF_CROSS_LINE_PATTERN, 0)
  70 #define  RGB888_TO_RGB666               FIELD_PREP(LCDIF_CROSS_LINE_PATTERN, 6)
  71 #define  RGB565_TO_RGB565               FIELD_PREP(LCDIF_CROSS_LINE_PATTERN, 7)
  72
  73 #define MHZ(x)                          ((x) * 1000000UL)
  74
  75 #define REF_CLK_RATE_MAX                MHZ(64)
  76 #define REF_CLK_RATE_MIN                MHZ(2)
  77 #define FOUT_MAX                        MHZ(1250)
  78 #define FOUT_MIN                        MHZ(40)
  79 #define FVCO_DIV_FACTOR                 MHZ(80)
  80
  81 #define MBPS(x)                         ((x) * 1000000UL)
  82
  83 #define DATA_RATE_MAX_SPEED             MBPS(2500)
  84 #define DATA_RATE_MIN_SPEED             MBPS(80)
  85
  86 #define M_MAX                           625UL
  87 #define M_MIN                           64UL
  88
  89 #define N_MAX                           16U
  90 #define N_MIN                           1U
  91
  92 struct imx93_dsi {
  93         struct device *dev;
  94         struct regmap *regmap;
  95         struct clk *clk_pixel;
  96         struct clk *clk_ref;
  97         struct clk *clk_cfg;
  98         struct dw_mipi_dsi *dmd;
  99         struct dw_mipi_dsi_plat_data pdata;
 100         union phy_configure_opts phy_cfg;
 101         unsigned long ref_clk_rate;
 102         u32 format;
 103 };
 104
 105 struct dphy_pll_cfg {
 106         u32 m;  /* PLL Feedback Multiplication Ratio */
 107         u32 n;  /* PLL Input Frequency Division Ratio */
 108 };
 109
 110 struct dphy_pll_vco_prop {
 111         unsigned long max_fout;
 112         u8 vco_cntl;
 113         u8 prop_cntl;
 114 };
 115
 116 struct dphy_pll_hsfreqrange {
 117         unsigned long max_mbps;
 118         u8 hsfreqrange;
 119 };
 120
 121 /* DPHY Databook Table 3-13 Charge-pump Programmability */
 122 static const struct dphy_pll_vco_prop vco_prop_map[] = {
 123         {   55, 0x3f, 0x0d },
 124         {   82, 0x37, 0x0d },
 125         {  110, 0x2f, 0x0d },
 126         {  165, 0x27, 0x0d },
 127         {  220, 0x1f, 0x0d },
 128         {  330, 0x17, 0x0d },
 129         {  440, 0x0f, 0x0d },
 130         {  660, 0x07, 0x0d },
 131         { 1149, 0x03, 0x0d },
 132         { 1152, 0x01, 0x0d },
 133         { 1250, 0x01, 0x0e },
 134 };
 135
 136 /* DPHY Databook Table 5-7 Frequency Ranges and Defaults */
 137 static const struct dphy_pll_hsfreqrange hsfreqrange_map[] = {
 138         {   89, 0x00 },
 139         {   99, 0x10 },
 140         {  109, 0x20 },
 141         {  119, 0x30 },
 142         {  129, 0x01 },
 143         {  139, 0x11 },
 144         {  149, 0x21 },
 145         {  159, 0x31 },
 146         {  169, 0x02 },
 147         {  179, 0x12 },
 148         {  189, 0x22 },
 149         {  204, 0x32 },
 150         {  219, 0x03 },
 151         {  234, 0x13 },
 152         {  249, 0x23 },
 153         {  274, 0x33 },
 154         {  299, 0x04 },
 155         {  324, 0x14 },
 156         {  349, 0x25 },
 157         {  399, 0x35 },
 158         {  449, 0x05 },
 159         {  499, 0x16 },
 160         {  549, 0x26 },
 161         {  599, 0x37 },
 162         {  649, 0x07 },
 163         {  699, 0x18 },
 164         {  749, 0x28 },
 165         {  799, 0x39 },
 166         {  849, 0x09 },
 167         {  899, 0x19 },
 168         {  949, 0x29 },
 169         {  999, 0x3a },
 170         { 1049, 0x0a },
 171         { 1099, 0x1a },
 172         { 1149, 0x2a },
 173         { 1199, 0x3b },
 174         { 1249, 0x0b },
 175         { 1299, 0x1b },
 176         { 1349, 0x2b },
 177         { 1399, 0x3c },
 178         { 1449, 0x0c },
 179         { 1499, 0x1c },
 180         { 1549, 0x2c },
 181         { 1599, 0x3d },
 182         { 1649, 0x0d },
 183         { 1699, 0x1d },
 184         { 1749, 0x2e },
 185         { 1799, 0x3e },
 186         { 1849, 0x0e },
 187         { 1899, 0x1e },
 188         { 1949, 0x2f },
 189         { 1999, 0x3f },
 190         { 2049, 0x0f },
 191         { 2099, 0x40 },
 192         { 2149, 0x41 },
 193         { 2199, 0x42 },
 194         { 2249, 0x43 },
 195         { 2299, 0x44 },
 196         { 2349, 0x45 },
 197         { 2399, 0x46 },
 198         { 2449, 0x47 },
 199         { 2499, 0x48 },
 200         { 2500, 0x49 },
 201 };
 202
 203 static void dphy_pll_write(struct imx93_dsi *dsi, unsigned int reg, u32 value)
 204 {
 205         int ret;
 206
 207         ret = regmap_write(dsi->regmap, reg, value);
 208         if (ret < 0)
 209                 dev_err(dsi->dev, "failed to write 0x%08x to pll reg 0x%x: %d\n",
 210                         value, reg, ret);
 211 }
 212
 213 static inline unsigned long data_rate_to_fout(unsigned long data_rate)
 214 {
 215         /* Fout is half of data rate */
 216         return data_rate / 2;
 217 }
 218
 219 static int
 220 dphy_pll_get_configure_from_opts(struct imx93_dsi *dsi,
 221                                  struct phy_configure_opts_mipi_dphy *dphy_opts,
 222                                  struct dphy_pll_cfg *cfg)
 223 {
 224         struct device *dev = dsi->dev;
 225         unsigned long fin = dsi->ref_clk_rate;
 226         unsigned long fout;
 227         unsigned long best_fout = 0;
 228         unsigned int fvco_div;
 229         unsigned int min_n, max_n, n, best_n;
 230         unsigned long m, best_m;
 231         unsigned long min_delta = ULONG_MAX;
 232         unsigned long delta;
 233         u64 tmp;
 234
 235         if (dphy_opts->hs_clk_rate < DATA_RATE_MIN_SPEED ||
 236             dphy_opts->hs_clk_rate > DATA_RATE_MAX_SPEED) {
 237                 dev_dbg(dev, "invalid data rate per lane: %lu\n",
 238                         dphy_opts->hs_clk_rate);
 239                 return -EINVAL;
 240         }
 241
 242         fout = data_rate_to_fout(dphy_opts->hs_clk_rate);
 243
 244         /* DPHY Databook 3.3.6.1 Output Frequency */
 245         /* Fout = Fvco / Fvco_div = (Fin * M) / (Fvco_div * N) */
 246         /* Fvco_div could be 1/2/4/8 according to Fout range. */
 247         fvco_div = 8UL / min(DIV_ROUND_UP(fout, FVCO_DIV_FACTOR), 8UL);
 248
 249         /* limitation: 2MHz <= Fin / N <= 8MHz */
 250         min_n = DIV_ROUND_UP_ULL((u64)fin, MHZ(8));
 251         max_n = DIV_ROUND_DOWN_ULL((u64)fin, MHZ(2));
 252
 253         /* clamp possible N(s) */
 254         min_n = clamp(min_n, N_MIN, N_MAX);
 255         max_n = clamp(max_n, N_MIN, N_MAX);
 256
 257         dev_dbg(dev, "Fout = %lu, Fvco_div = %u, n_range = [%u, %u]\n",
 258                 fout, fvco_div, min_n, max_n);
 259
 260         for (n = min_n; n <= max_n; n++) {
 261                 /* M = (Fout * N * Fvco_div) / Fin */
 262                 m = DIV_ROUND_CLOSEST(fout * n * fvco_div, fin);
 263
 264                 /* check M range */
 265                 if (m < M_MIN || m > M_MAX)
 266                         continue;
 267
 268                 /* calculate temporary Fout */
 269                 tmp = m * fin;
 270                 do_div(tmp, n * fvco_div);
 271                 if (tmp < FOUT_MIN || tmp > FOUT_MAX)
 272                         continue;
 273
 274                 delta = abs(fout - tmp);
 275                 if (delta < min_delta) {
 276                         best_n = n;
 277                         best_m = m;
 278                         min_delta = delta;
 279                         best_fout = tmp;
 280                 }
 281         }
 282
 283         if (best_fout) {
 284                 cfg->m = best_m;
 285                 cfg->n = best_n;
 286                 dev_dbg(dev, "best Fout = %lu, m = %u, n = %u\n",
 287                         best_fout, cfg->m, cfg->n);
 288         } else {
 289                 dev_dbg(dev, "failed to find best Fout\n");
 290                 return -EINVAL;
 291         }
 292
 293         return 0;
 294 }
 295
 296 static void dphy_pll_clear_shadow(struct imx93_dsi *dsi)
 297 {
 298         /* Reference DPHY Databook Figure 3-3 Initialization Timing Diagram. */
 299         /* Select clock generation first. */
 300         dphy_pll_write(dsi, DSI_REG, CLKSEL_GEN);
 301
 302         /* Clear shadow after clock selection is done a while. */
 303         fsleep(1);
 304         dphy_pll_write(dsi, DSI_REG, CLKSEL_GEN | SHADOW_CLR);
 305
 306         /* A minimum pulse of 5ns on shadow_clear signal. */
 307         fsleep(1);
 308         dphy_pll_write(dsi, DSI_REG, CLKSEL_GEN);
 309 }
 310
 311 static unsigned long dphy_pll_get_cfgclkrange(struct imx93_dsi *dsi)
 312 {
 313         /*
 314          * DPHY Databook Table 4-4 System Control Signals mentions an equation
 315          * for cfgclkfreqrange[5:0].
 316          */
 317         return (clk_get_rate(dsi->clk_cfg) / MHZ(1) - 17) * 4;
 318 }
 319
 320 static u8
 321 dphy_pll_get_hsfreqrange(struct phy_configure_opts_mipi_dphy *dphy_opts)
 322 {
 323         unsigned long mbps = dphy_opts->hs_clk_rate / MHZ(1);
 324         int i;
 325
 326         for (i = 0; i < ARRAY_SIZE(hsfreqrange_map); i++)
 327                 if (mbps <= hsfreqrange_map[i].max_mbps)
 328                         return hsfreqrange_map[i].hsfreqrange;
 329
 330         return 0;
 331 }
 332
 333 static u8 dphy_pll_get_vco(struct phy_configure_opts_mipi_dphy *dphy_opts)
 334 {
 335         unsigned long fout = data_rate_to_fout(dphy_opts->hs_clk_rate) / MHZ(1);
 336         int i;
 337
 338         for (i = 0; i < ARRAY_SIZE(vco_prop_map); i++)
 339                 if (fout <= vco_prop_map[i].max_fout)
 340                         return vco_prop_map[i].vco_cntl;
 341
 342         return 0;
 343 }
 344
 345 static u8 dphy_pll_get_prop(struct phy_configure_opts_mipi_dphy *dphy_opts)
 346 {
 347         unsigned long fout = data_rate_to_fout(dphy_opts->hs_clk_rate) / MHZ(1);
 348         int i;
 349
 350         for (i = 0; i < ARRAY_SIZE(vco_prop_map); i++)
 351                 if (fout <= vco_prop_map[i].max_fout)
 352                         return vco_prop_map[i].prop_cntl;
 353
 354         return 0;
 355 }
 356
 357 static int dphy_pll_update(struct imx93_dsi *dsi)
 358 {
 359         int ret;
 360
 361         ret = regmap_update_bits(dsi->regmap, DSI_REG, UPDATE_PLL, UPDATE_PLL);
 362         if (ret < 0) {
 363                 dev_err(dsi->dev, "failed to set UPDATE_PLL: %d\n", ret);
 364                 return ret;
 365         }
 366
 367         /*
 368          * The updatepll signal should be asserted for a minimum of four clkin
 369          * cycles, according to DPHY Databook Figure 3-3 Initialization Timing
 370          * Diagram.
 371          */
 372         fsleep(10);
 373
 374         ret = regmap_update_bits(dsi->regmap, DSI_REG, UPDATE_PLL, 0);
 375         if (ret < 0) {
 376                 dev_err(dsi->dev, "failed to clear UPDATE_PLL: %d\n", ret);
 377                 return ret;
 378         }
 379
 380         return 0;
 381 }
 382
 383 static int dphy_pll_configure(struct imx93_dsi *dsi, union phy_configure_opts *opts)
 384 {
 385         struct dphy_pll_cfg cfg = { 0 };
 386         u32 val;
 387         int ret;
 388
 389         ret = dphy_pll_get_configure_from_opts(dsi, &opts->mipi_dphy, &cfg);
 390         if (ret) {
 391                 dev_err(dsi->dev, "failed to get phy pll cfg %d\n", ret);
 392                 return ret;
 393         }
 394
 395         dphy_pll_clear_shadow(dsi);
 396
 397         /* DSI_REG */
 398         val = CLKSEL_GEN |
 399               CFGCLKFREQRANGE(dphy_pll_get_cfgclkrange(dsi)) |
 400               HSFREQRANGE(dphy_pll_get_hsfreqrange(&opts->mipi_dphy));
 401         dphy_pll_write(dsi, DSI_REG, val);
 402
 403         /* DSI_WRITE_REG0 */
 404         val = M(cfg.m) | N(cfg.n) | INT_CTRL(0) |
 405               VCO_CTRL(dphy_pll_get_vco(&opts->mipi_dphy)) |
 406               PROP_CTRL(dphy_pll_get_prop(&opts->mipi_dphy));
 407         dphy_pll_write(dsi, DSI_WRITE_REG0, val);
 408
 409         /* DSI_WRITE_REG1 */
 410         dphy_pll_write(dsi, DSI_WRITE_REG1, GMP_CTRL(1) | CPBIAS_CTRL(0x10));
 411
 412         ret = clk_prepare_enable(dsi->clk_ref);
 413         if (ret < 0) {
 414                 dev_err(dsi->dev, "failed to enable ref clock: %d\n", ret);
 415                 return ret;
 416         }
 417
 418         /*
 419          * At least 10 refclk cycles are required before updatePLL assertion,
 420          * according to DPHY Databook Figure 3-3 Initialization Timing Diagram.
 421          */
 422         fsleep(10);
 423
 424         ret = dphy_pll_update(dsi);
 425         if (ret < 0) {
 426                 clk_disable_unprepare(dsi->clk_ref);
 427                 return ret;
 428         }
 429
 430         return 0;
 431 }
 432
 433 static void dphy_pll_clear_reg(struct imx93_dsi *dsi)
 434 {
 435         dphy_pll_write(dsi, DSI_REG, 0);
 436         dphy_pll_write(dsi, DSI_WRITE_REG0, 0);
 437         dphy_pll_write(dsi, DSI_WRITE_REG1, 0);
 438 }
 439
 440 static int dphy_pll_init(struct imx93_dsi *dsi)
 441 {
 442         int ret;
 443
 444         ret = clk_prepare_enable(dsi->clk_cfg);
 445         if (ret < 0) {
 446                 dev_err(dsi->dev, "failed to enable config clock: %d\n", ret);
 447                 return ret;
 448         }
 449
 450         dphy_pll_clear_reg(dsi);
 451
 452         return 0;
 453 }
 454
 455 static void dphy_pll_uninit(struct imx93_dsi *dsi)
 456 {
 457         dphy_pll_clear_reg(dsi);
 458         clk_disable_unprepare(dsi->clk_cfg);
 459 }
 460
 461 static void dphy_pll_power_off(struct imx93_dsi *dsi)
 462 {
 463         dphy_pll_clear_reg(dsi);
 464         clk_disable_unprepare(dsi->clk_ref);
 465 }
 466
 467 static int imx93_dsi_get_phy_configure_opts(struct imx93_dsi *dsi,
 468                                             const struct drm_display_mode *mode,
 469                                             union phy_configure_opts *phy_cfg,
 470                                             u32 lanes, u32 format)
 471 {
 472         struct device *dev = dsi->dev;
 473         int bpp;
 474         int ret;
 475
 476         bpp = mipi_dsi_pixel_format_to_bpp(format);
 477         if (bpp < 0) {
 478                 dev_dbg(dev, "failed to get bpp for pixel format %d\n", format);
 479                 return -EINVAL;
 480         }
 481
 482         ret = phy_mipi_dphy_get_default_config(mode->clock * MSEC_PER_SEC, bpp,
 483                                                lanes, &phy_cfg->mipi_dphy);
 484         if (ret < 0) {
 485                 dev_dbg(dev, "failed to get default phy cfg %d\n", ret);
 486                 return ret;
 487         }
 488
 489         return 0;
 490 }
 491
 492 static enum drm_mode_status
 493 imx93_dsi_validate_mode(struct imx93_dsi *dsi, const struct drm_display_mode *mode)
 494 {
 495         struct drm_bridge *bridge = dw_mipi_dsi_get_bridge(dsi->dmd);
 496
 497         /* Get the last bridge */
 498         while (drm_bridge_get_next_bridge(bridge))
 499                 bridge = drm_bridge_get_next_bridge(bridge);
 500
 501         if ((bridge->ops & DRM_BRIDGE_OP_DETECT) &&
 502             (bridge->ops & DRM_BRIDGE_OP_EDID)) {
 503                 unsigned long pixel_clock_rate = mode->clock * 1000;
 504                 unsigned long rounded_rate;
 505
 506                 /* Allow +/-0.5% pixel clock rate deviation */
 507                 rounded_rate = clk_round_rate(dsi->clk_pixel, pixel_clock_rate);
 508                 if (rounded_rate < pixel_clock_rate * 995 / 1000 ||
 509                     rounded_rate > pixel_clock_rate * 1005 / 1000) {
 510                         dev_dbg(dsi->dev, "failed to round clock for mode " DRM_MODE_FMT "\n",
 511                                 DRM_MODE_ARG(mode));
 512                         return MODE_NOCLOCK;
 513                 }
 514         }
 515
 516         return MODE_OK;
 517 }
 518
 519 static enum drm_mode_status
 520 imx93_dsi_validate_phy(struct imx93_dsi *dsi, const struct drm_display_mode *mode,
 521                        unsigned long mode_flags, u32 lanes, u32 format)
 522 {
 523         union phy_configure_opts phy_cfg;
 524         struct dphy_pll_cfg cfg = { 0 };
 525         struct device *dev = dsi->dev;
 526         int ret;
 527
 528         ret = imx93_dsi_get_phy_configure_opts(dsi, mode, &phy_cfg, lanes,
 529                                                format);
 530         if (ret < 0) {
 531                 dev_dbg(dev, "failed to get phy cfg opts %d\n", ret);
 532                 return MODE_ERROR;
 533         }
 534
 535         ret = dphy_pll_get_configure_from_opts(dsi, &phy_cfg.mipi_dphy, &cfg);
 536         if (ret < 0) {
 537                 dev_dbg(dev, "failed to get phy pll cfg %d\n", ret);
 538                 return MODE_NOCLOCK;
 539         }
 540
 541         return MODE_OK;
 542 }
 543
 544 static enum drm_mode_status
 545 imx93_dsi_mode_valid(void *priv_data, const struct drm_display_mode *mode,
 546                      unsigned long mode_flags, u32 lanes, u32 format)
 547 {
 548         struct imx93_dsi *dsi = priv_data;
 549         struct device *dev = dsi->dev;
 550         enum drm_mode_status ret;
 551
 552         ret = imx93_dsi_validate_mode(dsi, mode);
 553         if (ret != MODE_OK) {
 554                 dev_dbg(dev, "failed to validate mode " DRM_MODE_FMT "\n",
 555                         DRM_MODE_ARG(mode));
 556                 return ret;
 557         }
 558
 559         ret = imx93_dsi_validate_phy(dsi, mode, mode_flags, lanes, format);
 560         if (ret != MODE_OK) {
 561                 dev_dbg(dev, "failed to validate phy for mode " DRM_MODE_FMT "\n",
 562                         DRM_MODE_ARG(mode));
 563                 return ret;
 564         }
 565
 566         return MODE_OK;
 567 }
 568
 569 static bool imx93_dsi_mode_fixup(void *priv_data,
 570                                  const struct drm_display_mode *mode,
 571                                  struct drm_display_mode *adjusted_mode)
 572 {
 573         struct imx93_dsi *dsi = priv_data;
 574         unsigned long pixel_clock_rate;
 575         unsigned long rounded_rate;
 576
 577         pixel_clock_rate = mode->clock * 1000;
 578         rounded_rate = clk_round_rate(dsi->clk_pixel, pixel_clock_rate);
 579
 580         memcpy(adjusted_mode, mode, sizeof(*mode));
 581         adjusted_mode->clock = rounded_rate / 1000;
 582
 583         dev_dbg(dsi->dev, "adj clock %d for mode " DRM_MODE_FMT "\n",
 584                 adjusted_mode->clock, DRM_MODE_ARG(mode));
 585
 586         return true;
 587 }
 588
 589 static u32 *imx93_dsi_get_input_bus_fmts(void *priv_data,
 590                                          struct drm_bridge *bridge,
 591                                          struct drm_bridge_state *bridge_state,
 592                                          struct drm_crtc_state *crtc_state,
 593                                          struct drm_connector_state *conn_state,
 594                                          u32 output_fmt,
 595                                          unsigned int *num_input_fmts)
 596 {
 597         u32 *input_fmts, input_fmt;
 598
 599         *num_input_fmts = 0;
 600
 601         switch (output_fmt) {
 602         case MEDIA_BUS_FMT_RGB888_1X24:
 603         case MEDIA_BUS_FMT_RGB666_1X18:
 604         case MEDIA_BUS_FMT_FIXED:
 605                 input_fmt = MEDIA_BUS_FMT_RGB888_1X24;
 606                 break;
 607         case MEDIA_BUS_FMT_RGB565_1X16:
 608                 input_fmt = output_fmt;
 609                 break;
 610         default:
 611                 return NULL;
 612         }
 613
 614         input_fmts = kmalloc(sizeof(*input_fmts), GFP_KERNEL);
 615         if (!input_fmts)
 616                 return NULL;
 617         input_fmts[0] = input_fmt;
 618         *num_input_fmts = 1;
 619
 620         return input_fmts;
 621 }
 622
 623 static int imx93_dsi_phy_init(void *priv_data)
 624 {
 625         struct imx93_dsi *dsi = priv_data;
 626         unsigned int fmt = 0;
 627         int ret;
 628
 629         switch (dsi->format) {
 630         case MIPI_DSI_FMT_RGB888:
 631                 fmt = RGB888_TO_RGB888;
 632                 break;
 633         case MIPI_DSI_FMT_RGB666:
 634                 fmt = RGB888_TO_RGB666;
 635                 regmap_update_bits(dsi->regmap, DISPLAY_MUX,
 636                                    MIPI_DSI_RGB666_MAP_CFG, RGB666_CONFIG2);
 637                 break;
 638         case MIPI_DSI_FMT_RGB666_PACKED:
 639                 fmt = RGB888_TO_RGB666;
 640                 regmap_update_bits(dsi->regmap, DISPLAY_MUX,
 641                                    MIPI_DSI_RGB666_MAP_CFG, RGB666_CONFIG1);
 642                 break;
 643         case MIPI_DSI_FMT_RGB565:
 644                 fmt = RGB565_TO_RGB565;
 645                 regmap_update_bits(dsi->regmap, DISPLAY_MUX,
 646                                    MIPI_DSI_RGB565_MAP_CFG, RGB565_CONFIG1);
 647                 break;
 648         }
 649
 650         regmap_update_bits(dsi->regmap, DISPLAY_MUX, LCDIF_CROSS_LINE_PATTERN, fmt);
 651
 652         ret = dphy_pll_init(dsi);
 653         if (ret < 0) {
 654                 dev_err(dsi->dev, "failed to init phy pll: %d\n", ret);
 655                 return ret;
 656         }
 657
 658         ret = dphy_pll_configure(dsi, &dsi->phy_cfg);
 659         if (ret < 0) {
 660                 dev_err(dsi->dev, "failed to configure phy pll: %d\n", ret);
 661                 dphy_pll_uninit(dsi);
 662                 return ret;
 663         }
 664
 665         return 0;
 666 }
 667
 668 static void imx93_dsi_phy_power_off(void *priv_data)
 669 {
 670         struct imx93_dsi *dsi = priv_data;
 671
 672         dphy_pll_power_off(dsi);
 673         dphy_pll_uninit(dsi);
 674 }
 675
 676 static int
 677 imx93_dsi_get_lane_mbps(void *priv_data, const struct drm_display_mode *mode,
 678                         unsigned long mode_flags, u32 lanes, u32 format,
 679                         unsigned int *lane_mbps)
 680 {
 681         struct imx93_dsi *dsi = priv_data;
 682         union phy_configure_opts phy_cfg;
 683         struct device *dev = dsi->dev;
 684         int ret;
 685
 686         ret = imx93_dsi_get_phy_configure_opts(dsi, mode, &phy_cfg, lanes,
 687                                                format);
 688         if (ret < 0) {
 689                 dev_dbg(dev, "failed to get phy cfg opts %d\n", ret);
 690                 return ret;
 691         }
 692
 693         *lane_mbps = DIV_ROUND_UP(phy_cfg.mipi_dphy.hs_clk_rate, USEC_PER_SEC);
 694
 695         memcpy(&dsi->phy_cfg, &phy_cfg, sizeof(phy_cfg));
 696
 697         dev_dbg(dev, "get lane_mbps %u for mode " DRM_MODE_FMT "\n",
 698                 *lane_mbps, DRM_MODE_ARG(mode));
 699
 700         return 0;
 701 }
 702
 703 /* High-Speed Transition Times */
 704 struct hstt {
 705         unsigned int maxfreq;
 706         struct dw_mipi_dsi_dphy_timing timing;
 707 };
 708
 709 #define HSTT(_maxfreq, _c_lp2hs, _c_hs2lp, _d_lp2hs, _d_hs2lp)  \
 710 {                                                               \
 711         .maxfreq = (_maxfreq),                                  \
 712         .timing = {                                             \
 713                 .clk_lp2hs = (_c_lp2hs),                        \
 714                 .clk_hs2lp = (_c_hs2lp),                        \
 715                 .data_lp2hs = (_d_lp2hs),                       \
 716                 .data_hs2lp = (_d_hs2lp),                       \
 717         }                                                       \
 718 }
 719
 720 /* DPHY Databook Table A-4 High-Speed Transition Times */
 721 static const struct hstt hstt_table[] = {
 722         HSTT(80,    21,  17,  15, 10),
 723         HSTT(90,    23,  17,  16, 10),
 724         HSTT(100,   22,  17,  16, 10),
 725         HSTT(110,   25,  18,  17, 11),
 726         HSTT(120,   26,  20,  18, 11),
 727         HSTT(130,   27,  19,  19, 11),
 728         HSTT(140,   27,  19,  19, 11),
 729         HSTT(150,   28,  20,  20, 12),
 730         HSTT(160,   30,  21,  22, 13),
 731         HSTT(170,   30,  21,  23, 13),
 732         HSTT(180,   31,  21,  23, 13),
 733         HSTT(190,   32,  22,  24, 13),
 734         HSTT(205,   35,  22,  25, 13),
 735         HSTT(220,   37,  26,  27, 15),
 736         HSTT(235,   38,  28,  27, 16),
 737         HSTT(250,   41,  29,  30, 17),
 738         HSTT(275,   43,  29,  32, 18),
 739         HSTT(300,   45,  32,  35, 19),
 740         HSTT(325,   48,  33,  36, 18),
 741         HSTT(350,   51,  35,  40, 20),
 742         HSTT(400,   59,  37,  44, 21),
 743         HSTT(450,   65,  40,  49, 23),
 744         HSTT(500,   71,  41,  54, 24),
 745         HSTT(550,   77,  44,  57, 26),
 746         HSTT(600,   82,  46,  64, 27),
 747         HSTT(650,   87,  48,  67, 28),
 748         HSTT(700,   94,  52,  71, 29),
 749         HSTT(750,   99,  52,  75, 31),
 750         HSTT(800,  105,  55,  82, 32),
 751         HSTT(850,  110,  58,  85, 32),
 752         HSTT(900,  115,  58,  88, 35),
 753         HSTT(950,  120,  62,  93, 36),
 754         HSTT(1000, 128,  63,  99, 38),
 755         HSTT(1050, 132,  65, 102, 38),
 756         HSTT(1100, 138,  67, 106, 39),
 757         HSTT(1150, 146,  69, 112, 42),
 758         HSTT(1200, 151,  71, 117, 43),
 759         HSTT(1250, 153,  74, 120, 45),
 760         HSTT(1300, 160,  73, 124, 46),
 761         HSTT(1350, 165,  76, 130, 47),
 762         HSTT(1400, 172,  78, 134, 49),
 763         HSTT(1450, 177,  80, 138, 49),
 764         HSTT(1500, 183,  81, 143, 52),
 765         HSTT(1550, 191,  84, 147, 52),
 766         HSTT(1600, 194,  85, 152, 52),
 767         HSTT(1650, 201,  86, 155, 53),
 768         HSTT(1700, 208,  88, 161, 53),
 769         HSTT(1750, 212,  89, 165, 53),
 770         HSTT(1800, 220,  90, 171, 54),
 771         HSTT(1850, 223,  92, 175, 54),
 772         HSTT(1900, 231,  91, 180, 55),
 773         HSTT(1950, 236,  95, 185, 56),
 774         HSTT(2000, 243,  97, 190, 56),
 775         HSTT(2050, 248,  99, 194, 58),
 776         HSTT(2100, 252, 100, 199, 59),
 777         HSTT(2150, 259, 102, 204, 61),
 778         HSTT(2200, 266, 105, 210, 62),
 779         HSTT(2250, 269, 109, 213, 63),
 780         HSTT(2300, 272, 109, 217, 65),
 781         HSTT(2350, 281, 112, 225, 66),
 782         HSTT(2400, 283, 115, 226, 66),
 783         HSTT(2450, 282, 115, 226, 67),
 784         HSTT(2500, 281, 118, 227, 67),
 785 };
 786
 787 static int imx93_dsi_phy_get_timing(void *priv_data, unsigned int lane_mbps,
 788                                     struct dw_mipi_dsi_dphy_timing *timing)
 789 {
 790         struct imx93_dsi *dsi = priv_data;
 791         struct device *dev = dsi->dev;
 792         int i;
 793
 794         for (i = 0; i < ARRAY_SIZE(hstt_table); i++)
 795                 if (lane_mbps <= hstt_table[i].maxfreq)
 796                         break;
 797
 798         if (i == ARRAY_SIZE(hstt_table)) {
 799                 dev_err(dev, "failed to get phy timing for lane_mbps %u\n",
 800                         lane_mbps);
 801                 return -EINVAL;
 802         }
 803
 804         *timing = hstt_table[i].timing;
 805
 806         dev_dbg(dev, "get phy timing for %u <= %u (lane_mbps)\n",
 807                 lane_mbps, hstt_table[i].maxfreq);
 808
 809         return 0;
 810 }
 811
 812 static const struct dw_mipi_dsi_phy_ops imx93_dsi_phy_ops = {
 813         .init = imx93_dsi_phy_init,
 814         .power_off = imx93_dsi_phy_power_off,
 815         .get_lane_mbps = imx93_dsi_get_lane_mbps,
 816         .get_timing = imx93_dsi_phy_get_timing,
 817 };
 818
 819 static int imx93_dsi_host_attach(void *priv_data, struct mipi_dsi_device *device)
 820 {
 821         struct imx93_dsi *dsi = priv_data;
 822
 823         dsi->format = device->format;
 824
 825         return 0;
 826 }
 827
 828 static const struct dw_mipi_dsi_host_ops imx93_dsi_host_ops = {
 829         .attach = imx93_dsi_host_attach,
 830 };
 831
 832 static int imx93_dsi_probe(struct platform_device *pdev)
 833 {
 834         struct device *dev = &pdev->dev;
 835         struct device_node *np = dev->of_node;
 836         struct imx93_dsi *dsi;
 837         int ret;
 838
 839         dsi = devm_kzalloc(dev, sizeof(*dsi), GFP_KERNEL);
 840         if (!dsi)
 841                 return -ENOMEM;
 842
 843         dsi->regmap = syscon_regmap_lookup_by_phandle(np, "fsl,media-blk-ctrl");
 844         if (IS_ERR(dsi->regmap)) {
 845                 ret = PTR_ERR(dsi->regmap);
 846                 dev_err(dev, "failed to get block ctrl regmap: %d\n", ret);
 847                 return ret;
 848         }
 849
 850         dsi->clk_pixel = devm_clk_get(dev, "pix");
 851         if (IS_ERR(dsi->clk_pixel))
 852                 return dev_err_probe(dev, PTR_ERR(dsi->clk_pixel),
 853                                      "failed to get pixel clock\n");
 854
 855         dsi->clk_cfg = devm_clk_get(dev, "phy_cfg");
 856         if (IS_ERR(dsi->clk_cfg))
 857                 return dev_err_probe(dev, PTR_ERR(dsi->clk_cfg),
 858                                      "failed to get phy cfg clock\n");
 859
 860         dsi->clk_ref = devm_clk_get(dev, "phy_ref");
 861         if (IS_ERR(dsi->clk_ref))
 862                 return dev_err_probe(dev, PTR_ERR(dsi->clk_ref),
 863                                      "failed to get phy ref clock\n");
 864
 865         dsi->ref_clk_rate = clk_get_rate(dsi->clk_ref);
 866         if (dsi->ref_clk_rate < REF_CLK_RATE_MIN ||
 867             dsi->ref_clk_rate > REF_CLK_RATE_MAX) {
 868                 dev_err(dev, "invalid phy ref clock rate %lu\n",
 869                         dsi->ref_clk_rate);
 870                 return -EINVAL;
 871         }
 872         dev_dbg(dev, "phy ref clock rate: %lu\n", dsi->ref_clk_rate);
 873
 874         dsi->dev = dev;
 875         dsi->pdata.max_data_lanes = 4;
 876         dsi->pdata.mode_valid = imx93_dsi_mode_valid;
 877         dsi->pdata.mode_fixup = imx93_dsi_mode_fixup;
 878         dsi->pdata.get_input_bus_fmts = imx93_dsi_get_input_bus_fmts;
 879         dsi->pdata.phy_ops = &imx93_dsi_phy_ops;
 880         dsi->pdata.host_ops = &imx93_dsi_host_ops;
 881         dsi->pdata.priv_data = dsi;
 882         platform_set_drvdata(pdev, dsi);
 883
 884         dsi->dmd = dw_mipi_dsi_probe(pdev, &dsi->pdata);
 885         if (IS_ERR(dsi->dmd))
 886                 return dev_err_probe(dev, PTR_ERR(dsi->dmd),
 887                                      "failed to probe dw_mipi_dsi\n");
 888
 889         return 0;
 890 }
 891
 892 static void imx93_dsi_remove(struct platform_device *pdev)
 893 {
 894         struct imx93_dsi *dsi = platform_get_drvdata(pdev);
 895
 896         dw_mipi_dsi_remove(dsi->dmd);
 897 }
 898
 899 static const struct of_device_id imx93_dsi_dt_ids[] = {
 900         { .compatible = "fsl,imx93-mipi-dsi", },
 901         { /* sentinel */ }
 902 };
 903 MODULE_DEVICE_TABLE(of, imx93_dsi_dt_ids);
 904
 905 static struct platform_driver imx93_dsi_driver = {
 906         .probe  = imx93_dsi_probe,
 907         .remove_new = imx93_dsi_remove,
 908         .driver = {
 909                 .of_match_table = imx93_dsi_dt_ids,
 910                 .name = "imx93_mipi_dsi",
 911         },
 912 };
 913 module_platform_driver(imx93_dsi_driver);
 914
 915 MODULE_DESCRIPTION("Freescale i.MX93 MIPI DSI driver");
 916 MODULE_AUTHOR("Liu Ying <[email protected]>");
 917 MODULE_LICENSE("GPL");