drivers/gpu/drm/msm/dsi/dsi_host.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (c) 2015, The Linux Foundation. All rights reserved.
   4  */
   5
   6 #include <linux/clk.h>
   7 #include <linux/delay.h>
   8 #include <linux/dma-mapping.h>
   9 #include <linux/err.h>
  10 #include <linux/gpio/consumer.h>
  11 #include <linux/interrupt.h>
  12 #include <linux/mfd/syscon.h>
  13 #include <linux/of_device.h>
  14 #include <linux/of_graph.h>
  15 #include <linux/of_irq.h>
  16 #include <linux/pinctrl/consumer.h>
  17 #include <linux/pm_opp.h>
  18 #include <linux/regmap.h>
  19 #include <linux/regulator/consumer.h>
  20 #include <linux/spinlock.h>
  21
  22 #include <video/mipi_display.h>
  23
  24 #include <drm/display/drm_dsc_helper.h>
  25 #include <drm/drm_of.h>
  26
  27 #include "dsi.h"
  28 #include "dsi.xml.h"
  29 #include "sfpb.xml.h"
  30 #include "dsi_cfg.h"
  31 #include "msm_kms.h"
  32 #include "msm_gem.h"
  33 #include "phy/dsi_phy.h"
  34
  35 #define DSI_RESET_TOGGLE_DELAY_MS 20
  36
  37 static int dsi_populate_dsc_params(struct msm_dsi_host *msm_host, struct drm_dsc_config *dsc);
  38
  39 static int dsi_get_version(const void __iomem *base, u32 *major, u32 *minor)
  40 {
  41         u32 ver;
  42
  43         if (!major || !minor)
  44                 return -EINVAL;
  45
  46         /*
  47          * From DSI6G(v3), addition of a 6G_HW_VERSION register at offset 0
  48          * makes all other registers 4-byte shifted down.
  49          *
  50          * In order to identify between DSI6G(v3) and beyond, and DSIv2 and
  51          * older, we read the DSI_VERSION register without any shift(offset
  52          * 0x1f0). In the case of DSIv2, this hast to be a non-zero value. In
  53          * the case of DSI6G, this has to be zero (the offset points to a
  54          * scratch register which we never touch)
  55          */
  56
  57         ver = msm_readl(base + REG_DSI_VERSION);
  58         if (ver) {
  59                 /* older dsi host, there is no register shift */
  60                 ver = FIELD(ver, DSI_VERSION_MAJOR);
  61                 if (ver <= MSM_DSI_VER_MAJOR_V2) {
  62                         /* old versions */
  63                         *major = ver;
  64                         *minor = 0;
  65                         return 0;
  66                 } else {
  67                         return -EINVAL;
  68                 }
  69         } else {
  70                 /*
  71                  * newer host, offset 0 has 6G_HW_VERSION, the rest of the
  72                  * registers are shifted down, read DSI_VERSION again with
  73                  * the shifted offset
  74                  */
  75                 ver = msm_readl(base + DSI_6G_REG_SHIFT + REG_DSI_VERSION);
  76                 ver = FIELD(ver, DSI_VERSION_MAJOR);
  77                 if (ver == MSM_DSI_VER_MAJOR_6G) {
  78                         /* 6G version */
  79                         *major = ver;
  80                         *minor = msm_readl(base + REG_DSI_6G_HW_VERSION);
  81                         return 0;
  82                 } else {
  83                         return -EINVAL;
  84                 }
  85         }
  86 }
  87
  88 #define DSI_ERR_STATE_ACK                       0x0000
  89 #define DSI_ERR_STATE_TIMEOUT                   0x0001
  90 #define DSI_ERR_STATE_DLN0_PHY                  0x0002
  91 #define DSI_ERR_STATE_FIFO                      0x0004
  92 #define DSI_ERR_STATE_MDP_FIFO_UNDERFLOW        0x0008
  93 #define DSI_ERR_STATE_INTERLEAVE_OP_CONTENTION  0x0010
  94 #define DSI_ERR_STATE_PLL_UNLOCKED              0x0020
  95
  96 #define DSI_CLK_CTRL_ENABLE_CLKS        \
  97                 (DSI_CLK_CTRL_AHBS_HCLK_ON | DSI_CLK_CTRL_AHBM_SCLK_ON | \
  98                 DSI_CLK_CTRL_PCLK_ON | DSI_CLK_CTRL_DSICLK_ON | \
  99                 DSI_CLK_CTRL_BYTECLK_ON | DSI_CLK_CTRL_ESCCLK_ON | \
 100                 DSI_CLK_CTRL_FORCE_ON_DYN_AHBM_HCLK)
 101
 102 struct msm_dsi_host {
 103         struct mipi_dsi_host base;
 104
 105         struct platform_device *pdev;
 106         struct drm_device *dev;
 107
 108         int id;
 109
 110         void __iomem *ctrl_base;
 111         phys_addr_t ctrl_size;
 112         struct regulator_bulk_data *supplies;
 113
 114         int num_bus_clks;
 115         struct clk_bulk_data bus_clks[DSI_BUS_CLK_MAX];
 116
 117         struct clk *byte_clk;
 118         struct clk *esc_clk;
 119         struct clk *pixel_clk;
 120         struct clk *byte_clk_src;
 121         struct clk *pixel_clk_src;
 122         struct clk *byte_intf_clk;
 123
 124         unsigned long byte_clk_rate;
 125         unsigned long pixel_clk_rate;
 126         unsigned long esc_clk_rate;
 127
 128         /* DSI v2 specific clocks */
 129         struct clk *src_clk;
 130         struct clk *esc_clk_src;
 131         struct clk *dsi_clk_src;
 132
 133         unsigned long src_clk_rate;
 134
 135         struct gpio_desc *disp_en_gpio;
 136         struct gpio_desc *te_gpio;
 137
 138         const struct msm_dsi_cfg_handler *cfg_hnd;
 139
 140         struct completion dma_comp;
 141         struct completion video_comp;
 142         struct mutex dev_mutex;
 143         struct mutex cmd_mutex;
 144         spinlock_t intr_lock; /* Protect interrupt ctrl register */
 145
 146         u32 err_work_state;
 147         struct work_struct err_work;
 148         struct workqueue_struct *workqueue;
 149
 150         /* DSI 6G TX buffer*/
 151         struct drm_gem_object *tx_gem_obj;
 152         struct msm_gem_address_space *aspace;
 153
 154         /* DSI v2 TX buffer */
 155         void *tx_buf;
 156         dma_addr_t tx_buf_paddr;
 157
 158         int tx_size;
 159
 160         u8 *rx_buf;
 161
 162         struct regmap *sfpb;
 163
 164         struct drm_display_mode *mode;
 165         struct drm_dsc_config *dsc;
 166
 167         /* connected device info */
 168         unsigned int channel;
 169         unsigned int lanes;
 170         enum mipi_dsi_pixel_format format;
 171         unsigned long mode_flags;
 172
 173         /* lane data parsed via DT */
 174         int dlane_swap;
 175         int num_data_lanes;
 176
 177         /* from phy DT */
 178         bool cphy_mode;
 179
 180         u32 dma_cmd_ctrl_restore;
 181
 182         bool registered;
 183         bool power_on;
 184         bool enabled;
 185         int irq;
 186 };
 187
 188 static u32 dsi_get_bpp(const enum mipi_dsi_pixel_format fmt)
 189 {
 190         switch (fmt) {
 191         case MIPI_DSI_FMT_RGB565:               return 16;
 192         case MIPI_DSI_FMT_RGB666_PACKED:        return 18;
 193         case MIPI_DSI_FMT_RGB666:
 194         case MIPI_DSI_FMT_RGB888:
 195         default:                                return 24;
 196         }
 197 }
 198
 199 static inline u32 dsi_read(struct msm_dsi_host *msm_host, u32 reg)
 200 {
 201         return msm_readl(msm_host->ctrl_base + reg);
 202 }
 203 static inline void dsi_write(struct msm_dsi_host *msm_host, u32 reg, u32 data)
 204 {
 205         msm_writel(data, msm_host->ctrl_base + reg);
 206 }
 207
 208 static const struct msm_dsi_cfg_handler *dsi_get_config(
 209                                                 struct msm_dsi_host *msm_host)
 210 {
 211         const struct msm_dsi_cfg_handler *cfg_hnd = NULL;
 212         struct device *dev = &msm_host->pdev->dev;
 213         struct clk *ahb_clk;
 214         int ret;
 215         u32 major = 0, minor = 0;
 216
 217         cfg_hnd = device_get_match_data(dev);
 218         if (cfg_hnd)
 219                 return cfg_hnd;
 220
 221         ahb_clk = msm_clk_get(msm_host->pdev, "iface");
 222         if (IS_ERR(ahb_clk)) {
 223                 pr_err("%s: cannot get interface clock\n", __func__);
 224                 goto exit;
 225         }
 226
 227         pm_runtime_get_sync(dev);
 228
 229         ret = clk_prepare_enable(ahb_clk);
 230         if (ret) {
 231                 pr_err("%s: unable to enable ahb_clk\n", __func__);
 232                 goto runtime_put;
 233         }
 234
 235         ret = dsi_get_version(msm_host->ctrl_base, &major, &minor);
 236         if (ret) {
 237                 pr_err("%s: Invalid version\n", __func__);
 238                 goto disable_clks;
 239         }
 240
 241         cfg_hnd = msm_dsi_cfg_get(major, minor);
 242
 243         DBG("%s: Version %x:%x\n", __func__, major, minor);
 244
 245 disable_clks:
 246         clk_disable_unprepare(ahb_clk);
 247 runtime_put:
 248         pm_runtime_put_sync(dev);
 249 exit:
 250         return cfg_hnd;
 251 }
 252
 253 static inline struct msm_dsi_host *to_msm_dsi_host(struct mipi_dsi_host *host)
 254 {
 255         return container_of(host, struct msm_dsi_host, base);
 256 }
 257
 258 int dsi_clk_init_v2(struct msm_dsi_host *msm_host)
 259 {
 260         struct platform_device *pdev = msm_host->pdev;
 261         int ret = 0;
 262
 263         msm_host->src_clk = msm_clk_get(pdev, "src");
 264
 265         if (IS_ERR(msm_host->src_clk)) {
 266                 ret = PTR_ERR(msm_host->src_clk);
 267                 pr_err("%s: can't find src clock. ret=%d\n",
 268                         __func__, ret);
 269                 msm_host->src_clk = NULL;
 270                 return ret;
 271         }
 272
 273         msm_host->esc_clk_src = clk_get_parent(msm_host->esc_clk);
 274         if (!msm_host->esc_clk_src) {
 275                 ret = -ENODEV;
 276                 pr_err("%s: can't get esc clock parent. ret=%d\n",
 277                         __func__, ret);
 278                 return ret;
 279         }
 280
 281         msm_host->dsi_clk_src = clk_get_parent(msm_host->src_clk);
 282         if (!msm_host->dsi_clk_src) {
 283                 ret = -ENODEV;
 284                 pr_err("%s: can't get src clock parent. ret=%d\n",
 285                         __func__, ret);
 286         }
 287
 288         return ret;
 289 }
 290
 291 int dsi_clk_init_6g_v2(struct msm_dsi_host *msm_host)
 292 {
 293         struct platform_device *pdev = msm_host->pdev;
 294         int ret = 0;
 295
 296         msm_host->byte_intf_clk = msm_clk_get(pdev, "byte_intf");
 297         if (IS_ERR(msm_host->byte_intf_clk)) {
 298                 ret = PTR_ERR(msm_host->byte_intf_clk);
 299                 pr_err("%s: can't find byte_intf clock. ret=%d\n",
 300                         __func__, ret);
 301         }
 302
 303         return ret;
 304 }
 305
 306 static int dsi_clk_init(struct msm_dsi_host *msm_host)
 307 {
 308         struct platform_device *pdev = msm_host->pdev;
 309         const struct msm_dsi_cfg_handler *cfg_hnd = msm_host->cfg_hnd;
 310         const struct msm_dsi_config *cfg = cfg_hnd->cfg;
 311         int i, ret = 0;
 312
 313         /* get bus clocks */
 314         for (i = 0; i < cfg->num_bus_clks; i++)
 315                 msm_host->bus_clks[i].id = cfg->bus_clk_names[i];
 316         msm_host->num_bus_clks = cfg->num_bus_clks;
 317
 318         ret = devm_clk_bulk_get(&pdev->dev, msm_host->num_bus_clks, msm_host->bus_clks);
 319         if (ret < 0) {
 320                 dev_err(&pdev->dev, "Unable to get clocks, ret = %d\n", ret);
 321                 goto exit;
 322         }
 323
 324         /* get link and source clocks */
 325         msm_host->byte_clk = msm_clk_get(pdev, "byte");
 326         if (IS_ERR(msm_host->byte_clk)) {
 327                 ret = PTR_ERR(msm_host->byte_clk);
 328                 pr_err("%s: can't find dsi_byte clock. ret=%d\n",
 329                         __func__, ret);
 330                 msm_host->byte_clk = NULL;
 331                 goto exit;
 332         }
 333
 334         msm_host->pixel_clk = msm_clk_get(pdev, "pixel");
 335         if (IS_ERR(msm_host->pixel_clk)) {
 336                 ret = PTR_ERR(msm_host->pixel_clk);
 337                 pr_err("%s: can't find dsi_pixel clock. ret=%d\n",
 338                         __func__, ret);
 339                 msm_host->pixel_clk = NULL;
 340                 goto exit;
 341         }
 342
 343         msm_host->esc_clk = msm_clk_get(pdev, "core");
 344         if (IS_ERR(msm_host->esc_clk)) {
 345                 ret = PTR_ERR(msm_host->esc_clk);
 346                 pr_err("%s: can't find dsi_esc clock. ret=%d\n",
 347                         __func__, ret);
 348                 msm_host->esc_clk = NULL;
 349                 goto exit;
 350         }
 351
 352         msm_host->byte_clk_src = clk_get_parent(msm_host->byte_clk);
 353         if (IS_ERR(msm_host->byte_clk_src)) {
 354                 ret = PTR_ERR(msm_host->byte_clk_src);
 355                 pr_err("%s: can't find byte_clk clock. ret=%d\n", __func__, ret);
 356                 goto exit;
 357         }
 358
 359         msm_host->pixel_clk_src = clk_get_parent(msm_host->pixel_clk);
 360         if (IS_ERR(msm_host->pixel_clk_src)) {
 361                 ret = PTR_ERR(msm_host->pixel_clk_src);
 362                 pr_err("%s: can't find pixel_clk clock. ret=%d\n", __func__, ret);
 363                 goto exit;
 364         }
 365
 366         if (cfg_hnd->ops->clk_init_ver)
 367                 ret = cfg_hnd->ops->clk_init_ver(msm_host);
 368 exit:
 369         return ret;
 370 }
 371
 372 int msm_dsi_runtime_suspend(struct device *dev)
 373 {
 374         struct platform_device *pdev = to_platform_device(dev);
 375         struct msm_dsi *msm_dsi = platform_get_drvdata(pdev);
 376         struct mipi_dsi_host *host = msm_dsi->host;
 377         struct msm_dsi_host *msm_host = to_msm_dsi_host(host);
 378
 379         if (!msm_host->cfg_hnd)
 380                 return 0;
 381
 382         clk_bulk_disable_unprepare(msm_host->num_bus_clks, msm_host->bus_clks);
 383
 384         return 0;
 385 }
 386
 387 int msm_dsi_runtime_resume(struct device *dev)
 388 {
 389         struct platform_device *pdev = to_platform_device(dev);
 390         struct msm_dsi *msm_dsi = platform_get_drvdata(pdev);
 391         struct mipi_dsi_host *host = msm_dsi->host;
 392         struct msm_dsi_host *msm_host = to_msm_dsi_host(host);
 393
 394         if (!msm_host->cfg_hnd)
 395                 return 0;
 396
 397         return clk_bulk_prepare_enable(msm_host->num_bus_clks, msm_host->bus_clks);
 398 }
 399
 400 int dsi_link_clk_set_rate_6g(struct msm_dsi_host *msm_host)
 401 {
 402         unsigned long byte_intf_rate;
 403         int ret;
 404
 405         DBG("Set clk rates: pclk=%d, byteclk=%lu",
 406                 msm_host->mode->clock, msm_host->byte_clk_rate);
 407
 408         ret = dev_pm_opp_set_rate(&msm_host->pdev->dev,
 409                                   msm_host->byte_clk_rate);
 410         if (ret) {
 411                 pr_err("%s: dev_pm_opp_set_rate failed %d\n", __func__, ret);
 412                 return ret;
 413         }
 414
 415         ret = clk_set_rate(msm_host->pixel_clk, msm_host->pixel_clk_rate);
 416         if (ret) {
 417                 pr_err("%s: Failed to set rate pixel clk, %d\n", __func__, ret);
 418                 return ret;
 419         }
 420
 421         if (msm_host->byte_intf_clk) {
 422                 /* For CPHY, byte_intf_clk is same as byte_clk */
 423                 if (msm_host->cphy_mode)
 424                         byte_intf_rate = msm_host->byte_clk_rate;
 425                 else
 426                         byte_intf_rate = msm_host->byte_clk_rate / 2;
 427
 428                 ret = clk_set_rate(msm_host->byte_intf_clk, byte_intf_rate);
 429                 if (ret) {
 430                         pr_err("%s: Failed to set rate byte intf clk, %d\n",
 431                                __func__, ret);
 432                         return ret;
 433                 }
 434         }
 435
 436         return 0;
 437 }
 438
 439
 440 int dsi_link_clk_enable_6g(struct msm_dsi_host *msm_host)
 441 {
 442         int ret;
 443
 444         ret = clk_prepare_enable(msm_host->esc_clk);
 445         if (ret) {
 446                 pr_err("%s: Failed to enable dsi esc clk\n", __func__);
 447                 goto error;
 448         }
 449
 450         ret = clk_prepare_enable(msm_host->byte_clk);
 451         if (ret) {
 452                 pr_err("%s: Failed to enable dsi byte clk\n", __func__);
 453                 goto byte_clk_err;
 454         }
 455
 456         ret = clk_prepare_enable(msm_host->pixel_clk);
 457         if (ret) {
 458                 pr_err("%s: Failed to enable dsi pixel clk\n", __func__);
 459                 goto pixel_clk_err;
 460         }
 461
 462         ret = clk_prepare_enable(msm_host->byte_intf_clk);
 463         if (ret) {
 464                 pr_err("%s: Failed to enable byte intf clk\n",
 465                            __func__);
 466                 goto byte_intf_clk_err;
 467         }
 468
 469         return 0;
 470
 471 byte_intf_clk_err:
 472         clk_disable_unprepare(msm_host->pixel_clk);
 473 pixel_clk_err:
 474         clk_disable_unprepare(msm_host->byte_clk);
 475 byte_clk_err:
 476         clk_disable_unprepare(msm_host->esc_clk);
 477 error:
 478         return ret;
 479 }
 480
 481 int dsi_link_clk_set_rate_v2(struct msm_dsi_host *msm_host)
 482 {
 483         int ret;
 484
 485         DBG("Set clk rates: pclk=%d, byteclk=%lu, esc_clk=%lu, dsi_src_clk=%lu",
 486                 msm_host->mode->clock, msm_host->byte_clk_rate,
 487                 msm_host->esc_clk_rate, msm_host->src_clk_rate);
 488
 489         ret = clk_set_rate(msm_host->byte_clk, msm_host->byte_clk_rate);
 490         if (ret) {
 491                 pr_err("%s: Failed to set rate byte clk, %d\n", __func__, ret);
 492                 return ret;
 493         }
 494
 495         ret = clk_set_rate(msm_host->esc_clk, msm_host->esc_clk_rate);
 496         if (ret) {
 497                 pr_err("%s: Failed to set rate esc clk, %d\n", __func__, ret);
 498                 return ret;
 499         }
 500
 501         ret = clk_set_rate(msm_host->src_clk, msm_host->src_clk_rate);
 502         if (ret) {
 503                 pr_err("%s: Failed to set rate src clk, %d\n", __func__, ret);
 504                 return ret;
 505         }
 506
 507         ret = clk_set_rate(msm_host->pixel_clk, msm_host->pixel_clk_rate);
 508         if (ret) {
 509                 pr_err("%s: Failed to set rate pixel clk, %d\n", __func__, ret);
 510                 return ret;
 511         }
 512
 513         return 0;
 514 }
 515
 516 int dsi_link_clk_enable_v2(struct msm_dsi_host *msm_host)
 517 {
 518         int ret;
 519
 520         ret = clk_prepare_enable(msm_host->byte_clk);
 521         if (ret) {
 522                 pr_err("%s: Failed to enable dsi byte clk\n", __func__);
 523                 goto error;
 524         }
 525
 526         ret = clk_prepare_enable(msm_host->esc_clk);
 527         if (ret) {
 528                 pr_err("%s: Failed to enable dsi esc clk\n", __func__);
 529                 goto esc_clk_err;
 530         }
 531
 532         ret = clk_prepare_enable(msm_host->src_clk);
 533         if (ret) {
 534                 pr_err("%s: Failed to enable dsi src clk\n", __func__);
 535                 goto src_clk_err;
 536         }
 537
 538         ret = clk_prepare_enable(msm_host->pixel_clk);
 539         if (ret) {
 540                 pr_err("%s: Failed to enable dsi pixel clk\n", __func__);
 541                 goto pixel_clk_err;
 542         }
 543
 544         return 0;
 545
 546 pixel_clk_err:
 547         clk_disable_unprepare(msm_host->src_clk);
 548 src_clk_err:
 549         clk_disable_unprepare(msm_host->esc_clk);
 550 esc_clk_err:
 551         clk_disable_unprepare(msm_host->byte_clk);
 552 error:
 553         return ret;
 554 }
 555
 556 void dsi_link_clk_disable_6g(struct msm_dsi_host *msm_host)
 557 {
 558         /* Drop the performance state vote */
 559         dev_pm_opp_set_rate(&msm_host->pdev->dev, 0);
 560         clk_disable_unprepare(msm_host->esc_clk);
 561         clk_disable_unprepare(msm_host->pixel_clk);
 562         clk_disable_unprepare(msm_host->byte_intf_clk);
 563         clk_disable_unprepare(msm_host->byte_clk);
 564 }
 565
 566 void dsi_link_clk_disable_v2(struct msm_dsi_host *msm_host)
 567 {
 568         clk_disable_unprepare(msm_host->pixel_clk);
 569         clk_disable_unprepare(msm_host->src_clk);
 570         clk_disable_unprepare(msm_host->esc_clk);
 571         clk_disable_unprepare(msm_host->byte_clk);
 572 }
 573
 574 static unsigned long dsi_get_pclk_rate(struct msm_dsi_host *msm_host, bool is_bonded_dsi)
 575 {
 576         struct drm_display_mode *mode = msm_host->mode;
 577         unsigned long pclk_rate;
 578
 579         pclk_rate = mode->clock * 1000;
 580
 581         /*
 582          * For bonded DSI mode, the current DRM mode has the complete width of the
 583          * panel. Since, the complete panel is driven by two DSI controllers,
 584          * the clock rates have to be split between the two dsi controllers.
 585          * Adjust the byte and pixel clock rates for each dsi host accordingly.
 586          */
 587         if (is_bonded_dsi)
 588                 pclk_rate /= 2;
 589
 590         return pclk_rate;
 591 }
 592
 593 static void dsi_calc_pclk(struct msm_dsi_host *msm_host, bool is_bonded_dsi)
 594 {
 595         u8 lanes = msm_host->lanes;
 596         u32 bpp = dsi_get_bpp(msm_host->format);
 597         unsigned long pclk_rate = dsi_get_pclk_rate(msm_host, is_bonded_dsi);
 598         u64 pclk_bpp = (u64)pclk_rate * bpp;
 599
 600         if (lanes == 0) {
 601                 pr_err("%s: forcing mdss_dsi lanes to 1\n", __func__);
 602                 lanes = 1;
 603         }
 604
 605         /* CPHY "byte_clk" is in units of 16 bits */
 606         if (msm_host->cphy_mode)
 607                 do_div(pclk_bpp, (16 * lanes));
 608         else
 609                 do_div(pclk_bpp, (8 * lanes));
 610
 611         msm_host->pixel_clk_rate = pclk_rate;
 612         msm_host->byte_clk_rate = pclk_bpp;
 613
 614         DBG("pclk=%lu, bclk=%lu", msm_host->pixel_clk_rate,
 615                                 msm_host->byte_clk_rate);
 616
 617 }
 618
 619 int dsi_calc_clk_rate_6g(struct msm_dsi_host *msm_host, bool is_bonded_dsi)
 620 {
 621         if (!msm_host->mode) {
 622                 pr_err("%s: mode not set\n", __func__);
 623                 return -EINVAL;
 624         }
 625
 626         dsi_calc_pclk(msm_host, is_bonded_dsi);
 627         msm_host->esc_clk_rate = clk_get_rate(msm_host->esc_clk);
 628         return 0;
 629 }
 630
 631 int dsi_calc_clk_rate_v2(struct msm_dsi_host *msm_host, bool is_bonded_dsi)
 632 {
 633         u32 bpp = dsi_get_bpp(msm_host->format);
 634         u64 pclk_bpp;
 635         unsigned int esc_mhz, esc_div;
 636         unsigned long byte_mhz;
 637
 638         dsi_calc_pclk(msm_host, is_bonded_dsi);
 639
 640         pclk_bpp = (u64)dsi_get_pclk_rate(msm_host, is_bonded_dsi) * bpp;
 641         do_div(pclk_bpp, 8);
 642         msm_host->src_clk_rate = pclk_bpp;
 643
 644         /*
 645          * esc clock is byte clock followed by a 4 bit divider,
 646          * we need to find an escape clock frequency within the
 647          * mipi DSI spec range within the maximum divider limit
 648          * We iterate here between an escape clock frequencey
 649          * between 20 Mhz to 5 Mhz and pick up the first one
 650          * that can be supported by our divider
 651          */
 652
 653         byte_mhz = msm_host->byte_clk_rate / 1000000;
 654
 655         for (esc_mhz = 20; esc_mhz >= 5; esc_mhz--) {
 656                 esc_div = DIV_ROUND_UP(byte_mhz, esc_mhz);
 657
 658                 /*
 659                  * TODO: Ideally, we shouldn't know what sort of divider
 660                  * is available in mmss_cc, we're just assuming that
 661                  * it'll always be a 4 bit divider. Need to come up with
 662                  * a better way here.
 663                  */
 664                 if (esc_div >= 1 && esc_div <= 16)
 665                         break;
 666         }
 667
 668         if (esc_mhz < 5)
 669                 return -EINVAL;
 670
 671         msm_host->esc_clk_rate = msm_host->byte_clk_rate / esc_div;
 672
 673         DBG("esc=%lu, src=%lu", msm_host->esc_clk_rate,
 674                 msm_host->src_clk_rate);
 675
 676         return 0;
 677 }
 678
 679 static void dsi_intr_ctrl(struct msm_dsi_host *msm_host, u32 mask, int enable)
 680 {
 681         u32 intr;
 682         unsigned long flags;
 683
 684         spin_lock_irqsave(&msm_host->intr_lock, flags);
 685         intr = dsi_read(msm_host, REG_DSI_INTR_CTRL);
 686
 687         if (enable)
 688                 intr |= mask;
 689         else
 690                 intr &= ~mask;
 691
 692         DBG("intr=%x enable=%d", intr, enable);
 693
 694         dsi_write(msm_host, REG_DSI_INTR_CTRL, intr);
 695         spin_unlock_irqrestore(&msm_host->intr_lock, flags);
 696 }
 697
 698 static inline enum dsi_traffic_mode dsi_get_traffic_mode(const u32 mode_flags)
 699 {
 700         if (mode_flags & MIPI_DSI_MODE_VIDEO_BURST)
 701                 return BURST_MODE;
 702         else if (mode_flags & MIPI_DSI_MODE_VIDEO_SYNC_PULSE)
 703                 return NON_BURST_SYNCH_PULSE;
 704
 705         return NON_BURST_SYNCH_EVENT;
 706 }
 707
 708 static inline enum dsi_vid_dst_format dsi_get_vid_fmt(
 709                                 const enum mipi_dsi_pixel_format mipi_fmt)
 710 {
 711         switch (mipi_fmt) {
 712         case MIPI_DSI_FMT_RGB888:       return VID_DST_FORMAT_RGB888;
 713         case MIPI_DSI_FMT_RGB666:       return VID_DST_FORMAT_RGB666_LOOSE;
 714         case MIPI_DSI_FMT_RGB666_PACKED:        return VID_DST_FORMAT_RGB666;
 715         case MIPI_DSI_FMT_RGB565:       return VID_DST_FORMAT_RGB565;
 716         default:                        return VID_DST_FORMAT_RGB888;
 717         }
 718 }
 719
 720 static inline enum dsi_cmd_dst_format dsi_get_cmd_fmt(
 721                                 const enum mipi_dsi_pixel_format mipi_fmt)
 722 {
 723         switch (mipi_fmt) {
 724         case MIPI_DSI_FMT_RGB888:       return CMD_DST_FORMAT_RGB888;
 725         case MIPI_DSI_FMT_RGB666_PACKED:
 726         case MIPI_DSI_FMT_RGB666:       return CMD_DST_FORMAT_RGB666;
 727         case MIPI_DSI_FMT_RGB565:       return CMD_DST_FORMAT_RGB565;
 728         default:                        return CMD_DST_FORMAT_RGB888;
 729         }
 730 }
 731
 732 static void dsi_ctrl_config(struct msm_dsi_host *msm_host, bool enable,
 733                         struct msm_dsi_phy_shared_timings *phy_shared_timings, struct msm_dsi_phy *phy)
 734 {
 735         u32 flags = msm_host->mode_flags;
 736         enum mipi_dsi_pixel_format mipi_fmt = msm_host->format;
 737         const struct msm_dsi_cfg_handler *cfg_hnd = msm_host->cfg_hnd;
 738         u32 data = 0, lane_ctrl = 0;
 739
 740         if (!enable) {
 741                 dsi_write(msm_host, REG_DSI_CTRL, 0);
 742                 return;
 743         }
 744
 745         if (flags & MIPI_DSI_MODE_VIDEO) {
 746                 if (flags & MIPI_DSI_MODE_VIDEO_HSE)
 747                         data |= DSI_VID_CFG0_PULSE_MODE_HSA_HE;
 748                 if (flags & MIPI_DSI_MODE_VIDEO_NO_HFP)
 749                         data |= DSI_VID_CFG0_HFP_POWER_STOP;
 750                 if (flags & MIPI_DSI_MODE_VIDEO_NO_HBP)
 751                         data |= DSI_VID_CFG0_HBP_POWER_STOP;
 752                 if (flags & MIPI_DSI_MODE_VIDEO_NO_HSA)
 753                         data |= DSI_VID_CFG0_HSA_POWER_STOP;
 754                 /* Always set low power stop mode for BLLP
 755                  * to let command engine send packets
 756                  */
 757                 data |= DSI_VID_CFG0_EOF_BLLP_POWER_STOP |
 758                         DSI_VID_CFG0_BLLP_POWER_STOP;
 759                 data |= DSI_VID_CFG0_TRAFFIC_MODE(dsi_get_traffic_mode(flags));
 760                 data |= DSI_VID_CFG0_DST_FORMAT(dsi_get_vid_fmt(mipi_fmt));
 761                 data |= DSI_VID_CFG0_VIRT_CHANNEL(msm_host->channel);
 762                 dsi_write(msm_host, REG_DSI_VID_CFG0, data);
 763
 764                 /* Do not swap RGB colors */
 765                 data = DSI_VID_CFG1_RGB_SWAP(SWAP_RGB);
 766                 dsi_write(msm_host, REG_DSI_VID_CFG1, 0);
 767         } else {
 768                 /* Do not swap RGB colors */
 769                 data = DSI_CMD_CFG0_RGB_SWAP(SWAP_RGB);
 770                 data |= DSI_CMD_CFG0_DST_FORMAT(dsi_get_cmd_fmt(mipi_fmt));
 771                 dsi_write(msm_host, REG_DSI_CMD_CFG0, data);
 772
 773                 data = DSI_CMD_CFG1_WR_MEM_START(MIPI_DCS_WRITE_MEMORY_START) |
 774                         DSI_CMD_CFG1_WR_MEM_CONTINUE(
 775                                         MIPI_DCS_WRITE_MEMORY_CONTINUE);
 776                 /* Always insert DCS command */
 777                 data |= DSI_CMD_CFG1_INSERT_DCS_COMMAND;
 778                 dsi_write(msm_host, REG_DSI_CMD_CFG1, data);
 779         }
 780
 781         dsi_write(msm_host, REG_DSI_CMD_DMA_CTRL,
 782                         DSI_CMD_DMA_CTRL_FROM_FRAME_BUFFER |
 783                         DSI_CMD_DMA_CTRL_LOW_POWER);
 784
 785         data = 0;
 786         /* Always assume dedicated TE pin */
 787         data |= DSI_TRIG_CTRL_TE;
 788         data |= DSI_TRIG_CTRL_MDP_TRIGGER(TRIGGER_NONE);
 789         data |= DSI_TRIG_CTRL_DMA_TRIGGER(TRIGGER_SW);
 790         data |= DSI_TRIG_CTRL_STREAM(msm_host->channel);
 791         if ((cfg_hnd->major == MSM_DSI_VER_MAJOR_6G) &&
 792                 (cfg_hnd->minor >= MSM_DSI_6G_VER_MINOR_V1_2))
 793                 data |= DSI_TRIG_CTRL_BLOCK_DMA_WITHIN_FRAME;
 794         dsi_write(msm_host, REG_DSI_TRIG_CTRL, data);
 795
 796         data = DSI_CLKOUT_TIMING_CTRL_T_CLK_POST(phy_shared_timings->clk_post) |
 797                 DSI_CLKOUT_TIMING_CTRL_T_CLK_PRE(phy_shared_timings->clk_pre);
 798         dsi_write(msm_host, REG_DSI_CLKOUT_TIMING_CTRL, data);
 799
 800         if ((cfg_hnd->major == MSM_DSI_VER_MAJOR_6G) &&
 801             (cfg_hnd->minor > MSM_DSI_6G_VER_MINOR_V1_0) &&
 802             phy_shared_timings->clk_pre_inc_by_2)
 803                 dsi_write(msm_host, REG_DSI_T_CLK_PRE_EXTEND,
 804                           DSI_T_CLK_PRE_EXTEND_INC_BY_2_BYTECLK);
 805
 806         data = 0;
 807         if (!(flags & MIPI_DSI_MODE_NO_EOT_PACKET))
 808                 data |= DSI_EOT_PACKET_CTRL_TX_EOT_APPEND;
 809         dsi_write(msm_host, REG_DSI_EOT_PACKET_CTRL, data);
 810
 811         /* allow only ack-err-status to generate interrupt */
 812         dsi_write(msm_host, REG_DSI_ERR_INT_MASK0, 0x13ff3fe0);
 813
 814         dsi_intr_ctrl(msm_host, DSI_IRQ_MASK_ERROR, 1);
 815
 816         dsi_write(msm_host, REG_DSI_CLK_CTRL, DSI_CLK_CTRL_ENABLE_CLKS);
 817
 818         data = DSI_CTRL_CLK_EN;
 819
 820         DBG("lane number=%d", msm_host->lanes);
 821         data |= ((DSI_CTRL_LANE0 << msm_host->lanes) - DSI_CTRL_LANE0);
 822
 823         dsi_write(msm_host, REG_DSI_LANE_SWAP_CTRL,
 824                   DSI_LANE_SWAP_CTRL_DLN_SWAP_SEL(msm_host->dlane_swap));
 825
 826         if (!(flags & MIPI_DSI_CLOCK_NON_CONTINUOUS)) {
 827                 lane_ctrl = dsi_read(msm_host, REG_DSI_LANE_CTRL);
 828
 829                 if (msm_dsi_phy_set_continuous_clock(phy, enable))
 830                         lane_ctrl &= ~DSI_LANE_CTRL_HS_REQ_SEL_PHY;
 831
 832                 dsi_write(msm_host, REG_DSI_LANE_CTRL,
 833                         lane_ctrl | DSI_LANE_CTRL_CLKLN_HS_FORCE_REQUEST);
 834         }
 835
 836         data |= DSI_CTRL_ENABLE;
 837
 838         dsi_write(msm_host, REG_DSI_CTRL, data);
 839
 840         if (msm_host->cphy_mode)
 841                 dsi_write(msm_host, REG_DSI_CPHY_MODE_CTRL, BIT(0));
 842 }
 843
 844 static void dsi_update_dsc_timing(struct msm_dsi_host *msm_host, bool is_cmd_mode, u32 hdisplay)
 845 {
 846         struct drm_dsc_config *dsc = msm_host->dsc;
 847         u32 reg, reg_ctrl, reg_ctrl2;
 848         u32 slice_per_intf, total_bytes_per_intf;
 849         u32 pkt_per_line;
 850         u32 eol_byte_num;
 851
 852         /* first calculate dsc parameters and then program
 853          * compress mode registers
 854          */
 855         slice_per_intf = DIV_ROUND_UP(hdisplay, dsc->slice_width);
 856
 857         total_bytes_per_intf = dsc->slice_chunk_size * slice_per_intf;
 858
 859         eol_byte_num = total_bytes_per_intf % 3;
 860
 861         /*
 862          * Typically, pkt_per_line = slice_per_intf * slice_per_pkt.
 863          *
 864          * Since the current driver only supports slice_per_pkt = 1,
 865          * pkt_per_line will be equal to slice per intf for now.
 866          */
 867         pkt_per_line = slice_per_intf;
 868
 869         if (is_cmd_mode) /* packet data type */
 870                 reg = DSI_COMMAND_COMPRESSION_MODE_CTRL_STREAM0_DATATYPE(MIPI_DSI_DCS_LONG_WRITE);
 871         else
 872                 reg = DSI_VIDEO_COMPRESSION_MODE_CTRL_DATATYPE(MIPI_DSI_COMPRESSED_PIXEL_STREAM);
 873
 874         /* DSI_VIDEO_COMPRESSION_MODE & DSI_COMMAND_COMPRESSION_MODE
 875          * registers have similar offsets, so for below common code use
 876          * DSI_VIDEO_COMPRESSION_MODE_XXXX for setting bits
 877          */
 878         reg |= DSI_VIDEO_COMPRESSION_MODE_CTRL_PKT_PER_LINE(pkt_per_line >> 1);
 879         reg |= DSI_VIDEO_COMPRESSION_MODE_CTRL_EOL_BYTE_NUM(eol_byte_num);
 880         reg |= DSI_VIDEO_COMPRESSION_MODE_CTRL_EN;
 881
 882         if (is_cmd_mode) {
 883                 reg_ctrl = dsi_read(msm_host, REG_DSI_COMMAND_COMPRESSION_MODE_CTRL);
 884                 reg_ctrl2 = dsi_read(msm_host, REG_DSI_COMMAND_COMPRESSION_MODE_CTRL2);
 885
 886                 reg_ctrl &= ~0xffff;
 887                 reg_ctrl |= reg;
 888
 889                 reg_ctrl2 &= ~DSI_COMMAND_COMPRESSION_MODE_CTRL2_STREAM0_SLICE_WIDTH__MASK;
 890                 reg_ctrl2 |= DSI_COMMAND_COMPRESSION_MODE_CTRL2_STREAM0_SLICE_WIDTH(dsc->slice_chunk_size);
 891
 892                 dsi_write(msm_host, REG_DSI_COMMAND_COMPRESSION_MODE_CTRL, reg_ctrl);
 893                 dsi_write(msm_host, REG_DSI_COMMAND_COMPRESSION_MODE_CTRL2, reg_ctrl2);
 894         } else {
 895                 dsi_write(msm_host, REG_DSI_VIDEO_COMPRESSION_MODE_CTRL, reg);
 896         }
 897 }
 898
 899 static void dsi_timing_setup(struct msm_dsi_host *msm_host, bool is_bonded_dsi)
 900 {
 901         struct drm_display_mode *mode = msm_host->mode;
 902         u32 hs_start = 0, vs_start = 0; /* take sync start as 0 */
 903         u32 h_total = mode->htotal;
 904         u32 v_total = mode->vtotal;
 905         u32 hs_end = mode->hsync_end - mode->hsync_start;
 906         u32 vs_end = mode->vsync_end - mode->vsync_start;
 907         u32 ha_start = h_total - mode->hsync_start;
 908         u32 ha_end = ha_start + mode->hdisplay;
 909         u32 va_start = v_total - mode->vsync_start;
 910         u32 va_end = va_start + mode->vdisplay;
 911         u32 hdisplay = mode->hdisplay;
 912         u32 wc;
 913         int ret;
 914
 915         DBG("");
 916
 917         /*
 918          * For bonded DSI mode, the current DRM mode has
 919          * the complete width of the panel. Since, the complete
 920          * panel is driven by two DSI controllers, the horizontal
 921          * timings have to be split between the two dsi controllers.
 922          * Adjust the DSI host timing values accordingly.
 923          */
 924         if (is_bonded_dsi) {
 925                 h_total /= 2;
 926                 hs_end /= 2;
 927                 ha_start /= 2;
 928                 ha_end /= 2;
 929                 hdisplay /= 2;
 930         }
 931
 932         if (msm_host->dsc) {
 933                 struct drm_dsc_config *dsc = msm_host->dsc;
 934
 935                 /* update dsc params with timing params */
 936                 if (!dsc || !mode->hdisplay || !mode->vdisplay) {
 937                         pr_err("DSI: invalid input: pic_width: %d pic_height: %d\n",
 938                                mode->hdisplay, mode->vdisplay);
 939                         return;
 940                 }
 941
 942                 dsc->pic_width = mode->hdisplay;
 943                 dsc->pic_height = mode->vdisplay;
 944                 DBG("Mode %dx%d\n", dsc->pic_width, dsc->pic_height);
 945
 946                 /* we do the calculations for dsc parameters here so that
 947                  * panel can use these parameters
 948                  */
 949                 ret = dsi_populate_dsc_params(msm_host, dsc);
 950                 if (ret)
 951                         return;
 952
 953                 /* Divide the display by 3 but keep back/font porch and
 954                  * pulse width same
 955                  */
 956                 h_total -= hdisplay;
 957                 hdisplay /= 3;
 958                 h_total += hdisplay;
 959                 ha_end = ha_start + hdisplay;
 960         }
 961
 962         if (msm_host->mode_flags & MIPI_DSI_MODE_VIDEO) {
 963                 if (msm_host->dsc)
 964                         dsi_update_dsc_timing(msm_host, false, mode->hdisplay);
 965
 966                 dsi_write(msm_host, REG_DSI_ACTIVE_H,
 967                         DSI_ACTIVE_H_START(ha_start) |
 968                         DSI_ACTIVE_H_END(ha_end));
 969                 dsi_write(msm_host, REG_DSI_ACTIVE_V,
 970                         DSI_ACTIVE_V_START(va_start) |
 971                         DSI_ACTIVE_V_END(va_end));
 972                 dsi_write(msm_host, REG_DSI_TOTAL,
 973                         DSI_TOTAL_H_TOTAL(h_total - 1) |
 974                         DSI_TOTAL_V_TOTAL(v_total - 1));
 975
 976                 dsi_write(msm_host, REG_DSI_ACTIVE_HSYNC,
 977                         DSI_ACTIVE_HSYNC_START(hs_start) |
 978                         DSI_ACTIVE_HSYNC_END(hs_end));
 979                 dsi_write(msm_host, REG_DSI_ACTIVE_VSYNC_HPOS, 0);
 980                 dsi_write(msm_host, REG_DSI_ACTIVE_VSYNC_VPOS,
 981                         DSI_ACTIVE_VSYNC_VPOS_START(vs_start) |
 982                         DSI_ACTIVE_VSYNC_VPOS_END(vs_end));
 983         } else {                /* command mode */
 984                 if (msm_host->dsc)
 985                         dsi_update_dsc_timing(msm_host, true, mode->hdisplay);
 986
 987                 /* image data and 1 byte write_memory_start cmd */
 988                 if (!msm_host->dsc)
 989                         wc = hdisplay * dsi_get_bpp(msm_host->format) / 8 + 1;
 990                 else
 991                         /*
 992                          * When DSC is enabled, WC = slice_chunk_size * slice_per_pkt + 1.
 993                          * Currently, the driver only supports default value of slice_per_pkt = 1
 994                          *
 995                          * TODO: Expand mipi_dsi_device struct to hold slice_per_pkt info
 996                          *       and adjust DSC math to account for slice_per_pkt.
 997                          */
 998                         wc = msm_host->dsc->slice_chunk_size + 1;
 999
1000                 dsi_write(msm_host, REG_DSI_CMD_MDP_STREAM0_CTRL,
1001                         DSI_CMD_MDP_STREAM0_CTRL_WORD_COUNT(wc) |
1002                         DSI_CMD_MDP_STREAM0_CTRL_VIRTUAL_CHANNEL(
1003                                         msm_host->channel) |
1004                         DSI_CMD_MDP_STREAM0_CTRL_DATA_TYPE(
1005                                         MIPI_DSI_DCS_LONG_WRITE));
1006
1007                 dsi_write(msm_host, REG_DSI_CMD_MDP_STREAM0_TOTAL,
1008                         DSI_CMD_MDP_STREAM0_TOTAL_H_TOTAL(hdisplay) |
1009                         DSI_CMD_MDP_STREAM0_TOTAL_V_TOTAL(mode->vdisplay));
1010         }
1011 }
1012
1013 static void dsi_sw_reset(struct msm_dsi_host *msm_host)
1014 {
1015         u32 ctrl;
1016
1017         ctrl = dsi_read(msm_host, REG_DSI_CTRL);
1018
1019         if (ctrl & DSI_CTRL_ENABLE) {
1020                 dsi_write(msm_host, REG_DSI_CTRL, ctrl & ~DSI_CTRL_ENABLE);
1021                 /*
1022                  * dsi controller need to be disabled before
1023                  * clocks turned on
1024                  */
1025                 wmb();
1026         }
1027
1028         dsi_write(msm_host, REG_DSI_CLK_CTRL, DSI_CLK_CTRL_ENABLE_CLKS);
1029         wmb(); /* clocks need to be enabled before reset */
1030
1031         /* dsi controller can only be reset while clocks are running */
1032         dsi_write(msm_host, REG_DSI_RESET, 1);
1033         msleep(DSI_RESET_TOGGLE_DELAY_MS); /* make sure reset happen */
1034         dsi_write(msm_host, REG_DSI_RESET, 0);
1035         wmb(); /* controller out of reset */
1036
1037         if (ctrl & DSI_CTRL_ENABLE) {
1038                 dsi_write(msm_host, REG_DSI_CTRL, ctrl);
1039                 wmb();  /* make sure dsi controller enabled again */
1040         }
1041 }
1042
1043 static void dsi_op_mode_config(struct msm_dsi_host *msm_host,
1044                                         bool video_mode, bool enable)
1045 {
1046         u32 dsi_ctrl;
1047
1048         dsi_ctrl = dsi_read(msm_host, REG_DSI_CTRL);
1049
1050         if (!enable) {
1051                 dsi_ctrl &= ~(DSI_CTRL_ENABLE | DSI_CTRL_VID_MODE_EN |
1052                                 DSI_CTRL_CMD_MODE_EN);
1053                 dsi_intr_ctrl(msm_host, DSI_IRQ_MASK_CMD_MDP_DONE |
1054                                         DSI_IRQ_MASK_VIDEO_DONE, 0);
1055         } else {
1056                 if (video_mode) {
1057                         dsi_ctrl |= DSI_CTRL_VID_MODE_EN;
1058                 } else {                /* command mode */
1059                         dsi_ctrl |= DSI_CTRL_CMD_MODE_EN;
1060                         dsi_intr_ctrl(msm_host, DSI_IRQ_MASK_CMD_MDP_DONE, 1);
1061                 }
1062                 dsi_ctrl |= DSI_CTRL_ENABLE;
1063         }
1064
1065         dsi_write(msm_host, REG_DSI_CTRL, dsi_ctrl);
1066 }
1067
1068 static void dsi_set_tx_power_mode(int mode, struct msm_dsi_host *msm_host)
1069 {
1070         u32 data;
1071
1072         data = dsi_read(msm_host, REG_DSI_CMD_DMA_CTRL);
1073
1074         if (mode == 0)
1075                 data &= ~DSI_CMD_DMA_CTRL_LOW_POWER;
1076         else
1077                 data |= DSI_CMD_DMA_CTRL_LOW_POWER;
1078
1079         dsi_write(msm_host, REG_DSI_CMD_DMA_CTRL, data);
1080 }
1081
1082 static void dsi_wait4video_done(struct msm_dsi_host *msm_host)
1083 {
1084         u32 ret = 0;
1085         struct device *dev = &msm_host->pdev->dev;
1086
1087         dsi_intr_ctrl(msm_host, DSI_IRQ_MASK_VIDEO_DONE, 1);
1088
1089         reinit_completion(&msm_host->video_comp);
1090
1091         ret = wait_for_completion_timeout(&msm_host->video_comp,
1092                         msecs_to_jiffies(70));
1093
1094         if (ret == 0)
1095                 DRM_DEV_ERROR(dev, "wait for video done timed out\n");
1096
1097         dsi_intr_ctrl(msm_host, DSI_IRQ_MASK_VIDEO_DONE, 0);
1098 }
1099
1100 static void dsi_wait4video_eng_busy(struct msm_dsi_host *msm_host)
1101 {
1102         u32 data;
1103
1104         if (!(msm_host->mode_flags & MIPI_DSI_MODE_VIDEO))
1105                 return;
1106
1107         data = dsi_read(msm_host, REG_DSI_STATUS0);
1108
1109         /* if video mode engine is not busy, its because
1110          * either timing engine was not turned on or the
1111          * DSI controller has finished transmitting the video
1112          * data already, so no need to wait in those cases
1113          */
1114         if (!(data & DSI_STATUS0_VIDEO_MODE_ENGINE_BUSY))
1115                 return;
1116
1117         if (msm_host->power_on && msm_host->enabled) {
1118                 dsi_wait4video_done(msm_host);
1119                 /* delay 4 ms to skip BLLP */
1120                 usleep_range(2000, 4000);
1121         }
1122 }
1123
1124 int dsi_tx_buf_alloc_6g(struct msm_dsi_host *msm_host, int size)
1125 {
1126         struct drm_device *dev = msm_host->dev;
1127         struct msm_drm_private *priv = dev->dev_private;
1128         uint64_t iova;
1129         u8 *data;
1130
1131         msm_host->aspace = msm_gem_address_space_get(priv->kms->aspace);
1132
1133         data = msm_gem_kernel_new(dev, size, MSM_BO_WC,
1134                                         msm_host->aspace,
1135                                         &msm_host->tx_gem_obj, &iova);
1136
1137         if (IS_ERR(data)) {
1138                 msm_host->tx_gem_obj = NULL;
1139                 return PTR_ERR(data);
1140         }
1141
1142         msm_gem_object_set_name(msm_host->tx_gem_obj, "tx_gem");
1143
1144         msm_host->tx_size = msm_host->tx_gem_obj->size;
1145
1146         return 0;
1147 }
1148
1149 int dsi_tx_buf_alloc_v2(struct msm_dsi_host *msm_host, int size)
1150 {
1151         struct drm_device *dev = msm_host->dev;
1152
1153         msm_host->tx_buf = dma_alloc_coherent(dev->dev, size,
1154                                         &msm_host->tx_buf_paddr, GFP_KERNEL);
1155         if (!msm_host->tx_buf)
1156                 return -ENOMEM;
1157
1158         msm_host->tx_size = size;
1159
1160         return 0;
1161 }
1162
1163 void msm_dsi_tx_buf_free(struct mipi_dsi_host *host)
1164 {
1165         struct msm_dsi_host *msm_host = to_msm_dsi_host(host);
1166         struct drm_device *dev = msm_host->dev;
1167
1168         /*
1169          * This is possible if we're tearing down before we've had a chance to
1170          * fully initialize. A very real possibility if our probe is deferred,
1171          * in which case we'll hit msm_dsi_host_destroy() without having run
1172          * through the dsi_tx_buf_alloc().
1173          */
1174         if (!dev)
1175                 return;
1176
1177         if (msm_host->tx_gem_obj) {
1178                 msm_gem_kernel_put(msm_host->tx_gem_obj, msm_host->aspace);
1179                 msm_gem_address_space_put(msm_host->aspace);
1180                 msm_host->tx_gem_obj = NULL;
1181                 msm_host->aspace = NULL;
1182         }
1183
1184         if (msm_host->tx_buf)
1185                 dma_free_coherent(dev->dev, msm_host->tx_size, msm_host->tx_buf,
1186                         msm_host->tx_buf_paddr);
1187 }
1188
1189 void *dsi_tx_buf_get_6g(struct msm_dsi_host *msm_host)
1190 {
1191         return msm_gem_get_vaddr(msm_host->tx_gem_obj);
1192 }
1193
1194 void *dsi_tx_buf_get_v2(struct msm_dsi_host *msm_host)
1195 {
1196         return msm_host->tx_buf;
1197 }
1198
1199 void dsi_tx_buf_put_6g(struct msm_dsi_host *msm_host)
1200 {
1201         msm_gem_put_vaddr(msm_host->tx_gem_obj);
1202 }
1203
1204 /*
1205  * prepare cmd buffer to be txed
1206  */
1207 static int dsi_cmd_dma_add(struct msm_dsi_host *msm_host,
1208                            const struct mipi_dsi_msg *msg)
1209 {
1210         const struct msm_dsi_cfg_handler *cfg_hnd = msm_host->cfg_hnd;
1211         struct mipi_dsi_packet packet;
1212         int len;
1213         int ret;
1214         u8 *data;
1215
1216         ret = mipi_dsi_create_packet(&packet, msg);
1217         if (ret) {
1218                 pr_err("%s: create packet failed, %d\n", __func__, ret);
1219                 return ret;
1220         }
1221         len = (packet.size + 3) & (~0x3);
1222
1223         if (len > msm_host->tx_size) {
1224                 pr_err("%s: packet size is too big\n", __func__);
1225                 return -EINVAL;
1226         }
1227
1228         data = cfg_hnd->ops->tx_buf_get(msm_host);
1229         if (IS_ERR(data)) {
1230                 ret = PTR_ERR(data);
1231                 pr_err("%s: get vaddr failed, %d\n", __func__, ret);
1232                 return ret;
1233         }
1234
1235         /* MSM specific command format in memory */
1236         data[0] = packet.header[1];
1237         data[1] = packet.header[2];
1238         data[2] = packet.header[0];
1239         data[3] = BIT(7); /* Last packet */
1240         if (mipi_dsi_packet_format_is_long(msg->type))
1241                 data[3] |= BIT(6);
1242         if (msg->rx_buf && msg->rx_len)
1243                 data[3] |= BIT(5);
1244
1245         /* Long packet */
1246         if (packet.payload && packet.payload_length)
1247                 memcpy(data + 4, packet.payload, packet.payload_length);
1248
1249         /* Append 0xff to the end */
1250         if (packet.size < len)
1251                 memset(data + packet.size, 0xff, len - packet.size);
1252
1253         if (cfg_hnd->ops->tx_buf_put)
1254                 cfg_hnd->ops->tx_buf_put(msm_host);
1255
1256         return len;
1257 }
1258
1259 /*
1260  * dsi_short_read1_resp: 1 parameter
1261  */
1262 static int dsi_short_read1_resp(u8 *buf, const struct mipi_dsi_msg *msg)
1263 {
1264         u8 *data = msg->rx_buf;
1265         if (data && (msg->rx_len >= 1)) {
1266                 *data = buf[1]; /* strip out dcs type */
1267                 return 1;
1268         } else {
1269                 pr_err("%s: read data does not match with rx_buf len %zu\n",
1270                         __func__, msg->rx_len);
1271                 return -EINVAL;
1272         }
1273 }
1274
1275 /*
1276  * dsi_short_read2_resp: 2 parameter
1277  */
1278 static int dsi_short_read2_resp(u8 *buf, const struct mipi_dsi_msg *msg)
1279 {
1280         u8 *data = msg->rx_buf;
1281         if (data && (msg->rx_len >= 2)) {
1282                 data[0] = buf[1]; /* strip out dcs type */
1283                 data[1] = buf[2];
1284                 return 2;
1285         } else {
1286                 pr_err("%s: read data does not match with rx_buf len %zu\n",
1287                         __func__, msg->rx_len);
1288                 return -EINVAL;
1289         }
1290 }
1291
1292 static int dsi_long_read_resp(u8 *buf, const struct mipi_dsi_msg *msg)
1293 {
1294         /* strip out 4 byte dcs header */
1295         if (msg->rx_buf && msg->rx_len)
1296                 memcpy(msg->rx_buf, buf + 4, msg->rx_len);
1297
1298         return msg->rx_len;
1299 }
1300
1301 int dsi_dma_base_get_6g(struct msm_dsi_host *msm_host, uint64_t *dma_base)
1302 {
1303         struct drm_device *dev = msm_host->dev;
1304         struct msm_drm_private *priv = dev->dev_private;
1305
1306         if (!dma_base)
1307                 return -EINVAL;
1308
1309         return msm_gem_get_and_pin_iova(msm_host->tx_gem_obj,
1310                                 priv->kms->aspace, dma_base);
1311 }
1312
1313 int dsi_dma_base_get_v2(struct msm_dsi_host *msm_host, uint64_t *dma_base)
1314 {
1315         if (!dma_base)
1316                 return -EINVAL;
1317
1318         *dma_base = msm_host->tx_buf_paddr;
1319         return 0;
1320 }
1321
1322 static int dsi_cmd_dma_tx(struct msm_dsi_host *msm_host, int len)
1323 {
1324         const struct msm_dsi_cfg_handler *cfg_hnd = msm_host->cfg_hnd;
1325         int ret;
1326         uint64_t dma_base;
1327         bool triggered;
1328
1329         ret = cfg_hnd->ops->dma_base_get(msm_host, &dma_base);
1330         if (ret) {
1331                 pr_err("%s: failed to get iova: %d\n", __func__, ret);
1332                 return ret;
1333         }
1334
1335         reinit_completion(&msm_host->dma_comp);
1336
1337         dsi_wait4video_eng_busy(msm_host);
1338
1339         triggered = msm_dsi_manager_cmd_xfer_trigger(
1340                                                 msm_host->id, dma_base, len);
1341         if (triggered) {
1342                 ret = wait_for_completion_timeout(&msm_host->dma_comp,
1343                                         msecs_to_jiffies(200));
1344                 DBG("ret=%d", ret);
1345                 if (ret == 0)
1346                         ret = -ETIMEDOUT;
1347                 else
1348                         ret = len;
1349         } else
1350                 ret = len;
1351
1352         return ret;
1353 }
1354
1355 static int dsi_cmd_dma_rx(struct msm_dsi_host *msm_host,
1356                         u8 *buf, int rx_byte, int pkt_size)
1357 {
1358         u32 *temp, data;
1359         int i, j = 0, cnt;
1360         u32 read_cnt;
1361         u8 reg[16];
1362         int repeated_bytes = 0;
1363         int buf_offset = buf - msm_host->rx_buf;
1364
1365         temp = (u32 *)reg;
1366         cnt = (rx_byte + 3) >> 2;
1367         if (cnt > 4)
1368                 cnt = 4; /* 4 x 32 bits registers only */
1369
1370         if (rx_byte == 4)
1371                 read_cnt = 4;
1372         else
1373                 read_cnt = pkt_size + 6;
1374
1375         /*
1376          * In case of multiple reads from the panel, after the first read, there
1377          * is possibility that there are some bytes in the payload repeating in
1378          * the RDBK_DATA registers. Since we read all the parameters from the
1379          * panel right from the first byte for every pass. We need to skip the
1380          * repeating bytes and then append the new parameters to the rx buffer.
1381          */
1382         if (read_cnt > 16) {
1383                 int bytes_shifted;
1384                 /* Any data more than 16 bytes will be shifted out.
1385                  * The temp read buffer should already contain these bytes.
1386                  * The remaining bytes in read buffer are the repeated bytes.
1387                  */
1388                 bytes_shifted = read_cnt - 16;
1389                 repeated_bytes = buf_offset - bytes_shifted;
1390         }
1391
1392         for (i = cnt - 1; i >= 0; i--) {
1393                 data = dsi_read(msm_host, REG_DSI_RDBK_DATA(i));
1394                 *temp++ = ntohl(data); /* to host byte order */
1395                 DBG("data = 0x%x and ntohl(data) = 0x%x", data, ntohl(data));
1396         }
1397
1398         for (i = repeated_bytes; i < 16; i++)
1399                 buf[j++] = reg[i];
1400
1401         return j;
1402 }
1403
1404 static int dsi_cmds2buf_tx(struct msm_dsi_host *msm_host,
1405                                 const struct mipi_dsi_msg *msg)
1406 {
1407         int len, ret;
1408         int bllp_len = msm_host->mode->hdisplay *
1409                         dsi_get_bpp(msm_host->format) / 8;
1410
1411         len = dsi_cmd_dma_add(msm_host, msg);
1412         if (len < 0) {
1413                 pr_err("%s: failed to add cmd type = 0x%x\n",
1414                         __func__,  msg->type);
1415                 return len;
1416         }
1417
1418         /* for video mode, do not send cmds more than
1419         * one pixel line, since it only transmit it
1420         * during BLLP.
1421         */
1422         /* TODO: if the command is sent in LP mode, the bit rate is only
1423          * half of esc clk rate. In this case, if the video is already
1424          * actively streaming, we need to check more carefully if the
1425          * command can be fit into one BLLP.
1426          */
1427         if ((msm_host->mode_flags & MIPI_DSI_MODE_VIDEO) && (len > bllp_len)) {
1428                 pr_err("%s: cmd cannot fit into BLLP period, len=%d\n",
1429                         __func__, len);
1430                 return -EINVAL;
1431         }
1432
1433         ret = dsi_cmd_dma_tx(msm_host, len);
1434         if (ret < 0) {
1435                 pr_err("%s: cmd dma tx failed, type=0x%x, data0=0x%x, len=%d, ret=%d\n",
1436                         __func__, msg->type, (*(u8 *)(msg->tx_buf)), len, ret);
1437                 return ret;
1438         } else if (ret < len) {
1439                 pr_err("%s: cmd dma tx failed, type=0x%x, data0=0x%x, ret=%d len=%d\n",
1440                         __func__, msg->type, (*(u8 *)(msg->tx_buf)), ret, len);
1441                 return -EIO;
1442         }
1443
1444         return len;
1445 }
1446
1447 static void dsi_err_worker(struct work_struct *work)
1448 {
1449         struct msm_dsi_host *msm_host =
1450                 container_of(work, struct msm_dsi_host, err_work);
1451         u32 status = msm_host->err_work_state;
1452
1453         pr_err_ratelimited("%s: status=%x\n", __func__, status);
1454         if (status & DSI_ERR_STATE_MDP_FIFO_UNDERFLOW)
1455                 dsi_sw_reset(msm_host);
1456
1457         /* It is safe to clear here because error irq is disabled. */
1458         msm_host->err_work_state = 0;
1459
1460         /* enable dsi error interrupt */
1461         dsi_intr_ctrl(msm_host, DSI_IRQ_MASK_ERROR, 1);
1462 }
1463
1464 static void dsi_ack_err_status(struct msm_dsi_host *msm_host)
1465 {
1466         u32 status;
1467
1468         status = dsi_read(msm_host, REG_DSI_ACK_ERR_STATUS);
1469
1470         if (status) {
1471                 dsi_write(msm_host, REG_DSI_ACK_ERR_STATUS, status);
1472                 /* Writing of an extra 0 needed to clear error bits */
1473                 dsi_write(msm_host, REG_DSI_ACK_ERR_STATUS, 0);
1474                 msm_host->err_work_state |= DSI_ERR_STATE_ACK;
1475         }
1476 }
1477
1478 static void dsi_timeout_status(struct msm_dsi_host *msm_host)
1479 {
1480         u32 status;
1481
1482         status = dsi_read(msm_host, REG_DSI_TIMEOUT_STATUS);
1483
1484         if (status) {
1485                 dsi_write(msm_host, REG_DSI_TIMEOUT_STATUS, status);
1486                 msm_host->err_work_state |= DSI_ERR_STATE_TIMEOUT;
1487         }
1488 }
1489
1490 static void dsi_dln0_phy_err(struct msm_dsi_host *msm_host)
1491 {
1492         u32 status;
1493
1494         status = dsi_read(msm_host, REG_DSI_DLN0_PHY_ERR);
1495
1496         if (status & (DSI_DLN0_PHY_ERR_DLN0_ERR_ESC |
1497                         DSI_DLN0_PHY_ERR_DLN0_ERR_SYNC_ESC |
1498                         DSI_DLN0_PHY_ERR_DLN0_ERR_CONTROL |
1499                         DSI_DLN0_PHY_ERR_DLN0_ERR_CONTENTION_LP0 |
1500                         DSI_DLN0_PHY_ERR_DLN0_ERR_CONTENTION_LP1)) {
1501                 dsi_write(msm_host, REG_DSI_DLN0_PHY_ERR, status);
1502                 msm_host->err_work_state |= DSI_ERR_STATE_DLN0_PHY;
1503         }
1504 }
1505
1506 static void dsi_fifo_status(struct msm_dsi_host *msm_host)
1507 {
1508         u32 status;
1509
1510         status = dsi_read(msm_host, REG_DSI_FIFO_STATUS);
1511
1512         /* fifo underflow, overflow */
1513         if (status) {
1514                 dsi_write(msm_host, REG_DSI_FIFO_STATUS, status);
1515                 msm_host->err_work_state |= DSI_ERR_STATE_FIFO;
1516                 if (status & DSI_FIFO_STATUS_CMD_MDP_FIFO_UNDERFLOW)
1517                         msm_host->err_work_state |=
1518                                         DSI_ERR_STATE_MDP_FIFO_UNDERFLOW;
1519         }
1520 }
1521
1522 static void dsi_status(struct msm_dsi_host *msm_host)
1523 {
1524         u32 status;
1525
1526         status = dsi_read(msm_host, REG_DSI_STATUS0);
1527
1528         if (status & DSI_STATUS0_INTERLEAVE_OP_CONTENTION) {
1529                 dsi_write(msm_host, REG_DSI_STATUS0, status);
1530                 msm_host->err_work_state |=
1531                         DSI_ERR_STATE_INTERLEAVE_OP_CONTENTION;
1532         }
1533 }
1534
1535 static void dsi_clk_status(struct msm_dsi_host *msm_host)
1536 {
1537         u32 status;
1538
1539         status = dsi_read(msm_host, REG_DSI_CLK_STATUS);
1540
1541         if (status & DSI_CLK_STATUS_PLL_UNLOCKED) {
1542                 dsi_write(msm_host, REG_DSI_CLK_STATUS, status);
1543                 msm_host->err_work_state |= DSI_ERR_STATE_PLL_UNLOCKED;
1544         }
1545 }
1546
1547 static void dsi_error(struct msm_dsi_host *msm_host)
1548 {
1549         /* disable dsi error interrupt */
1550         dsi_intr_ctrl(msm_host, DSI_IRQ_MASK_ERROR, 0);
1551
1552         dsi_clk_status(msm_host);
1553         dsi_fifo_status(msm_host);
1554         dsi_ack_err_status(msm_host);
1555         dsi_timeout_status(msm_host);
1556         dsi_status(msm_host);
1557         dsi_dln0_phy_err(msm_host);
1558
1559         queue_work(msm_host->workqueue, &msm_host->err_work);
1560 }
1561
1562 static irqreturn_t dsi_host_irq(int irq, void *ptr)
1563 {
1564         struct msm_dsi_host *msm_host = ptr;
1565         u32 isr;
1566         unsigned long flags;
1567
1568         if (!msm_host->ctrl_base)
1569                 return IRQ_HANDLED;
1570
1571         spin_lock_irqsave(&msm_host->intr_lock, flags);
1572         isr = dsi_read(msm_host, REG_DSI_INTR_CTRL);
1573         dsi_write(msm_host, REG_DSI_INTR_CTRL, isr);
1574         spin_unlock_irqrestore(&msm_host->intr_lock, flags);
1575
1576         DBG("isr=0x%x, id=%d", isr, msm_host->id);
1577
1578         if (isr & DSI_IRQ_ERROR)
1579                 dsi_error(msm_host);
1580
1581         if (isr & DSI_IRQ_VIDEO_DONE)
1582                 complete(&msm_host->video_comp);
1583
1584         if (isr & DSI_IRQ_CMD_DMA_DONE)
1585                 complete(&msm_host->dma_comp);
1586
1587         return IRQ_HANDLED;
1588 }
1589
1590 static int dsi_host_init_panel_gpios(struct msm_dsi_host *msm_host,
1591                         struct device *panel_device)
1592 {
1593         msm_host->disp_en_gpio = devm_gpiod_get_optional(panel_device,
1594                                                          "disp-enable",
1595                                                          GPIOD_OUT_LOW);
1596         if (IS_ERR(msm_host->disp_en_gpio)) {
1597                 DBG("cannot get disp-enable-gpios %ld",
1598                                 PTR_ERR(msm_host->disp_en_gpio));
1599                 return PTR_ERR(msm_host->disp_en_gpio);
1600         }
1601
1602         msm_host->te_gpio = devm_gpiod_get_optional(panel_device, "disp-te",
1603                                                                 GPIOD_IN);
1604         if (IS_ERR(msm_host->te_gpio)) {
1605                 DBG("cannot get disp-te-gpios %ld", PTR_ERR(msm_host->te_gpio));
1606                 return PTR_ERR(msm_host->te_gpio);
1607         }
1608
1609         return 0;
1610 }
1611
1612 static int dsi_host_attach(struct mipi_dsi_host *host,
1613                                         struct mipi_dsi_device *dsi)
1614 {
1615         struct msm_dsi_host *msm_host = to_msm_dsi_host(host);
1616         int ret;
1617
1618         if (dsi->lanes > msm_host->num_data_lanes)
1619                 return -EINVAL;
1620
1621         msm_host->channel = dsi->channel;
1622         msm_host->lanes = dsi->lanes;
1623         msm_host->format = dsi->format;
1624         msm_host->mode_flags = dsi->mode_flags;
1625         if (dsi->dsc)
1626                 msm_host->dsc = dsi->dsc;
1627
1628         /* Some gpios defined in panel DT need to be controlled by host */
1629         ret = dsi_host_init_panel_gpios(msm_host, &dsi->dev);
1630         if (ret)
1631                 return ret;
1632
1633         ret = dsi_dev_attach(msm_host->pdev);
1634         if (ret)
1635                 return ret;
1636
1637         DBG("id=%d", msm_host->id);
1638
1639         return 0;
1640 }
1641
1642 static int dsi_host_detach(struct mipi_dsi_host *host,
1643                                         struct mipi_dsi_device *dsi)
1644 {
1645         struct msm_dsi_host *msm_host = to_msm_dsi_host(host);
1646
1647         dsi_dev_detach(msm_host->pdev);
1648
1649         DBG("id=%d", msm_host->id);
1650
1651         return 0;
1652 }
1653
1654 static ssize_t dsi_host_transfer(struct mipi_dsi_host *host,
1655                                         const struct mipi_dsi_msg *msg)
1656 {
1657         struct msm_dsi_host *msm_host = to_msm_dsi_host(host);
1658         int ret;
1659
1660         if (!msg || !msm_host->power_on)
1661                 return -EINVAL;
1662
1663         mutex_lock(&msm_host->cmd_mutex);
1664         ret = msm_dsi_manager_cmd_xfer(msm_host->id, msg);
1665         mutex_unlock(&msm_host->cmd_mutex);
1666
1667         return ret;
1668 }
1669
1670 static const struct mipi_dsi_host_ops dsi_host_ops = {
1671         .attach = dsi_host_attach,
1672         .detach = dsi_host_detach,
1673         .transfer = dsi_host_transfer,
1674 };
1675
1676 /*
1677  * List of supported physical to logical lane mappings.
1678  * For example, the 2nd entry represents the following mapping:
1679  *
1680  * "3012": Logic 3->Phys 0; Logic 0->Phys 1; Logic 1->Phys 2; Logic 2->Phys 3;
1681  */
1682 static const int supported_data_lane_swaps[][4] = {
1683         { 0, 1, 2, 3 },
1684         { 3, 0, 1, 2 },
1685         { 2, 3, 0, 1 },
1686         { 1, 2, 3, 0 },
1687         { 0, 3, 2, 1 },
1688         { 1, 0, 3, 2 },
1689         { 2, 1, 0, 3 },
1690         { 3, 2, 1, 0 },
1691 };
1692
1693 static int dsi_host_parse_lane_data(struct msm_dsi_host *msm_host,
1694                                     struct device_node *ep)
1695 {
1696         struct device *dev = &msm_host->pdev->dev;
1697         struct property *prop;
1698         u32 lane_map[4];
1699         int ret, i, len, num_lanes;
1700
1701         prop = of_find_property(ep, "data-lanes", &len);
1702         if (!prop) {
1703                 DRM_DEV_DEBUG(dev,
1704                         "failed to find data lane mapping, using default\n");
1705                 /* Set the number of date lanes to 4 by default. */
1706                 msm_host->num_data_lanes = 4;
1707                 return 0;
1708         }
1709
1710         num_lanes = drm_of_get_data_lanes_count(ep, 1, 4);
1711         if (num_lanes < 0) {
1712                 DRM_DEV_ERROR(dev, "bad number of data lanes\n");
1713                 return num_lanes;
1714         }
1715
1716         msm_host->num_data_lanes = num_lanes;
1717
1718         ret = of_property_read_u32_array(ep, "data-lanes", lane_map,
1719                                          num_lanes);
1720         if (ret) {
1721                 DRM_DEV_ERROR(dev, "failed to read lane data\n");
1722                 return ret;
1723         }
1724
1725         /*
1726          * compare DT specified physical-logical lane mappings with the ones
1727          * supported by hardware
1728          */
1729         for (i = 0; i < ARRAY_SIZE(supported_data_lane_swaps); i++) {
1730                 const int *swap = supported_data_lane_swaps[i];
1731                 int j;
1732
1733                 /*
1734                  * the data-lanes array we get from DT has a logical->physical
1735                  * mapping. The "data lane swap" register field represents
1736                  * supported configurations in a physical->logical mapping.
1737                  * Translate the DT mapping to what we understand and find a
1738                  * configuration that works.
1739                  */
1740                 for (j = 0; j < num_lanes; j++) {
1741                         if (lane_map[j] < 0 || lane_map[j] > 3)
1742                                 DRM_DEV_ERROR(dev, "bad physical lane entry %u\n",
1743                                         lane_map[j]);
1744
1745                         if (swap[lane_map[j]] != j)
1746                                 break;
1747                 }
1748
1749                 if (j == num_lanes) {
1750                         msm_host->dlane_swap = i;
1751                         return 0;
1752                 }
1753         }
1754
1755         return -EINVAL;
1756 }
1757
1758 static u32 dsi_dsc_rc_buf_thresh[DSC_NUM_BUF_RANGES - 1] = {
1759         0x0e, 0x1c, 0x2a, 0x38, 0x46, 0x54, 0x62,
1760         0x69, 0x70, 0x77, 0x79, 0x7b, 0x7d, 0x7e
1761 };
1762
1763 /* only 8bpc, 8bpp added */
1764 static char min_qp[DSC_NUM_BUF_RANGES] = {
1765         0, 0, 1, 1, 3, 3, 3, 3, 3, 3, 5, 5, 5, 7, 13
1766 };
1767
1768 static char max_qp[DSC_NUM_BUF_RANGES] = {
1769         4, 4, 5, 6, 7, 7, 7, 8, 9, 10, 11, 12, 13, 13, 15
1770 };
1771
1772 static char bpg_offset[DSC_NUM_BUF_RANGES] = {
1773         2, 0, 0, -2, -4, -6, -8, -8, -8, -10, -10, -12, -12, -12, -12
1774 };
1775
1776 static int dsi_populate_dsc_params(struct msm_dsi_host *msm_host, struct drm_dsc_config *dsc)
1777 {
1778         int i;
1779         u16 bpp = dsc->bits_per_pixel >> 4;
1780
1781         if (dsc->bits_per_pixel & 0xf) {
1782                 DRM_DEV_ERROR(&msm_host->pdev->dev, "DSI does not support fractional bits_per_pixel\n");
1783                 return -EINVAL;
1784         }
1785
1786         if (dsc->bits_per_component != 8) {
1787                 DRM_DEV_ERROR(&msm_host->pdev->dev, "DSI does not support bits_per_component != 8 yet\n");
1788                 return -EOPNOTSUPP;
1789         }
1790
1791         dsc->rc_model_size = 8192;
1792         dsc->first_line_bpg_offset = 12;
1793         dsc->rc_edge_factor = 6;
1794         dsc->rc_tgt_offset_high = 3;
1795         dsc->rc_tgt_offset_low = 3;
1796         dsc->simple_422 = 0;
1797         dsc->convert_rgb = 1;
1798         dsc->vbr_enable = 0;
1799
1800         /* handle only bpp = bpc = 8 */
1801         for (i = 0; i < DSC_NUM_BUF_RANGES - 1 ; i++)
1802                 dsc->rc_buf_thresh[i] = dsi_dsc_rc_buf_thresh[i];
1803
1804         for (i = 0; i < DSC_NUM_BUF_RANGES; i++) {
1805                 dsc->rc_range_params[i].range_min_qp = min_qp[i];
1806                 dsc->rc_range_params[i].range_max_qp = max_qp[i];
1807                 /*
1808                  * Range BPG Offset contains two's-complement signed values that fill
1809                  * 8 bits, yet the registers and DCS PPS field are only 6 bits wide.
1810                  */
1811                 dsc->rc_range_params[i].range_bpg_offset = bpg_offset[i] & DSC_RANGE_BPG_OFFSET_MASK;
1812         }
1813
1814         dsc->initial_offset = 6144;             /* Not bpp 12 */
1815         if (bpp != 8)
1816                 dsc->initial_offset = 2048;     /* bpp = 12 */
1817
1818         if (dsc->bits_per_component <= 10)
1819                 dsc->mux_word_size = DSC_MUX_WORD_SIZE_8_10_BPC;
1820         else
1821                 dsc->mux_word_size = DSC_MUX_WORD_SIZE_12_BPC;
1822
1823         dsc->initial_xmit_delay = 512;
1824         dsc->initial_scale_value = 32;
1825         dsc->first_line_bpg_offset = 12;
1826         dsc->line_buf_depth = dsc->bits_per_component + 1;
1827
1828         /* bpc 8 */
1829         dsc->flatness_min_qp = 3;
1830         dsc->flatness_max_qp = 12;
1831         dsc->rc_quant_incr_limit0 = 11;
1832         dsc->rc_quant_incr_limit1 = 11;
1833
1834         return drm_dsc_compute_rc_parameters(dsc);
1835 }
1836
1837 static int dsi_host_parse_dt(struct msm_dsi_host *msm_host)
1838 {
1839         struct device *dev = &msm_host->pdev->dev;
1840         struct device_node *np = dev->of_node;
1841         struct device_node *endpoint;
1842         int ret = 0;
1843
1844         /*
1845          * Get the endpoint of the output port of the DSI host. In our case,
1846          * this is mapped to port number with reg = 1. Don't return an error if
1847          * the remote endpoint isn't defined. It's possible that there is
1848          * nothing connected to the dsi output.
1849          */
1850         endpoint = of_graph_get_endpoint_by_regs(np, 1, -1);
1851         if (!endpoint) {
1852                 DRM_DEV_DEBUG(dev, "%s: no endpoint\n", __func__);
1853                 return 0;
1854         }
1855
1856         ret = dsi_host_parse_lane_data(msm_host, endpoint);
1857         if (ret) {
1858                 DRM_DEV_ERROR(dev, "%s: invalid lane configuration %d\n",
1859                         __func__, ret);
1860                 ret = -EINVAL;
1861                 goto err;
1862         }
1863
1864         if (of_property_read_bool(np, "syscon-sfpb")) {
1865                 msm_host->sfpb = syscon_regmap_lookup_by_phandle(np,
1866                                         "syscon-sfpb");
1867                 if (IS_ERR(msm_host->sfpb)) {
1868                         DRM_DEV_ERROR(dev, "%s: failed to get sfpb regmap\n",
1869                                 __func__);
1870                         ret = PTR_ERR(msm_host->sfpb);
1871                 }
1872         }
1873
1874 err:
1875         of_node_put(endpoint);
1876
1877         return ret;
1878 }
1879
1880 static int dsi_host_get_id(struct msm_dsi_host *msm_host)
1881 {
1882         struct platform_device *pdev = msm_host->pdev;
1883         const struct msm_dsi_config *cfg = msm_host->cfg_hnd->cfg;
1884         struct resource *res;
1885         int i;
1886
1887         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "dsi_ctrl");
1888         if (!res)
1889                 return -EINVAL;
1890
1891         for (i = 0; i < cfg->num_dsi; i++) {
1892                 if (cfg->io_start[i] == res->start)
1893                         return i;
1894         }
1895
1896         return -EINVAL;
1897 }
1898
1899 int msm_dsi_host_init(struct msm_dsi *msm_dsi)
1900 {
1901         struct msm_dsi_host *msm_host = NULL;
1902         struct platform_device *pdev = msm_dsi->pdev;
1903         const struct msm_dsi_config *cfg;
1904         int ret;
1905
1906         msm_host = devm_kzalloc(&pdev->dev, sizeof(*msm_host), GFP_KERNEL);
1907         if (!msm_host) {
1908                 ret = -ENOMEM;
1909                 goto fail;
1910         }
1911
1912         msm_host->pdev = pdev;
1913         msm_dsi->host = &msm_host->base;
1914
1915         ret = dsi_host_parse_dt(msm_host);
1916         if (ret) {
1917                 pr_err("%s: failed to parse dt\n", __func__);
1918                 goto fail;
1919         }
1920
1921         msm_host->ctrl_base = msm_ioremap_size(pdev, "dsi_ctrl", &msm_host->ctrl_size);
1922         if (IS_ERR(msm_host->ctrl_base)) {
1923                 pr_err("%s: unable to map Dsi ctrl base\n", __func__);
1924                 ret = PTR_ERR(msm_host->ctrl_base);
1925                 goto fail;
1926         }
1927
1928         pm_runtime_enable(&pdev->dev);
1929
1930         msm_host->cfg_hnd = dsi_get_config(msm_host);
1931         if (!msm_host->cfg_hnd) {
1932                 ret = -EINVAL;
1933                 pr_err("%s: get config failed\n", __func__);
1934                 goto fail;
1935         }
1936         cfg = msm_host->cfg_hnd->cfg;
1937
1938         msm_host->id = dsi_host_get_id(msm_host);
1939         if (msm_host->id < 0) {
1940                 ret = msm_host->id;
1941                 pr_err("%s: unable to identify DSI host index\n", __func__);
1942                 goto fail;
1943         }
1944
1945         /* fixup base address by io offset */
1946         msm_host->ctrl_base += cfg->io_offset;
1947
1948         ret = devm_regulator_bulk_get_const(&pdev->dev, cfg->num_regulators,
1949                                             cfg->regulator_data,
1950                                             &msm_host->supplies);
1951         if (ret)
1952                 goto fail;
1953
1954         ret = dsi_clk_init(msm_host);
1955         if (ret) {
1956                 pr_err("%s: unable to initialize dsi clks\n", __func__);
1957                 goto fail;
1958         }
1959
1960         msm_host->rx_buf = devm_kzalloc(&pdev->dev, SZ_4K, GFP_KERNEL);
1961         if (!msm_host->rx_buf) {
1962                 ret = -ENOMEM;
1963                 pr_err("%s: alloc rx temp buf failed\n", __func__);
1964                 goto fail;
1965         }
1966
1967         ret = devm_pm_opp_set_clkname(&pdev->dev, "byte");
1968         if (ret)
1969                 return ret;
1970         /* OPP table is optional */
1971         ret = devm_pm_opp_of_add_table(&pdev->dev);
1972         if (ret && ret != -ENODEV) {
1973                 dev_err(&pdev->dev, "invalid OPP table in device tree\n");
1974                 return ret;
1975         }
1976
1977         msm_host->irq = irq_of_parse_and_map(pdev->dev.of_node, 0);
1978         if (!msm_host->irq) {
1979                 dev_err(&pdev->dev, "failed to get irq\n");
1980                 return -EINVAL;
1981         }
1982
1983         /* do not autoenable, will be enabled later */
1984         ret = devm_request_irq(&pdev->dev, msm_host->irq, dsi_host_irq,
1985                         IRQF_TRIGGER_HIGH | IRQF_NO_AUTOEN,
1986                         "dsi_isr", msm_host);
1987         if (ret < 0) {
1988                 dev_err(&pdev->dev, "failed to request IRQ%u: %d\n",
1989                                 msm_host->irq, ret);
1990                 return ret;
1991         }
1992
1993         init_completion(&msm_host->dma_comp);
1994         init_completion(&msm_host->video_comp);
1995         mutex_init(&msm_host->dev_mutex);
1996         mutex_init(&msm_host->cmd_mutex);
1997         spin_lock_init(&msm_host->intr_lock);
1998
1999         /* setup workqueue */
2000         msm_host->workqueue = alloc_ordered_workqueue("dsi_drm_work", 0);
2001         if (!msm_host->workqueue)
2002                 return -ENOMEM;
2003
2004         INIT_WORK(&msm_host->err_work, dsi_err_worker);
2005
2006         msm_dsi->id = msm_host->id;
2007
2008         DBG("Dsi Host %d initialized", msm_host->id);
2009         return 0;
2010
2011 fail:
2012         return ret;
2013 }
2014
2015 void msm_dsi_host_destroy(struct mipi_dsi_host *host)
2016 {
2017         struct msm_dsi_host *msm_host = to_msm_dsi_host(host);
2018
2019         DBG("");
2020         if (msm_host->workqueue) {
2021                 destroy_workqueue(msm_host->workqueue);
2022                 msm_host->workqueue = NULL;
2023         }
2024
2025         mutex_destroy(&msm_host->cmd_mutex);
2026         mutex_destroy(&msm_host->dev_mutex);
2027
2028         pm_runtime_disable(&msm_host->pdev->dev);
2029 }
2030
2031 int msm_dsi_host_modeset_init(struct mipi_dsi_host *host,
2032                                         struct drm_device *dev)
2033 {
2034         struct msm_dsi_host *msm_host = to_msm_dsi_host(host);
2035         const struct msm_dsi_cfg_handler *cfg_hnd = msm_host->cfg_hnd;
2036         int ret;
2037
2038         msm_host->dev = dev;
2039
2040         ret = cfg_hnd->ops->tx_buf_alloc(msm_host, SZ_4K);
2041         if (ret) {
2042                 pr_err("%s: alloc tx gem obj failed, %d\n", __func__, ret);
2043                 return ret;
2044         }
2045
2046         return 0;
2047 }
2048
2049 int msm_dsi_host_register(struct mipi_dsi_host *host)
2050 {
2051         struct msm_dsi_host *msm_host = to_msm_dsi_host(host);
2052         int ret;
2053
2054         /* Register mipi dsi host */
2055         if (!msm_host->registered) {
2056                 host->dev = &msm_host->pdev->dev;
2057                 host->ops = &dsi_host_ops;
2058                 ret = mipi_dsi_host_register(host);
2059                 if (ret)
2060                         return ret;
2061
2062                 msm_host->registered = true;
2063         }
2064
2065         return 0;
2066 }
2067
2068 void msm_dsi_host_unregister(struct mipi_dsi_host *host)
2069 {
2070         struct msm_dsi_host *msm_host = to_msm_dsi_host(host);
2071
2072         if (msm_host->registered) {
2073                 mipi_dsi_host_unregister(host);
2074                 host->dev = NULL;
2075                 host->ops = NULL;
2076                 msm_host->registered = false;
2077         }
2078 }
2079
2080 int msm_dsi_host_xfer_prepare(struct mipi_dsi_host *host,
2081                                 const struct mipi_dsi_msg *msg)
2082 {
2083         struct msm_dsi_host *msm_host = to_msm_dsi_host(host);
2084         const struct msm_dsi_cfg_handler *cfg_hnd = msm_host->cfg_hnd;
2085
2086         /* TODO: make sure dsi_cmd_mdp is idle.
2087          * Since DSI6G v1.2.0, we can set DSI_TRIG_CTRL.BLOCK_DMA_WITHIN_FRAME
2088          * to ask H/W to wait until cmd mdp is idle. S/W wait is not needed.
2089          * How to handle the old versions? Wait for mdp cmd done?
2090          */
2091
2092         /*
2093          * mdss interrupt is generated in mdp core clock domain
2094          * mdp clock need to be enabled to receive dsi interrupt
2095          */
2096         pm_runtime_get_sync(&msm_host->pdev->dev);
2097         cfg_hnd->ops->link_clk_set_rate(msm_host);
2098         cfg_hnd->ops->link_clk_enable(msm_host);
2099
2100         /* TODO: vote for bus bandwidth */
2101
2102         if (!(msg->flags & MIPI_DSI_MSG_USE_LPM))
2103                 dsi_set_tx_power_mode(0, msm_host);
2104
2105         msm_host->dma_cmd_ctrl_restore = dsi_read(msm_host, REG_DSI_CTRL);
2106         dsi_write(msm_host, REG_DSI_CTRL,
2107                 msm_host->dma_cmd_ctrl_restore |
2108                 DSI_CTRL_CMD_MODE_EN |
2109                 DSI_CTRL_ENABLE);
2110         dsi_intr_ctrl(msm_host, DSI_IRQ_MASK_CMD_DMA_DONE, 1);
2111
2112         return 0;
2113 }
2114
2115 void msm_dsi_host_xfer_restore(struct mipi_dsi_host *host,
2116                                 const struct mipi_dsi_msg *msg)
2117 {
2118         struct msm_dsi_host *msm_host = to_msm_dsi_host(host);
2119         const struct msm_dsi_cfg_handler *cfg_hnd = msm_host->cfg_hnd;
2120
2121         dsi_intr_ctrl(msm_host, DSI_IRQ_MASK_CMD_DMA_DONE, 0);
2122         dsi_write(msm_host, REG_DSI_CTRL, msm_host->dma_cmd_ctrl_restore);
2123
2124         if (!(msg->flags & MIPI_DSI_MSG_USE_LPM))
2125                 dsi_set_tx_power_mode(1, msm_host);
2126
2127         /* TODO: unvote for bus bandwidth */
2128
2129         cfg_hnd->ops->link_clk_disable(msm_host);
2130         pm_runtime_put(&msm_host->pdev->dev);
2131 }
2132
2133 int msm_dsi_host_cmd_tx(struct mipi_dsi_host *host,
2134                                 const struct mipi_dsi_msg *msg)
2135 {
2136         struct msm_dsi_host *msm_host = to_msm_dsi_host(host);
2137
2138         return dsi_cmds2buf_tx(msm_host, msg);
2139 }
2140
2141 int msm_dsi_host_cmd_rx(struct mipi_dsi_host *host,
2142                                 const struct mipi_dsi_msg *msg)
2143 {
2144         struct msm_dsi_host *msm_host = to_msm_dsi_host(host);
2145         const struct msm_dsi_cfg_handler *cfg_hnd = msm_host->cfg_hnd;
2146         int data_byte, rx_byte, dlen, end;
2147         int short_response, diff, pkt_size, ret = 0;
2148         char cmd;
2149         int rlen = msg->rx_len;
2150         u8 *buf;
2151
2152         if (rlen <= 2) {
2153                 short_response = 1;
2154                 pkt_size = rlen;
2155                 rx_byte = 4;
2156         } else {
2157                 short_response = 0;
2158                 data_byte = 10; /* first read */
2159                 if (rlen < data_byte)
2160                         pkt_size = rlen;
2161                 else
2162                         pkt_size = data_byte;
2163                 rx_byte = data_byte + 6; /* 4 header + 2 crc */
2164         }
2165
2166         buf = msm_host->rx_buf;
2167         end = 0;
2168         while (!end) {
2169                 u8 tx[2] = {pkt_size & 0xff, pkt_size >> 8};
2170                 struct mipi_dsi_msg max_pkt_size_msg = {
2171                         .channel = msg->channel,
2172                         .type = MIPI_DSI_SET_MAXIMUM_RETURN_PACKET_SIZE,
2173                         .tx_len = 2,
2174                         .tx_buf = tx,
2175                 };
2176
2177                 DBG("rlen=%d pkt_size=%d rx_byte=%d",
2178                         rlen, pkt_size, rx_byte);
2179
2180                 ret = dsi_cmds2buf_tx(msm_host, &max_pkt_size_msg);
2181                 if (ret < 2) {
2182                         pr_err("%s: Set max pkt size failed, %d\n",
2183                                 __func__, ret);
2184                         return -EINVAL;
2185                 }
2186
2187                 if ((cfg_hnd->major == MSM_DSI_VER_MAJOR_6G) &&
2188                         (cfg_hnd->minor >= MSM_DSI_6G_VER_MINOR_V1_1)) {
2189                         /* Clear the RDBK_DATA registers */
2190                         dsi_write(msm_host, REG_DSI_RDBK_DATA_CTRL,
2191                                         DSI_RDBK_DATA_CTRL_CLR);
2192                         wmb(); /* make sure the RDBK registers are cleared */
2193                         dsi_write(msm_host, REG_DSI_RDBK_DATA_CTRL, 0);
2194                         wmb(); /* release cleared status before transfer */
2195                 }
2196
2197                 ret = dsi_cmds2buf_tx(msm_host, msg);
2198                 if (ret < 0) {
2199                         pr_err("%s: Read cmd Tx failed, %d\n", __func__, ret);
2200                         return ret;
2201                 } else if (ret < msg->tx_len) {
2202                         pr_err("%s: Read cmd Tx failed, too short: %d\n", __func__, ret);
2203                         return -ECOMM;
2204                 }
2205
2206                 /*
2207                  * once cmd_dma_done interrupt received,
2208                  * return data from client is ready and stored
2209                  * at RDBK_DATA register already
2210                  * since rx fifo is 16 bytes, dcs header is kept at first loop,
2211                  * after that dcs header lost during shift into registers
2212                  */
2213                 dlen = dsi_cmd_dma_rx(msm_host, buf, rx_byte, pkt_size);
2214
2215                 if (dlen <= 0)
2216                         return 0;
2217
2218                 if (short_response)
2219                         break;
2220
2221                 if (rlen <= data_byte) {
2222                         diff = data_byte - rlen;
2223                         end = 1;
2224                 } else {
2225                         diff = 0;
2226                         rlen -= data_byte;
2227                 }
2228
2229                 if (!end) {
2230                         dlen -= 2; /* 2 crc */
2231                         dlen -= diff;
2232                         buf += dlen;    /* next start position */
2233                         data_byte = 14; /* NOT first read */
2234                         if (rlen < data_byte)
2235                                 pkt_size += rlen;
2236                         else
2237                                 pkt_size += data_byte;
2238                         DBG("buf=%p dlen=%d diff=%d", buf, dlen, diff);
2239                 }
2240         }
2241
2242         /*
2243          * For single Long read, if the requested rlen < 10,
2244          * we need to shift the start position of rx
2245          * data buffer to skip the bytes which are not
2246          * updated.
2247          */
2248         if (pkt_size < 10 && !short_response)
2249                 buf = msm_host->rx_buf + (10 - rlen);
2250         else
2251                 buf = msm_host->rx_buf;
2252
2253         cmd = buf[0];
2254         switch (cmd) {
2255         case MIPI_DSI_RX_ACKNOWLEDGE_AND_ERROR_REPORT:
2256                 pr_err("%s: rx ACK_ERR_PACLAGE\n", __func__);
2257                 ret = 0;
2258                 break;
2259         case MIPI_DSI_RX_GENERIC_SHORT_READ_RESPONSE_1BYTE:
2260         case MIPI_DSI_RX_DCS_SHORT_READ_RESPONSE_1BYTE:
2261                 ret = dsi_short_read1_resp(buf, msg);
2262                 break;
2263         case MIPI_DSI_RX_GENERIC_SHORT_READ_RESPONSE_2BYTE:
2264         case MIPI_DSI_RX_DCS_SHORT_READ_RESPONSE_2BYTE:
2265                 ret = dsi_short_read2_resp(buf, msg);
2266                 break;
2267         case MIPI_DSI_RX_GENERIC_LONG_READ_RESPONSE:
2268         case MIPI_DSI_RX_DCS_LONG_READ_RESPONSE:
2269                 ret = dsi_long_read_resp(buf, msg);
2270                 break;
2271         default:
2272                 pr_warn("%s:Invalid response cmd\n", __func__);
2273                 ret = 0;
2274         }
2275
2276         return ret;
2277 }
2278
2279 void msm_dsi_host_cmd_xfer_commit(struct mipi_dsi_host *host, u32 dma_base,
2280                                   u32 len)
2281 {
2282         struct msm_dsi_host *msm_host = to_msm_dsi_host(host);
2283
2284         dsi_write(msm_host, REG_DSI_DMA_BASE, dma_base);
2285         dsi_write(msm_host, REG_DSI_DMA_LEN, len);
2286         dsi_write(msm_host, REG_DSI_TRIG_DMA, 1);
2287
2288         /* Make sure trigger happens */
2289         wmb();
2290 }
2291
2292 void msm_dsi_host_set_phy_mode(struct mipi_dsi_host *host,
2293         struct msm_dsi_phy *src_phy)
2294 {
2295         struct msm_dsi_host *msm_host = to_msm_dsi_host(host);
2296
2297         msm_host->cphy_mode = src_phy->cphy_mode;
2298 }
2299
2300 void msm_dsi_host_reset_phy(struct mipi_dsi_host *host)
2301 {
2302         struct msm_dsi_host *msm_host = to_msm_dsi_host(host);
2303
2304         DBG("");
2305         dsi_write(msm_host, REG_DSI_PHY_RESET, DSI_PHY_RESET_RESET);
2306         /* Make sure fully reset */
2307         wmb();
2308         udelay(1000);
2309         dsi_write(msm_host, REG_DSI_PHY_RESET, 0);
2310         udelay(100);
2311 }
2312
2313 void msm_dsi_host_get_phy_clk_req(struct mipi_dsi_host *host,
2314                         struct msm_dsi_phy_clk_request *clk_req,
2315                         bool is_bonded_dsi)
2316 {
2317         struct msm_dsi_host *msm_host = to_msm_dsi_host(host);
2318         const struct msm_dsi_cfg_handler *cfg_hnd = msm_host->cfg_hnd;
2319         int ret;
2320
2321         ret = cfg_hnd->ops->calc_clk_rate(msm_host, is_bonded_dsi);
2322         if (ret) {
2323                 pr_err("%s: unable to calc clk rate, %d\n", __func__, ret);
2324                 return;
2325         }
2326
2327         /* CPHY transmits 16 bits over 7 clock cycles
2328          * "byte_clk" is in units of 16-bits (see dsi_calc_pclk),
2329          * so multiply by 7 to get the "bitclk rate"
2330          */
2331         if (msm_host->cphy_mode)
2332                 clk_req->bitclk_rate = msm_host->byte_clk_rate * 7;
2333         else
2334                 clk_req->bitclk_rate = msm_host->byte_clk_rate * 8;
2335         clk_req->escclk_rate = msm_host->esc_clk_rate;
2336 }
2337
2338 void msm_dsi_host_enable_irq(struct mipi_dsi_host *host)
2339 {
2340         struct msm_dsi_host *msm_host = to_msm_dsi_host(host);
2341
2342         enable_irq(msm_host->irq);
2343 }
2344
2345 void msm_dsi_host_disable_irq(struct mipi_dsi_host *host)
2346 {
2347         struct msm_dsi_host *msm_host = to_msm_dsi_host(host);
2348
2349         disable_irq(msm_host->irq);
2350 }
2351
2352 int msm_dsi_host_enable(struct mipi_dsi_host *host)
2353 {
2354         struct msm_dsi_host *msm_host = to_msm_dsi_host(host);
2355
2356         dsi_op_mode_config(msm_host,
2357                 !!(msm_host->mode_flags & MIPI_DSI_MODE_VIDEO), true);
2358
2359         /* TODO: clock should be turned off for command mode,
2360          * and only turned on before MDP START.
2361          * This part of code should be enabled once mdp driver support it.
2362          */
2363         /* if (msm_panel->mode == MSM_DSI_CMD_MODE) {
2364          *      dsi_link_clk_disable(msm_host);
2365          *      pm_runtime_put(&msm_host->pdev->dev);
2366          * }
2367          */
2368         msm_host->enabled = true;
2369         return 0;
2370 }
2371
2372 int msm_dsi_host_disable(struct mipi_dsi_host *host)
2373 {
2374         struct msm_dsi_host *msm_host = to_msm_dsi_host(host);
2375
2376         msm_host->enabled = false;
2377         dsi_op_mode_config(msm_host,
2378                 !!(msm_host->mode_flags & MIPI_DSI_MODE_VIDEO), false);
2379
2380         /* Since we have disabled INTF, the video engine won't stop so that
2381          * the cmd engine will be blocked.
2382          * Reset to disable video engine so that we can send off cmd.
2383          */
2384         dsi_sw_reset(msm_host);
2385
2386         return 0;
2387 }
2388
2389 static void msm_dsi_sfpb_config(struct msm_dsi_host *msm_host, bool enable)
2390 {
2391         enum sfpb_ahb_arb_master_port_en en;
2392
2393         if (!msm_host->sfpb)
2394                 return;
2395
2396         en = enable ? SFPB_MASTER_PORT_ENABLE : SFPB_MASTER_PORT_DISABLE;
2397
2398         regmap_update_bits(msm_host->sfpb, REG_SFPB_GPREG,
2399                         SFPB_GPREG_MASTER_PORT_EN__MASK,
2400                         SFPB_GPREG_MASTER_PORT_EN(en));
2401 }
2402
2403 int msm_dsi_host_power_on(struct mipi_dsi_host *host,
2404                         struct msm_dsi_phy_shared_timings *phy_shared_timings,
2405                         bool is_bonded_dsi, struct msm_dsi_phy *phy)
2406 {
2407         struct msm_dsi_host *msm_host = to_msm_dsi_host(host);
2408         const struct msm_dsi_cfg_handler *cfg_hnd = msm_host->cfg_hnd;
2409         int ret = 0;
2410
2411         mutex_lock(&msm_host->dev_mutex);
2412         if (msm_host->power_on) {
2413                 DBG("dsi host already on");
2414                 goto unlock_ret;
2415         }
2416
2417         msm_dsi_sfpb_config(msm_host, true);
2418
2419         ret = regulator_bulk_enable(msm_host->cfg_hnd->cfg->num_regulators,
2420                                     msm_host->supplies);
2421         if (ret) {
2422                 pr_err("%s:Failed to enable vregs.ret=%d\n",
2423                         __func__, ret);
2424                 goto unlock_ret;
2425         }
2426
2427         pm_runtime_get_sync(&msm_host->pdev->dev);
2428         ret = cfg_hnd->ops->link_clk_set_rate(msm_host);
2429         if (!ret)
2430                 ret = cfg_hnd->ops->link_clk_enable(msm_host);
2431         if (ret) {
2432                 pr_err("%s: failed to enable link clocks. ret=%d\n",
2433                        __func__, ret);
2434                 goto fail_disable_reg;
2435         }
2436
2437         ret = pinctrl_pm_select_default_state(&msm_host->pdev->dev);
2438         if (ret) {
2439                 pr_err("%s: failed to set pinctrl default state, %d\n",
2440                         __func__, ret);
2441                 goto fail_disable_clk;
2442         }
2443
2444         dsi_timing_setup(msm_host, is_bonded_dsi);
2445         dsi_sw_reset(msm_host);
2446         dsi_ctrl_config(msm_host, true, phy_shared_timings, phy);
2447
2448         if (msm_host->disp_en_gpio)
2449                 gpiod_set_value(msm_host->disp_en_gpio, 1);
2450
2451         msm_host->power_on = true;
2452         mutex_unlock(&msm_host->dev_mutex);
2453
2454         return 0;
2455
2456 fail_disable_clk:
2457         cfg_hnd->ops->link_clk_disable(msm_host);
2458         pm_runtime_put(&msm_host->pdev->dev);
2459 fail_disable_reg:
2460         regulator_bulk_disable(msm_host->cfg_hnd->cfg->num_regulators,
2461                                msm_host->supplies);
2462 unlock_ret:
2463         mutex_unlock(&msm_host->dev_mutex);
2464         return ret;
2465 }
2466
2467 int msm_dsi_host_power_off(struct mipi_dsi_host *host)
2468 {
2469         struct msm_dsi_host *msm_host = to_msm_dsi_host(host);
2470         const struct msm_dsi_cfg_handler *cfg_hnd = msm_host->cfg_hnd;
2471
2472         mutex_lock(&msm_host->dev_mutex);
2473         if (!msm_host->power_on) {
2474                 DBG("dsi host already off");
2475                 goto unlock_ret;
2476         }
2477
2478         dsi_ctrl_config(msm_host, false, NULL, NULL);
2479
2480         if (msm_host->disp_en_gpio)
2481                 gpiod_set_value(msm_host->disp_en_gpio, 0);
2482
2483         pinctrl_pm_select_sleep_state(&msm_host->pdev->dev);
2484
2485         cfg_hnd->ops->link_clk_disable(msm_host);
2486         pm_runtime_put(&msm_host->pdev->dev);
2487
2488         regulator_bulk_disable(msm_host->cfg_hnd->cfg->num_regulators,
2489                                msm_host->supplies);
2490
2491         msm_dsi_sfpb_config(msm_host, false);
2492
2493         DBG("-");
2494
2495         msm_host->power_on = false;
2496
2497 unlock_ret:
2498         mutex_unlock(&msm_host->dev_mutex);
2499         return 0;
2500 }
2501
2502 int msm_dsi_host_set_display_mode(struct mipi_dsi_host *host,
2503                                   const struct drm_display_mode *mode)
2504 {
2505         struct msm_dsi_host *msm_host = to_msm_dsi_host(host);
2506
2507         if (msm_host->mode) {
2508                 drm_mode_destroy(msm_host->dev, msm_host->mode);
2509                 msm_host->mode = NULL;
2510         }
2511
2512         msm_host->mode = drm_mode_duplicate(msm_host->dev, mode);
2513         if (!msm_host->mode) {
2514                 pr_err("%s: cannot duplicate mode\n", __func__);
2515                 return -ENOMEM;
2516         }
2517
2518         return 0;
2519 }
2520
2521 enum drm_mode_status msm_dsi_host_check_dsc(struct mipi_dsi_host *host,
2522                                             const struct drm_display_mode *mode)
2523 {
2524         struct msm_dsi_host *msm_host = to_msm_dsi_host(host);
2525         struct drm_dsc_config *dsc = msm_host->dsc;
2526         int pic_width = mode->hdisplay;
2527         int pic_height = mode->vdisplay;
2528
2529         if (!msm_host->dsc)
2530                 return MODE_OK;
2531
2532         if (pic_width % dsc->slice_width) {
2533                 pr_err("DSI: pic_width %d has to be multiple of slice %d\n",
2534                        pic_width, dsc->slice_width);
2535                 return MODE_H_ILLEGAL;
2536         }
2537
2538         if (pic_height % dsc->slice_height) {
2539                 pr_err("DSI: pic_height %d has to be multiple of slice %d\n",
2540                        pic_height, dsc->slice_height);
2541                 return MODE_V_ILLEGAL;
2542         }
2543
2544         return MODE_OK;
2545 }
2546
2547 unsigned long msm_dsi_host_get_mode_flags(struct mipi_dsi_host *host)
2548 {
2549         return to_msm_dsi_host(host)->mode_flags;
2550 }
2551
2552 void msm_dsi_host_snapshot(struct msm_disp_state *disp_state, struct mipi_dsi_host *host)
2553 {
2554         struct msm_dsi_host *msm_host = to_msm_dsi_host(host);
2555
2556         pm_runtime_get_sync(&msm_host->pdev->dev);
2557
2558         msm_disp_snapshot_add_block(disp_state, msm_host->ctrl_size,
2559                         msm_host->ctrl_base, "dsi%d_ctrl", msm_host->id);
2560
2561         pm_runtime_put_sync(&msm_host->pdev->dev);
2562 }
2563
2564 static void msm_dsi_host_video_test_pattern_setup(struct msm_dsi_host *msm_host)
2565 {
2566         u32 reg;
2567
2568         reg = dsi_read(msm_host, REG_DSI_TEST_PATTERN_GEN_CTRL);
2569
2570         dsi_write(msm_host, REG_DSI_TEST_PATTERN_GEN_VIDEO_INIT_VAL, 0xff);
2571         /* draw checkered rectangle pattern */
2572         dsi_write(msm_host, REG_DSI_TPG_MAIN_CONTROL,
2573                         DSI_TPG_MAIN_CONTROL_CHECKERED_RECTANGLE_PATTERN);
2574         /* use 24-bit RGB test pttern */
2575         dsi_write(msm_host, REG_DSI_TPG_VIDEO_CONFIG,
2576                         DSI_TPG_VIDEO_CONFIG_BPP(VIDEO_CONFIG_24BPP) |
2577                         DSI_TPG_VIDEO_CONFIG_RGB);
2578
2579         reg |= DSI_TEST_PATTERN_GEN_CTRL_VIDEO_PATTERN_SEL(VID_MDSS_GENERAL_PATTERN);
2580         dsi_write(msm_host, REG_DSI_TEST_PATTERN_GEN_CTRL, reg);
2581
2582         DBG("Video test pattern setup done\n");
2583 }
2584
2585 static void msm_dsi_host_cmd_test_pattern_setup(struct msm_dsi_host *msm_host)
2586 {
2587         u32 reg;
2588
2589         reg = dsi_read(msm_host, REG_DSI_TEST_PATTERN_GEN_CTRL);
2590
2591         /* initial value for test pattern */
2592         dsi_write(msm_host, REG_DSI_TEST_PATTERN_GEN_CMD_MDP_INIT_VAL0, 0xff);
2593
2594         reg |= DSI_TEST_PATTERN_GEN_CTRL_CMD_MDP_STREAM0_PATTERN_SEL(CMD_MDP_MDSS_GENERAL_PATTERN);
2595
2596         dsi_write(msm_host, REG_DSI_TEST_PATTERN_GEN_CTRL, reg);
2597         /* draw checkered rectangle pattern */
2598         dsi_write(msm_host, REG_DSI_TPG_MAIN_CONTROL2,
2599                         DSI_TPG_MAIN_CONTROL2_CMD_MDP0_CHECKERED_RECTANGLE_PATTERN);
2600
2601         DBG("Cmd test pattern setup done\n");
2602 }
2603
2604 void msm_dsi_host_test_pattern_en(struct mipi_dsi_host *host)
2605 {
2606         struct msm_dsi_host *msm_host = to_msm_dsi_host(host);
2607         bool is_video_mode = !!(msm_host->mode_flags & MIPI_DSI_MODE_VIDEO);
2608         u32 reg;
2609
2610         if (is_video_mode)
2611                 msm_dsi_host_video_test_pattern_setup(msm_host);
2612         else
2613                 msm_dsi_host_cmd_test_pattern_setup(msm_host);
2614
2615         reg = dsi_read(msm_host, REG_DSI_TEST_PATTERN_GEN_CTRL);
2616         /* enable the test pattern generator */
2617         dsi_write(msm_host, REG_DSI_TEST_PATTERN_GEN_CTRL, (reg | DSI_TEST_PATTERN_GEN_CTRL_EN));
2618
2619         /* for command mode need to trigger one frame from tpg */
2620         if (!is_video_mode)
2621                 dsi_write(msm_host, REG_DSI_TEST_PATTERN_GEN_CMD_STREAM0_TRIGGER,
2622                                 DSI_TEST_PATTERN_GEN_CMD_STREAM0_TRIGGER_SW_TRIGGER);
2623 }
2624
2625 struct drm_dsc_config *msm_dsi_host_get_dsc_config(struct mipi_dsi_host *host)
2626 {
2627         struct msm_dsi_host *msm_host = to_msm_dsi_host(host);
2628
2629         return msm_host->dsc;
2630 }