Quelle  lcd_mipid.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * LCD driver for MIPI DBI-C / DCS compatible LCDs
 *
 * Copyright (C) 2006 Nokia Corporation
 * Author: Imre Deak <imre.deak@nokia.com>
 */
#include <linux/device.h>
#include <linux/delay.h>
#include <linux/gpio/consumer.h>
#include <linux/slab.h>
#include <linux/workqueue.h>
#include <linux/spi/spi.h>
#include <linux/module.h>

#include <linux/platform_data/lcd-mipid.h>

#include "omapfb.h"

#define MIPID_MODULE_NAME  "lcd_mipid"

#define MIPID_CMD_READ_DISP_ID  0x04
#define MIPID_CMD_READ_RED  0x06
#define MIPID_CMD_READ_GREEN  0x07
#define MIPID_CMD_READ_BLUE  0x08
#define MIPID_CMD_READ_DISP_STATUS 0x09
#define MIPID_CMD_RDDSDR  0x0F
#define MIPID_CMD_SLEEP_IN  0x10
#define MIPID_CMD_SLEEP_OUT  0x11
#define MIPID_CMD_DISP_OFF  0x28
#define MIPID_CMD_DISP_ON  0x29

#define MIPID_ESD_CHECK_PERIOD  msecs_to_jiffies(5000)

#define to_mipid_device(p)  container_of(p, struct mipid_device, \
      panel)
struct mipid_device {
 int  enabled;
 int  revision;
 unsigned int saved_bklight_level;
 unsigned long hw_guard_end;  /* next value of jiffies
   when we can issue the
   next sleep in/out command */
 unsigned long hw_guard_wait;  /* max guard time in jiffies */
 struct gpio_desc *reset;

 struct omapfb_device *fbdev;
 struct spi_device *spi;
 struct mutex  mutex;
 struct lcd_panel panel;

 struct delayed_work esd_work;
 void   (*esd_check)(struct mipid_device *m);
};

static void mipid_transfer(struct mipid_device *md, int cmd, const u8 *wbuf,
      int wlen, u8 *rbuf, int rlen)
{
 struct spi_message m;
 struct spi_transfer *x, xfer[4];
 u16   w;
 int   r;

 BUG_ON(md->spi == NULL);

 spi_message_init(&m);

 memset(xfer, 0, sizeof(xfer));
 x = &xfer[0];

 cmd &=  0xff;
 x->tx_buf  = &cmd;
 x->bits_per_word = 9;
 x->len   = 2;
 spi_message_add_tail(x, &m);

 if (wlen) {
  x++;
  x->tx_buf  = wbuf;
  x->len   = wlen;
  x->bits_per_word = 9;
  spi_message_add_tail(x, &m);
 }

 if (rlen) {
  x++;
  x->rx_buf = &w;
  x->len  = 1;
  spi_message_add_tail(x, &m);

  if (rlen > 1) {
   /* Arrange for the extra clock before the first
 * data bit.
 */
   x->bits_per_word = 9;
   x->len   = 2;

   x++;
   x->rx_buf  = &rbuf[1];
   x->len   = rlen - 1;
   spi_message_add_tail(x, &m);
  }
 }

 r = spi_sync(md->spi, &m);
 if (r < 0)
  dev_dbg(&md->spi->dev, "spi_sync %d\n", r);

 if (rlen)
  rbuf[0] = w & 0xff;
}

static inline void mipid_cmd(struct mipid_device *md, int cmd)
{
 mipid_transfer(md, cmd, NULL, 0, NULL, 0);
}

static inline void mipid_write(struct mipid_device *md,
          int reg, const u8 *buf, int len)
{
 mipid_transfer(md, reg, buf, len, NULL, 0);
}

static inline void mipid_read(struct mipid_device *md,
         int reg, u8 *buf, int len)
{
 mipid_transfer(md, reg, NULL, 0, buf, len);
}

static void set_data_lines(struct mipid_device *md, int data_lines)
{
 u16 par;

 switch (data_lines) {
 case 16:
  par = 0x150;
  break;
 case 18:
  par = 0x160;
  break;
 case 24:
  par = 0x170;
  break;
 }
 mipid_write(md, 0x3a, (u8 *)&par, 2);
}

static void send_init_string(struct mipid_device *md)
{
 u16 initpar[] = { 0x0102, 0x0100, 0x0100 };

 mipid_write(md, 0xc2, (u8 *)initpar, sizeof(initpar));
 set_data_lines(md, md->panel.data_lines);
}

