drivers/video/fbdev/omap/lcd_mipid.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * LCD driver for MIPI DBI-C / DCS compatible LCDs
   4  *
   5  * Copyright (C) 2006 Nokia Corporation
   6  * Author: Imre Deak <[email protected]>
   7  */
   8 #include <linux/device.h>
   9 #include <linux/delay.h>
  10 #include <linux/gpio/consumer.h>
  11 #include <linux/slab.h>
  12 #include <linux/workqueue.h>
  13 #include <linux/spi/spi.h>
  14 #include <linux/module.h>
  15
  16 #include <linux/platform_data/lcd-mipid.h>
  17
  18 #include "omapfb.h"
  19
  20 #define MIPID_MODULE_NAME               "lcd_mipid"
  21
  22 #define MIPID_CMD_READ_DISP_ID          0x04
  23 #define MIPID_CMD_READ_RED              0x06
  24 #define MIPID_CMD_READ_GREEN            0x07
  25 #define MIPID_CMD_READ_BLUE             0x08
  26 #define MIPID_CMD_READ_DISP_STATUS      0x09
  27 #define MIPID_CMD_RDDSDR                0x0F
  28 #define MIPID_CMD_SLEEP_IN              0x10
  29 #define MIPID_CMD_SLEEP_OUT             0x11
  30 #define MIPID_CMD_DISP_OFF              0x28
  31 #define MIPID_CMD_DISP_ON               0x29
  32
  33 #define MIPID_ESD_CHECK_PERIOD          msecs_to_jiffies(5000)
  34
  35 #define to_mipid_device(p)              container_of(p, struct mipid_device, \
  36                                                 panel)
  37 struct mipid_device {
  38         int             enabled;
  39         int             revision;
  40         unsigned int    saved_bklight_level;
  41         unsigned long   hw_guard_end;           /* next value of jiffies
  42                                                    when we can issue the
  43                                                    next sleep in/out command */
  44         unsigned long   hw_guard_wait;          /* max guard time in jiffies */
  45         struct gpio_desc        *reset;
  46
  47         struct omapfb_device    *fbdev;
  48         struct spi_device       *spi;
  49         struct mutex            mutex;
  50         struct lcd_panel        panel;
  51
  52         struct delayed_work     esd_work;
  53         void                    (*esd_check)(struct mipid_device *m);
  54 };
  55
  56 static void mipid_transfer(struct mipid_device *md, int cmd, const u8 *wbuf,
  57                            int wlen, u8 *rbuf, int rlen)
  58 {
  59         struct spi_message      m;
  60         struct spi_transfer     *x, xfer[4];
  61         u16                     w;
  62         int                     r;
  63
  64         BUG_ON(md->spi == NULL);
  65
  66         spi_message_init(&m);
  67
  68         memset(xfer, 0, sizeof(xfer));
  69         x = &xfer[0];
  70
  71         cmd &=  0xff;
  72         x->tx_buf               = &cmd;
  73         x->bits_per_word        = 9;
  74         x->len                  = 2;
  75         spi_message_add_tail(x, &m);
  76
  77         if (wlen) {
  78                 x++;
  79                 x->tx_buf               = wbuf;
  80                 x->len                  = wlen;
  81                 x->bits_per_word        = 9;
  82                 spi_message_add_tail(x, &m);
  83         }
  84
  85         if (rlen) {
  86                 x++;
  87                 x->rx_buf       = &w;
  88                 x->len          = 1;
  89                 spi_message_add_tail(x, &m);
  90
  91                 if (rlen > 1) {
  92                         /* Arrange for the extra clock before the first
  93                          * data bit.
  94                          */
  95                         x->bits_per_word = 9;
  96                         x->len           = 2;
  97
  98                         x++;
  99                         x->rx_buf        = &rbuf[1];
 100                         x->len           = rlen - 1;
 101                         spi_message_add_tail(x, &m);
 102                 }
 103         }
 104
 105         r = spi_sync(md->spi, &m);
 106         if (r < 0)
 107                 dev_dbg(&md->spi->dev, "spi_sync %d\n", r);
 108
 109         if (rlen)
 110                 rbuf[0] = w & 0xff;
 111 }
 112
 113 static inline void mipid_cmd(struct mipid_device *md, int cmd)
 114 {
 115         mipid_transfer(md, cmd, NULL, 0, NULL, 0);
 116 }
 117
 118 static inline void mipid_write(struct mipid_device *md,
 119                                int reg, const u8 *buf, int len)
 120 {
 121         mipid_transfer(md, reg, buf, len, NULL, 0);
 122 }
 123
 124 static inline void mipid_read(struct mipid_device *md,
 125                               int reg, u8 *buf, int len)
 126 {
 127         mipid_transfer(md, reg, NULL, 0, buf, len);
 128 }
 129
 130 static void set_data_lines(struct mipid_device *md, int data_lines)
 131 {
 132         u16 par;
 133
 134         switch (data_lines) {
 135         case 16:
 136                 par = 0x150;
 137                 break;
 138         case 18:
 139                 par = 0x160;
 140                 break;
 141         case 24:
 142                 par = 0x170;
 143                 break;
 144         }
 145         mipid_write(md, 0x3a, (u8 *)&par, 2);
 146 }
 147
 148 static void send_init_string(struct mipid_device *md)
 149 {
 150         u16 initpar[] = { 0x0102, 0x0100, 0x0100 };
 151
 152         mipid_write(md, 0xc2, (u8 *)initpar, sizeof(initpar));
 153         set_data_lines(md, md->panel.data_lines);
 154 }
 155
 156 static void hw_guard_start(struct mipid_device *md, int guard_msec)
 157 {
 158         md->hw_guard_wait = msecs_to_jiffies(guard_msec);
 159         md->hw_guard_end = jiffies + md->hw_guard_wait;
 160 }
 161
 162 static void hw_guard_wait(struct mipid_device *md)
 163 {
 164         unsigned long wait = md->hw_guard_end - jiffies;
 165
 166         if ((long)wait > 0 && time_before_eq(wait,  md->hw_guard_wait)) {
 167                 set_current_state(TASK_UNINTERRUPTIBLE);
 168                 schedule_timeout(wait);
 169         }
 170 }
 171
 172 static void set_sleep_mode(struct mipid_device *md, int on)
 173 {
 174         int cmd, sleep_time = 50;
 175
 176         if (on)
 177                 cmd = MIPID_CMD_SLEEP_IN;
 178         else
 179                 cmd = MIPID_CMD_SLEEP_OUT;
 180         hw_guard_wait(md);
 181         mipid_cmd(md, cmd);
 182         hw_guard_start(md, 120);
 183         /*
 184          * When we enable the panel, it seems we _have_ to sleep
 185          * 120 ms before sending the init string. When disabling the
 186          * panel we'll sleep for the duration of 2 frames, so that the
 187          * controller can still provide the PCLK,HS,VS signals.
 188          */
 189         if (!on)
 190                 sleep_time = 120;
 191         msleep(sleep_time);
 192 }
 193
 194 static void set_display_state(struct mipid_device *md, int enabled)
 195 {
 196         int cmd = enabled ? MIPID_CMD_DISP_ON : MIPID_CMD_DISP_OFF;
 197
 198         mipid_cmd(md, cmd);
 199 }
 200
 201 static int mipid_set_bklight_level(struct lcd_panel *panel, unsigned int level)
 202 {
 203         struct mipid_device *md = to_mipid_device(panel);
 204         struct mipid_platform_data *pd = md->spi->dev.platform_data;
 205
 206         if (pd->get_bklight_max == NULL || pd->set_bklight_level == NULL)
 207                 return -ENODEV;
 208         if (level > pd->get_bklight_max(pd))
 209                 return -EINVAL;
 210         if (!md->enabled) {
 211                 md->saved_bklight_level = level;
 212                 return 0;
 213         }
 214         pd->set_bklight_level(pd, level);
 215
 216         return 0;
 217 }
 218
 219 static unsigned int mipid_get_bklight_level(struct lcd_panel *panel)
 220 {
 221         struct mipid_device *md = to_mipid_device(panel);
 222         struct mipid_platform_data *pd = md->spi->dev.platform_data;
 223
 224         if (pd->get_bklight_level == NULL)
 225                 return -ENODEV;
 226         return pd->get_bklight_level(pd);
 227 }
 228
 229 static unsigned int mipid_get_bklight_max(struct lcd_panel *panel)
 230 {
 231         struct mipid_device *md = to_mipid_device(panel);
 232         struct mipid_platform_data *pd = md->spi->dev.platform_data;
 233
 234         if (pd->get_bklight_max == NULL)
 235                 return -ENODEV;
 236
 237         return pd->get_bklight_max(pd);
 238 }
 239
 240 static unsigned long mipid_get_caps(struct lcd_panel *panel)
 241 {
 242         return OMAPFB_CAPS_SET_BACKLIGHT;
 243 }
 244
 245 static u16 read_first_pixel(struct mipid_device *md)
 246 {
 247         u16 pixel;
 248         u8 red, green, blue;
 249
 250         mutex_lock(&md->mutex);
 251         mipid_read(md, MIPID_CMD_READ_RED, &red, 1);
 252         mipid_read(md, MIPID_CMD_READ_GREEN, &green, 1);
 253         mipid_read(md, MIPID_CMD_READ_BLUE, &blue, 1);
 254         mutex_unlock(&md->mutex);
 255
 256         switch (md->panel.data_lines) {
 257         case 16:
 258                 pixel = ((red >> 1) << 11) | (green << 5) | (blue >> 1);
 259                 break;
 260         case 24:
 261                 /* 24 bit -> 16 bit */
 262                 pixel = ((red >> 3) << 11) | ((green >> 2) << 5) |
 263                         (blue >> 3);
 264                 break;
 265         default:
 266                 pixel = 0;
 267                 BUG();
 268         }
 269
 270         return pixel;
 271 }
 272
 273 static int mipid_run_test(struct lcd_panel *panel, int test_num)
 274 {
 275         struct mipid_device *md = to_mipid_device(panel);
 276         static const u16 test_values[4] = {
 277                 0x0000, 0xffff, 0xaaaa, 0x5555,
 278         };
 279         int i;
 280
 281         if (test_num != MIPID_TEST_RGB_LINES)
 282                 return MIPID_TEST_INVALID;
 283
 284         for (i = 0; i < ARRAY_SIZE(test_values); i++) {
 285                 int delay;
 286                 unsigned long tmo;
 287
 288                 omapfb_write_first_pixel(md->fbdev, test_values[i]);
 289                 tmo = jiffies + msecs_to_jiffies(100);
 290                 delay = 25;
 291                 while (1) {
 292                         u16 pixel;
 293
 294                         msleep(delay);
 295                         pixel = read_first_pixel(md);
 296                         if (pixel == test_values[i])
 297                                 break;
 298                         if (time_after(jiffies, tmo)) {
 299                                 dev_err(&md->spi->dev,
 300                                         "MIPI LCD RGB I/F test failed: "
 301                                         "expecting %04x, got %04x\n",
 302                                         test_values[i], pixel);
 303                                 return MIPID_TEST_FAILED;
 304                         }
 305                         delay = 10;
 306                 }
 307         }
 308
 309         return 0;
 310 }
 311
 312 static void ls041y3_esd_recover(struct mipid_device *md)
 313 {
 314         dev_err(&md->spi->dev, "performing LCD ESD recovery\n");
 315         set_sleep_mode(md, 1);
 316         set_sleep_mode(md, 0);
 317 }
 318
 319 static void ls041y3_esd_check_mode1(struct mipid_device *md)
 320 {
 321         u8 state1, state2;
 322
 323         mipid_read(md, MIPID_CMD_RDDSDR, &state1, 1);
 324         set_sleep_mode(md, 0);
 325         mipid_read(md, MIPID_CMD_RDDSDR, &state2, 1);
 326         dev_dbg(&md->spi->dev, "ESD mode 1 state1 %02x state2 %02x\n",
 327                 state1, state2);
 328         /* Each sleep out command will trigger a self diagnostic and flip
 329         * Bit6 if the test passes.
 330         */
 331         if (!((state1 ^ state2) & (1 << 6)))
 332                 ls041y3_esd_recover(md);
 333 }
 334
 335 static void ls041y3_esd_check_mode2(struct mipid_device *md)
 336 {
 337         int i;
 338         u8 rbuf[2];
 339         static const struct {
 340                 int     cmd;
 341                 int     wlen;
 342                 u16     wbuf[3];
 343         } *rd, rd_ctrl[7] = {
 344                 { 0xb0, 4, { 0x0101, 0x01fe, } },
 345                 { 0xb1, 4, { 0x01de, 0x0121, } },
 346                 { 0xc2, 4, { 0x0100, 0x0100, } },
 347                 { 0xbd, 2, { 0x0100, } },
 348                 { 0xc2, 4, { 0x01fc, 0x0103, } },
 349                 { 0xb4, 0, },
 350                 { 0x00, 0, },
 351         };
 352
 353         rd = rd_ctrl;
 354         for (i = 0; i < 3; i++, rd++)
 355                 mipid_write(md, rd->cmd, (u8 *)rd->wbuf, rd->wlen);
 356
 357         udelay(10);
 358         mipid_read(md, rd->cmd, rbuf, 2);
 359         rd++;
 360
 361         for (i = 0; i < 3; i++, rd++) {
 362                 udelay(10);
 363                 mipid_write(md, rd->cmd, (u8 *)rd->wbuf, rd->wlen);
 364         }
 365
 366         dev_dbg(&md->spi->dev, "ESD mode 2 state %02x\n", rbuf[1]);
 367         if (rbuf[1] == 0x00)
 368                 ls041y3_esd_recover(md);
 369 }
 370
 371 static void ls041y3_esd_check(struct mipid_device *md)
 372 {
 373         ls041y3_esd_check_mode1(md);
 374         if (md->revision >= 0x88)
 375                 ls041y3_esd_check_mode2(md);
 376 }
 377
 378 static void mipid_esd_start_check(struct mipid_device *md)
 379 {
 380         if (md->esd_check != NULL)
 381                 schedule_delayed_work(&md->esd_work,
 382                                    MIPID_ESD_CHECK_PERIOD);
 383 }
 384
 385 static void mipid_esd_stop_check(struct mipid_device *md)
 386 {
 387         if (md->esd_check != NULL)
 388                 cancel_delayed_work_sync(&md->esd_work);
 389 }
 390
 391 static void mipid_esd_work(struct work_struct *work)
 392 {
 393         struct mipid_device *md = container_of(work, struct mipid_device,
 394                                                esd_work.work);
 395
 396         mutex_lock(&md->mutex);
 397         md->esd_check(md);
 398         mutex_unlock(&md->mutex);
 399         mipid_esd_start_check(md);
 400 }
 401
 402 static int mipid_enable(struct lcd_panel *panel)
 403 {
 404         struct mipid_device *md = to_mipid_device(panel);
 405
 406         mutex_lock(&md->mutex);
 407
 408         if (md->enabled) {
 409                 mutex_unlock(&md->mutex);
 410                 return 0;
 411         }
 412         set_sleep_mode(md, 0);
 413         md->enabled = 1;
 414         send_init_string(md);
 415         set_display_state(md, 1);
 416         mipid_set_bklight_level(panel, md->saved_bklight_level);
 417         mipid_esd_start_check(md);
 418
 419         mutex_unlock(&md->mutex);
 420         return 0;
 421 }
 422
 423 static void mipid_disable(struct lcd_panel *panel)
 424 {
 425         struct mipid_device *md = to_mipid_device(panel);
 426
 427         /*
 428          * A final ESD work might be called before returning,
 429          * so do this without holding the lock.
 430          */
 431         mipid_esd_stop_check(md);
 432         mutex_lock(&md->mutex);
 433
 434         if (!md->enabled) {
 435                 mutex_unlock(&md->mutex);
 436                 return;
 437         }
 438         md->saved_bklight_level = mipid_get_bklight_level(panel);
 439         mipid_set_bklight_level(panel, 0);
 440         set_display_state(md, 0);
 441         set_sleep_mode(md, 1);
 442         md->enabled = 0;
 443
 444         mutex_unlock(&md->mutex);
 445 }
 446
 447 static int panel_enabled(struct mipid_device *md)
 448 {
 449         u32 disp_status;
 450         int enabled;
 451
 452         mipid_read(md, MIPID_CMD_READ_DISP_STATUS, (u8 *)&disp_status, 4);
 453         disp_status = __be32_to_cpu(disp_status);
 454         enabled = (disp_status & (1 << 17)) && (disp_status & (1 << 10));
 455         dev_dbg(&md->spi->dev,
 456                 "LCD panel %senabled by bootloader (status 0x%04x)\n",
 457                 enabled ? "" : "not ", disp_status);
 458         return enabled;
 459 }
 460
 461 static int mipid_init(struct lcd_panel *panel,
 462                             struct omapfb_device *fbdev)
 463 {
 464         struct mipid_device *md = to_mipid_device(panel);
 465
 466         md->fbdev = fbdev;
 467         INIT_DELAYED_WORK(&md->esd_work, mipid_esd_work);
 468         mutex_init(&md->mutex);
 469
 470         md->enabled = panel_enabled(md);
 471
 472         if (md->enabled)
 473                 mipid_esd_start_check(md);
 474         else
 475                 md->saved_bklight_level = mipid_get_bklight_level(panel);
 476
 477         return 0;
 478 }
 479
 480 static void mipid_cleanup(struct lcd_panel *panel)
 481 {
 482         struct mipid_device *md = to_mipid_device(panel);
 483
 484         if (md->enabled)
 485                 mipid_esd_stop_check(md);
 486 }
 487
 488 static const struct lcd_panel mipid_panel = {
 489         .config         = OMAP_LCDC_PANEL_TFT,
 490
 491         .bpp            = 16,
 492         .x_res          = 800,
 493         .y_res          = 480,
 494         .pixel_clock    = 21940,
 495         .hsw            = 50,
 496         .hfp            = 20,
 497         .hbp            = 15,
 498         .vsw            = 2,
 499         .vfp            = 1,
 500         .vbp            = 3,
 501
 502         .init                   = mipid_init,
 503         .cleanup                = mipid_cleanup,
 504         .enable                 = mipid_enable,
 505         .disable                = mipid_disable,
 506         .get_caps               = mipid_get_caps,
 507         .set_bklight_level      = mipid_set_bklight_level,
 508         .get_bklight_level      = mipid_get_bklight_level,
 509         .get_bklight_max        = mipid_get_bklight_max,
 510         .run_test               = mipid_run_test,
 511 };
 512
 513 static int mipid_detect(struct mipid_device *md)
 514 {
 515         struct mipid_platform_data *pdata;
 516         u8 display_id[3];
 517
 518         pdata = md->spi->dev.platform_data;
 519         if (pdata == NULL) {
 520                 dev_err(&md->spi->dev, "missing platform data\n");
 521                 return -ENOENT;
 522         }
 523
 524         mipid_read(md, MIPID_CMD_READ_DISP_ID, display_id, 3);
 525         dev_dbg(&md->spi->dev, "MIPI display ID: %02x%02x%02x\n",
 526                 display_id[0], display_id[1], display_id[2]);
 527
 528         switch (display_id[0]) {
 529         case 0x45:
 530                 md->panel.name = "lph8923";
 531                 break;
 532         case 0x83:
 533                 md->panel.name = "ls041y3";
 534                 md->esd_check = ls041y3_esd_check;
 535                 break;
 536         default:
 537                 md->panel.name = "unknown";
 538                 dev_err(&md->spi->dev, "invalid display ID\n");
 539                 return -ENODEV;
 540         }
 541
 542         md->revision = display_id[1];
 543         md->panel.data_lines = pdata->data_lines;
 544         pr_info("omapfb: %s rev %02x LCD detected, %d data lines\n",
 545                         md->panel.name, md->revision, md->panel.data_lines);
 546
 547         return 0;
 548 }
 549
 550 static int mipid_spi_probe(struct spi_device *spi)
 551 {
 552         struct mipid_device *md;
 553         int r;
 554
 555         md = kzalloc(sizeof(*md), GFP_KERNEL);
 556         if (md == NULL) {
 557                 dev_err(&spi->dev, "out of memory\n");
 558                 return -ENOMEM;
 559         }
 560
 561         /* This will de-assert RESET if active */
 562         md->reset = gpiod_get(&spi->dev, "reset", GPIOD_OUT_LOW);
 563         if (IS_ERR(md->reset))
 564                 return dev_err_probe(&spi->dev, PTR_ERR(md->reset),
 565                                      "no reset GPIO line\n");
 566
 567         spi->mode = SPI_MODE_0;
 568         md->spi = spi;
 569         dev_set_drvdata(&spi->dev, md);
 570         md->panel = mipid_panel;
 571
 572         r = mipid_detect(md);
 573         if (r < 0)
 574                 goto free_md;
 575
 576         omapfb_register_panel(&md->panel);
 577
 578         return 0;
 579
 580 free_md:
 581         kfree(md);
 582         return r;
 583 }
 584
 585 static void mipid_spi_remove(struct spi_device *spi)
 586 {
 587         struct mipid_device *md = dev_get_drvdata(&spi->dev);
 588
 589         /* Asserts RESET */
 590         gpiod_set_value(md->reset, 1);
 591         mipid_disable(&md->panel);
 592         kfree(md);
 593 }
 594
 595 static struct spi_driver mipid_spi_driver = {
 596         .driver = {
 597                 .name   = MIPID_MODULE_NAME,
 598         },
 599         .probe  = mipid_spi_probe,
 600         .remove = mipid_spi_remove,
 601 };
 602
 603 module_spi_driver(mipid_spi_driver);
 604
 605 MODULE_DESCRIPTION("MIPI display driver");
 606 MODULE_LICENSE("GPL");