static void hw_guard_start(struct mipid_device *md, int guard_msec)
{
 md->hw_guard_wait = msecs_to_jiffies(guard_msec);
 md->hw_guard_end = jiffies + md->hw_guard_wait;
}

static void hw_guard_wait(struct mipid_device *md)
{
 unsigned long wait = md->hw_guard_end - jiffies;

 if ((long)wait > 0 && time_before_eq(wait,  md->hw_guard_wait)) {
  set_current_state(TASK_UNINTERRUPTIBLE);
  schedule_timeout(wait);
 }
}

static void set_sleep_mode(struct mipid_device *md, int on)
{
 int cmd, sleep_time = 50;

 if (on)
  cmd = MIPID_CMD_SLEEP_IN;
 else
  cmd = MIPID_CMD_SLEEP_OUT;
 hw_guard_wait(md);
 mipid_cmd(md, cmd);
 hw_guard_start(md, 120);
 /*
 * When we enable the panel, it seems we _have_ to sleep
 * 120 ms before sending the init string. When disabling the
 * panel we'll sleep for the duration of 2 frames, so that the
 * controller can still provide the PCLK,HS,VS signals.
 */
 if (!on)
  sleep_time = 120;
 msleep(sleep_time);
}

static void set_display_state(struct mipid_device *md, int enabled)
{
 int cmd = enabled ? MIPID_CMD_DISP_ON : MIPID_CMD_DISP_OFF;

 mipid_cmd(md, cmd);
}

static int mipid_set_bklight_level(struct lcd_panel *panel, unsigned int level)
{
 struct mipid_device *md = to_mipid_device(panel);
 struct mipid_platform_data *pd = md->spi->dev.platform_data;

 if (pd->get_bklight_max == NULL || pd->set_bklight_level == NULL)
  return -ENODEV;
 if (level > pd->get_bklight_max(pd))
  return -EINVAL;
 if (!md->enabled) {
  md->saved_bklight_level = level;
  return 0;
 }
 pd->set_bklight_level(pd, level);

 return 0;
}

static unsigned int mipid_get_bklight_level(struct lcd_panel *panel)
{
 struct mipid_device *md = to_mipid_device(panel);
 struct mipid_platform_data *pd = md->spi->dev.platform_data;

 if (pd->get_bklight_level == NULL)
  return -ENODEV;
 return pd->get_bklight_level(pd);
}

static unsigned int mipid_get_bklight_max(struct lcd_panel *panel)
{
 struct mipid_device *md = to_mipid_device(panel);
 struct mipid_platform_data *pd = md->spi->dev.platform_data;

 if (pd->get_bklight_max == NULL)
  return -ENODEV;

 return pd->get_bklight_max(pd);
}

static unsigned long mipid_get_caps(struct lcd_panel *panel)
{
 return OMAPFB_CAPS_SET_BACKLIGHT;
}

static u16 read_first_pixel(struct mipid_device *md)
{
 u16 pixel;
 u8 red, green, blue;

 mutex_lock(&md->mutex);
 mipid_read(md, MIPID_CMD_READ_RED, &red, 1);
 mipid_read(md, MIPID_CMD_READ_GREEN, &green, 1);
 mipid_read(md, MIPID_CMD_READ_BLUE, &blue, 1);
 mutex_unlock(&md->mutex);

 switch (md->panel.data_lines) {
 case 16:
  pixel = ((red >> 1) << 11) | (green << 5) | (blue >> 1);
  break;
 case 24:
  /* 24 bit -> 16 bit */
  pixel = ((red >> 3) << 11) | ((green >> 2) << 5) |
   (blue >> 3);
  break;
 default:
  pixel = 0;
  BUG();
 }

 return pixel;
}

static int mipid_run_test(struct lcd_panel *panel, int test_num)
{
 struct mipid_device *md = to_mipid_device(panel);
 static const u16 test_values[4] = {
  0x0000, 0xffff, 0xaaaa, 0x5555,
 };
 int i;

 if (test_num != MIPID_TEST_RGB_LINES)
  return MIPID_TEST_INVALID;

 for (i = 0; i < ARRAY_SIZE(test_values); i++) {
  int delay;
  unsigned long tmo;

  omapfb_write_first_pixel(md->fbdev, test_values[i]);
  tmo = jiffies + msecs_to_jiffies(100);
  delay = 25;
  while (1) {
   u16 pixel;

   msleep(delay);
   pixel = read_first_pixel(md);
   if (pixel == test_values[i])
    break;
   if (time_after(jiffies, tmo)) {
    dev_err(&md->spi->dev,
     "MIPI LCD RGB I/F test failed: "
     "expecting %04x, got %04x\n",
     test_values[i], pixel);
    return MIPID_TEST_FAILED;
   }
   delay = 10;
  }
 }

 return 0;
}

static void ls041y3_esd_recover(struct mipid_device *md)
{
 dev_err(&md->spi->dev, "performing LCD ESD recovery\n");
 set_sleep_mode(md, 1);
 set_sleep_mode(md, 0);
}

static void ls041y3_esd_check_mode1(struct mipid_device *md)
{
 u8 state1, state2;

 mipid_read(md, MIPID_CMD_RDDSDR, &state1, 1);
 set_sleep_mode(md, 0);
 mipid_read(md, MIPID_CMD_RDDSDR, &state2, 1);
 dev_dbg(&md->spi->dev, "ESD mode 1 state1 %02x state2 %02x\n",
  state1, state2);
 /* Each sleep out command will trigger a self diagnostic and flip
* Bit6 if the test passes.
*/
 if (!((state1 ^ state2) & (1 << 6)))
  ls041y3_esd_recover(md);
}

static void ls041y3_esd_check_mode2(struct mipid_device *md)
{
 int i;
 u8 rbuf[2];
 static const struct {
  int cmd;
  int wlen;
  u16 wbuf[3];
 } *rd, rd_ctrl[7] = {
  { 0xb0, 4, { 0x0101, 0x01fe, } },
  { 0xb1, 4, { 0x01de, 0x0121, } },
  { 0xc2, 4, { 0x0100, 0x0100, } },
  { 0xbd, 2, { 0x0100, } },
  { 0xc2, 4, { 0x01fc, 0x0103, } },
  { 0xb4, 0, },
  { 0x00, 0, },
 };

 rd = rd_ctrl;
 for (i = 0; i < 3; i++, rd++)
  mipid_write(md, rd->cmd, (u8 *)rd->wbuf, rd->wlen);

 udelay(10);
 mipid_read(md, rd->cmd, rbuf, 2);
 rd++;

 for (i = 0; i < 3; i++, rd++) {
  udelay(10);
  mipid_write(md, rd->cmd, (u8 *)rd->wbuf, rd->wlen);
 }

 dev_dbg(&md->spi->dev, "ESD mode 2 state %02x\n", rbuf[1]);
 if (rbuf[1] == 0x00)
  ls041y3_esd_recover(md);
}

static void ls041y3_esd_check(struct mipid_device *md)
{
 ls041y3_esd_check_mode1(md);
 if (md->revision >= 0x88)
  ls041y3_esd_check_mode2(md);
}

static void mipid_esd_start_check(struct mipid_device *md)
{
 if (md->esd_check != NULL)
  schedule_delayed_work(&md->esd_work,
       MIPID_ESD_CHECK_PERIOD);
}

static void mipid_esd_stop_check(struct mipid_device *md)
{
 if (md->esd_check != NULL)
  cancel_delayed_work_sync(&md->esd_work);
}

static void mipid_esd_work(struct work_struct *work)
{
 struct mipid_device *md = container_of(work, struct mipid_device,
            esd_work.work);

 mutex_lock(&md->mutex);
 md->esd_check(md);
 mutex_unlock(&md->mutex);
 mipid_esd_start_check(md);
}

static int mipid_enable(struct lcd_panel *panel)
{
 struct mipid_device *md = to_mipid_device(panel);

 mutex_lock(&md->mutex);

 if (md->enabled) {
  mutex_unlock(&md->mutex);
  return 0;
 }
 set_sleep_mode(md, 0);
 md->enabled = 1;
 send_init_string(md);
 set_display_state(md, 1);
 mipid_set_bklight_level(panel, md->saved_bklight_level);
 mipid_esd_start_check(md);

 mutex_unlock(&md->mutex);
 return 0;
}

static void mipid_disable(struct lcd_panel *panel)
{
 struct mipid_device *md = to_mipid_device(panel);

 /*
 * A final ESD work might be called before returning,
 * so do this without holding the lock.
 */
 mipid_esd_stop_check(md);
 mutex_lock(&md->mutex);

 if (!md->enabled) {
  mutex_unlock(&md->mutex);
  return;
 }
 md->saved_bklight_level = mipid_get_bklight_level(panel);
 mipid_set_bklight_level(panel, 0);
 set_display_state(md, 0);
 set_sleep_mode(md, 1);
 md->enabled = 0;

 mutex_unlock(&md->mutex);
}

static int panel_enabled(struct mipid_device *md)
{
 u32 disp_status;
 int enabled;

 mipid_read(md, MIPID_CMD_READ_DISP_STATUS, (u8 *)&disp_status, 4);
 disp_status = __be32_to_cpu(disp_status);
 enabled = (disp_status & (1 << 17)) && (disp_status & (1 << 10));
 dev_dbg(&md->spi->dev,
  "LCD panel %senabled by bootloader (status 0x%04x)\n",
  enabled ? "" : "not ", disp_status);
 return enabled;
}

static int mipid_init(struct lcd_panel *panel,
       struct omapfb_device *fbdev)
{
 struct mipid_device *md = to_mipid_device(panel);

 md->fbdev = fbdev;
 INIT_DELAYED_WORK(&md->esd_work, mipid_esd_work);
 mutex_init(&md->mutex);

 md->enabled = panel_enabled(md);

 if (md->enabled)
  mipid_esd_start_check(md);
 else
  md->saved_bklight_level = mipid_get_bklight_level(panel);

 return 0;
}

static void mipid_cleanup(struct lcd_panel *panel)
{
 struct mipid_device *md = to_mipid_device(panel);

 if (md->enabled)
  mipid_esd_stop_check(md);
}

static const struct lcd_panel mipid_panel = {
 .config  = OMAP_LCDC_PANEL_TFT,

 .bpp  = 16,
 .x_res  = 800,
 .y_res  = 480,
 .pixel_clock = 21940,
 .hsw  = 50,
 .hfp  = 20,
 .hbp  = 15,
 .vsw  = 2,
 .vfp  = 1,
 .vbp  = 3,

 .init   = mipid_init,
 .cleanup  = mipid_cleanup,
 .enable   = mipid_enable,
 .disable  = mipid_disable,
 .get_caps  = mipid_get_caps,
 .set_bklight_level = mipid_set_bklight_level,
 .get_bklight_level = mipid_get_bklight_level,
 .get_bklight_max = mipid_get_bklight_max,
 .run_test  = mipid_run_test,
};

static int mipid_detect(struct mipid_device *md)
{
 struct mipid_platform_data *pdata;
 u8 display_id[3];

 pdata = md->spi->dev.platform_data;
 if (pdata == NULL) {
  dev_err(&md->spi->dev, "missing platform data\n");
  return -ENOENT;
 }

 mipid_read(md, MIPID_CMD_READ_DISP_ID, display_id, 3);
 dev_dbg(&md->spi->dev, "MIPI display ID: %02x%02x%02x\n",
  display_id[0], display_id[1], display_id[2]);

 switch (display_id[0]) {
 case 0x45:
  md->panel.name = "lph8923";
  break;
 case 0x83:
  md->panel.name = "ls041y3";
  md->esd_check = ls041y3_esd_check;
  break;
 default:
  md->panel.name = "unknown";
  dev_err(&md->spi->dev, "invalid display ID\n");
  return -ENODEV;
 }

 md->revision = display_id[1];
 md->panel.data_lines = pdata->data_lines;
 pr_info("omapfb: %s rev %02x LCD detected, %d data lines\n",
   md->panel.name, md->revision, md->panel.data_lines);

 return 0;
}

static int mipid_spi_probe(struct spi_device *spi)
{
 struct mipid_device *md;
 int r;

 md = kzalloc(sizeof(*md), GFP_KERNEL);
 if (md == NULL) {
  dev_err(&spi->dev, "out of memory\n");
  return -ENOMEM;
 }

 /* This will de-assert RESET if active */
 md->reset = gpiod_get(&spi->dev, "reset", GPIOD_OUT_LOW);
 if (IS_ERR(md->reset))
  return dev_err_probe(&spi->dev, PTR_ERR(md->reset),
         "no reset GPIO line\n");

 spi->mode = SPI_MODE_0;
 md->spi = spi;
 dev_set_drvdata(&spi->dev, md);
 md->panel = mipid_panel;

 r = mipid_detect(md);
 if (r < 0)
  goto free_md;

 omapfb_register_panel(&md->panel);

 return 0;

free_md:
 kfree(md);
 return r;
}

static void mipid_spi_remove(struct spi_device *spi)
{
 struct mipid_device *md = dev_get_drvdata(&spi->dev);

 /* Asserts RESET */
 gpiod_set_value(md->reset, 1);
 mipid_disable(&md->panel);
 kfree(md);
}

static struct spi_driver mipid_spi_driver = {
 .driver = {
  .name = MIPID_MODULE_NAME,
 },
 .probe = mipid_spi_probe,
 .remove = mipid_spi_remove,
};

module_spi_driver(mipid_spi_driver);

MODULE_DESCRIPTION("MIPI display driver");
MODULE_LICENSE("GPL");