drivers/gpu/drm/panel/panel-ilitek-ili9322.c

   1 /*
   2  * Ilitek ILI9322 TFT LCD drm_panel driver.
   3  *
   4  * This panel can be configured to support:
   5  * - 8-bit serial RGB interface
   6  * - 24-bit parallel RGB interface
   7  * - 8-bit ITU-R BT.601 interface
   8  * - 8-bit ITU-R BT.656 interface
   9  * - Up to 320RGBx240 dots resolution TFT LCD displays
  10  * - Scaling, brightness and contrast
  11  *
  12  * The scaling means that the display accepts a 640x480 or 720x480
  13  * input and rescales it to fit to the 320x240 display. So what we
  14  * present to the system is something else than what comes out on the
  15  * actual display.
  16  *
  17  * Copyright (C) 2017 Linus Walleij <linus.walleij@linaro.org>
  18  * Derived from drivers/drm/gpu/panel/panel-samsung-ld9040.c
  19  *
  20  * This program is free software; you can redistribute it and/or modify
  21  * it under the terms of the GNU General Public License version 2 as
  22  * published by the Free Software Foundation.
  23  */
  24
  25 #include <drm/drmP.h>
  26 #include <drm/drm_panel.h>
  27
  28 #include <linux/of_device.h>
  29 #include <linux/bitops.h>
  30 #include <linux/gpio/consumer.h>
  31 #include <linux/module.h>
  32 #include <linux/regmap.h>
  33 #include <linux/regulator/consumer.h>
  34 #include <linux/spi/spi.h>
  35
  36 #include <video/mipi_display.h>
  37 #include <video/of_videomode.h>
  38 #include <video/videomode.h>
  39
  40 #define ILI9322_CHIP_ID                 0x00
  41 #define ILI9322_CHIP_ID_MAGIC           0x96
  42
  43 /*
  44  * Voltage on the communication interface, from 0.7 (0x00)
  45  * to 1.32 (0x1f) times the VREG1OUT voltage in 2% increments.
  46  * 1.00 (0x0f) is the default.
  47  */
  48 #define ILI9322_VCOM_AMP                0x01
  49
  50 /*
  51  * High voltage on the communication signals, from 0.37 (0x00) to
  52  * 1.0 (0x3f) times the VREGOUT1 voltage in 1% increments.
  53  * 0.83 (0x2e) is the default.
  54  */
  55 #define ILI9322_VCOM_HIGH               0x02
  56
  57 /*
  58  * VREG1 voltage regulator from 3.6V (0x00) to 6.0V (0x18) in 0.1V
  59  * increments. 5.4V (0x12) is the default. This is the reference
  60  * voltage for the VCOM levels and the greyscale level.
  61  */
  62 #define ILI9322_VREG1_VOLTAGE           0x03
  63
  64 /* Describes the incoming signal */
  65 #define ILI9322_ENTRY                   0x06
  66 /* 0 = right-to-left, 1 = left-to-right (default), horizontal flip */
  67 #define ILI9322_ENTRY_HDIR              BIT(0)
  68 /* 0 = down-to-up, 1 = up-to-down (default), vertical flip  */
  69 #define ILI9322_ENTRY_VDIR              BIT(1)
  70 /* NTSC, PAL or autodetect */
  71 #define ILI9322_ENTRY_NTSC              (0 << 2)
  72 #define ILI9322_ENTRY_PAL               (1 << 2)
  73 #define ILI9322_ENTRY_AUTODETECT        (3 << 2)
  74 /* Input format */
  75 #define ILI9322_ENTRY_SERIAL_RGB_THROUGH (0 << 4)
  76 #define ILI9322_ENTRY_SERIAL_RGB_ALIGNED (1 << 4)
  77 #define ILI9322_ENTRY_SERIAL_RGB_DUMMY_320X240 (2 << 4)
  78 #define ILI9322_ENTRY_SERIAL_RGB_DUMMY_360X240 (3 << 4)
  79 #define ILI9322_ENTRY_DISABLE_1         (4 << 4)
  80 #define ILI9322_ENTRY_PARALLEL_RGB_THROUGH (5 << 4)
  81 #define ILI9322_ENTRY_PARALLEL_RGB_ALIGNED (6 << 4)
  82 #define ILI9322_ENTRY_YUV_640Y_320CBCR_25_54_MHZ (7 << 4)
  83 #define ILI9322_ENTRY_YUV_720Y_360CBCR_27_MHZ (8 << 4)
  84 #define ILI9322_ENTRY_DISABLE_2         (9 << 4)
  85 #define ILI9322_ENTRY_ITU_R_BT_656_720X360 (10 << 4)
  86 #define ILI9322_ENTRY_ITU_R_BT_656_640X320 (11 << 4)
  87
  88 /* Power control */
  89 #define ILI9322_POW_CTRL                0x07
  90 #define ILI9322_POW_CTRL_STB            BIT(0) /* 0 = standby, 1 = normal */
  91 #define ILI9322_POW_CTRL_VGL            BIT(1) /* 0 = off, 1 = on  */
  92 #define ILI9322_POW_CTRL_VGH            BIT(2) /* 0 = off, 1 = on  */
  93 #define ILI9322_POW_CTRL_DDVDH          BIT(3) /* 0 = off, 1 = on  */
  94 #define ILI9322_POW_CTRL_VCOM           BIT(4) /* 0 = off, 1 = on  */
  95 #define ILI9322_POW_CTRL_VCL            BIT(5) /* 0 = off, 1 = on  */
  96 #define ILI9322_POW_CTRL_AUTO           BIT(6) /* 0 = interactive, 1 = auto */
  97 #define ILI9322_POW_CTRL_STANDBY        (ILI9322_POW_CTRL_VGL | \
  98                                          ILI9322_POW_CTRL_VGH | \
  99                                          ILI9322_POW_CTRL_DDVDH | \
 100                                          ILI9322_POW_CTRL_VCL | \
 101                                          ILI9322_POW_CTRL_AUTO | \
 102                                          BIT(7))
 103 #define ILI9322_POW_CTRL_DEFAULT        (ILI9322_POW_CTRL_STANDBY | \
 104                                          ILI9322_POW_CTRL_STB)
 105
 106 /* Vertical back porch bits 0..5 */
 107 #define ILI9322_VBP                     0x08
 108
 109 /* Horizontal back porch, 8 bits */
 110 #define ILI9322_HBP                     0x09
 111
 112 /*
 113  * Polarity settings:
 114  * 1 = positive polarity
 115  * 0 = negative polarity
 116  */
 117 #define ILI9322_POL                     0x0a
 118 #define ILI9322_POL_DCLK                BIT(0) /* 1 default */
 119 #define ILI9322_POL_HSYNC               BIT(1) /* 0 default */
 120 #define ILI9322_POL_VSYNC               BIT(2) /* 0 default */
 121 #define ILI9322_POL_DE                  BIT(3) /* 1 default */
 122 /*
 123  * 0 means YCBCR are ordered Cb0,Y0,Cr0,Y1,Cb2,Y2,Cr2,Y3 (default)
 124  *   in RGB mode this means RGB comes in RGBRGB
 125  * 1 means YCBCR are ordered Cr0,Y0,Cb0,Y1,Cr2,Y2,Cb2,Y3
 126  *   in RGB mode this means RGB comes in BGRBGR
 127  */
 128 #define ILI9322_POL_YCBCR_MODE          BIT(4)
 129 /* Formula A for YCbCR->RGB = 0, Formula B = 1 */
 130 #define ILI9322_POL_FORMULA             BIT(5)
 131 /* Reverse polarity: 0 = 0..255, 1 = 255..0 */
 132 #define ILI9322_POL_REV                 BIT(6)
 133
 134 #define ILI9322_IF_CTRL                 0x0b
 135 #define ILI9322_IF_CTRL_HSYNC_VSYNC     0x00
 136 #define ILI9322_IF_CTRL_HSYNC_VSYNC_DE  BIT(2)
 137 #define ILI9322_IF_CTRL_DE_ONLY         BIT(3)
 138 #define ILI9322_IF_CTRL_SYNC_DISABLED   (BIT(2) | BIT(3))
 139 #define ILI9322_IF_CTRL_LINE_INVERSION  BIT(0) /* Not set means frame inv */
 140
 141 #define ILI9322_GLOBAL_RESET            0x04
 142 #define ILI9322_GLOBAL_RESET_ASSERT     0x00 /* bit 0 = 0 -> reset */
 143
 144 /*
 145  * 4+4 bits of negative and positive gamma correction
 146  * Upper nybble, bits 4-7 are negative gamma
 147  * Lower nybble, bits 0-3 are positive gamma
 148  */
 149 #define ILI9322_GAMMA_1                 0x10
 150 #define ILI9322_GAMMA_2                 0x11
 151 #define ILI9322_GAMMA_3                 0x12
 152 #define ILI9322_GAMMA_4                 0x13
 153 #define ILI9322_GAMMA_5                 0x14
 154 #define ILI9322_GAMMA_6                 0x15
 155 #define ILI9322_GAMMA_7                 0x16
 156 #define ILI9322_GAMMA_8                 0x17
 157
 158 /**
 159  * enum ili9322_input - the format of the incoming signal to the panel
 160  *
 161  * The panel can be connected to various input streams and four of them can
 162  * be selected by electronic straps on the display. However it is possible
 163  * to select another mode or override the electronic default with this
 164  * setting.
 165  */
 166 enum ili9322_input {
 167         ILI9322_INPUT_SRGB_THROUGH = 0x0,
 168         ILI9322_INPUT_SRGB_ALIGNED = 0x1,
 169         ILI9322_INPUT_SRGB_DUMMY_320X240 = 0x2,
 170         ILI9322_INPUT_SRGB_DUMMY_360X240 = 0x3,
 171         ILI9322_INPUT_DISABLED_1 = 0x4,
 172         ILI9322_INPUT_PRGB_THROUGH = 0x5,
 173         ILI9322_INPUT_PRGB_ALIGNED = 0x6,
 174         ILI9322_INPUT_YUV_640X320_YCBCR = 0x7,
 175         ILI9322_INPUT_YUV_720X360_YCBCR = 0x8,
 176         ILI9322_INPUT_DISABLED_2 = 0x9,
 177         ILI9322_INPUT_ITU_R_BT656_720X360_YCBCR = 0xa,
 178         ILI9322_INPUT_ITU_R_BT656_640X320_YCBCR = 0xb,
 179         ILI9322_INPUT_UNKNOWN = 0xc,
 180 };
 181
 182 static const char * const ili9322_inputs[] = {
 183         "8 bit serial RGB through",
 184         "8 bit serial RGB aligned",
 185         "8 bit serial RGB dummy 320x240",
 186         "8 bit serial RGB dummy 360x240",
 187         "disabled 1",
 188         "24 bit parallel RGB through",
 189         "24 bit parallel RGB aligned",
 190         "24 bit YUV 640Y 320CbCr",
 191         "24 bit YUV 720Y 360CbCr",
 192         "disabled 2",
 193         "8 bit ITU-R BT.656 720Y 360CbCr",
 194         "8 bit ITU-R BT.656 640Y 320CbCr",
 195 };
 196
 197 /**
 198  * struct ili9322_config - the system specific ILI9322 configuration
 199  * @width_mm: physical panel width [mm]
 200  * @height_mm: physical panel height [mm]
 201  * @flip_horizontal: flip the image horizontally (right-to-left scan)
 202  * (only in RGB and YUV modes)
 203  * @flip_vertical: flip the image vertically (down-to-up scan)
 204  * (only in RGB and YUV modes)
 205  * @input: the input/entry type used in this system, if this is set to
 206  * ILI9322_INPUT_UNKNOWN the driver will try to figure it out by probing
 207  * the hardware
 208  * @vreg1out_mv: the output in microvolts for the VREGOUT1 regulator used
 209  * to drive the physical display. Valid ranges are 3600 thru 6000 in 100
 210  * microvolt increments. If not specified, hardware defaults will be
 211  * used (4.5V).
 212  * @vcom_high_percent: the percentage of VREGOUT1 used for the peak
 213  * voltage on the communications link. Valid ranges are 37 thru 100
 214  * percent. If not specified, hardware defaults will be used (91%).
 215  * @vcom_amplitude_percent: the percentage of VREGOUT1 used for the
 216  * peak-to-peak amplitude of the communcation signals to the physical
 217  * display. Valid ranges are 70 thru 132 percent in increments if two
 218  * percent. Odd percentages will be truncated. If not specified, hardware
 219  * defaults will be used (114%).
 220  * @dclk_active_high: data/pixel clock active high, data will be clocked
 221  * in on the rising edge of the DCLK (this is usually the case).
 222  * @syncmode: The synchronization mode, what sync signals are emitted.
 223  * See the enum for details.
 224  * @de_active_high: DE (data entry) is active high
 225  * @hsync_active_high: HSYNC is active high
 226  * @vsync_active_high: VSYNC is active high
 227  * @gamma_corr_pos: a set of 8 nybbles describing positive
 228  * gamma correction for voltages V1 thru V8. Valid range 0..15
 229  * @gamma_corr_neg: a set of 8 nybbles describing negative
 230  * gamma correction for voltages V1 thru V8. Valid range 0..15
 231  *
 232  * These adjust what grayscale voltage will be output for input data V1 = 0,
 233  * V2 = 16, V3 = 48, V4 = 96, V5 = 160, V6 = 208, V7 = 240 and V8 = 255.
 234  * The curve is shaped like this:
 235  *
 236  *  ^
 237  *  |                                                        V8
 238  *  |                                                   V7
 239  *  |                                          V6
 240  *  |                               V5
 241  *  |                    V4
 242  *  |            V3
 243  *  |     V2
 244  *  | V1
 245  *  +----------------------------------------------------------->
 246  *    0   16     48      96         160        208      240  255
 247  *
 248  * The negative and postive gamma values adjust the V1 thru V8 up/down
 249  * according to the datasheet specifications. This is a property of the
 250  * physical display connected to the display controller and may vary.
 251  * If defined, both arrays must be supplied in full. If the properties
 252  * are not supplied, hardware defaults will be used.
 253  */
 254 struct ili9322_config {
 255         u32 width_mm;
 256         u32 height_mm;
 257         bool flip_horizontal;
 258         bool flip_vertical;
 259         enum ili9322_input input;
 260         u32 vreg1out_mv;
 261         u32 vcom_high_percent;
 262         u32 vcom_amplitude_percent;
 263         bool dclk_active_high;
 264         bool de_active_high;
 265         bool hsync_active_high;
 266         bool vsync_active_high;
 267         u8 syncmode;
 268         u8 gamma_corr_pos[8];
 269         u8 gamma_corr_neg[8];
 270 };
 271
 272 struct ili9322 {
 273         struct device *dev;
 274         const struct ili9322_config *conf;
 275         struct drm_panel panel;
 276         struct regmap *regmap;
 277         struct regulator_bulk_data supplies[3];
 278         struct gpio_desc *reset_gpio;
 279         enum ili9322_input input;
 280         struct videomode vm;
 281         u8 gamma[8];
 282         u8 vreg1out;
 283         u8 vcom_high;
 284         u8 vcom_amplitude;
 285 };
 286
 287 static inline struct ili9322 *panel_to_ili9322(struct drm_panel *panel)
 288 {
 289         return container_of(panel, struct ili9322, panel);
 290 }
 291
 292 static int ili9322_regmap_spi_write(void *context, const void *data,
 293                                     size_t count)
 294 {
 295         struct device *dev = context;
 296         struct spi_device *spi = to_spi_device(dev);
 297         u8 buf[2];
 298
 299         /* Clear bit 7 to write */
 300         memcpy(buf, data, 2);
 301         buf[0] &= ~0x80;
 302
 303         dev_dbg(dev, "WRITE: %02x %02x\n", buf[0], buf[1]);
 304         return spi_write_then_read(spi, buf, 2, NULL, 0);
 305 }
 306
 307 static int ili9322_regmap_spi_read(void *context, const void *reg,
 308                                    size_t reg_size, void *val, size_t val_size)
 309 {
 310         struct device *dev = context;
 311         struct spi_device *spi = to_spi_device(dev);
 312         u8 buf[1];
 313
 314         /* Set bit 7 to 1 to read */
 315         memcpy(buf, reg, 1);
 316         dev_dbg(dev, "READ: %02x reg size = %zu, val size = %zu\n",
 317                 buf[0], reg_size, val_size);
 318         buf[0] |= 0x80;
 319
 320         return spi_write_then_read(spi, buf, 1, val, 1);
 321 }
 322
 323 static struct regmap_bus ili9322_regmap_bus = {
 324         .write = ili9322_regmap_spi_write,
 325         .read = ili9322_regmap_spi_read,
 326         .reg_format_endian_default = REGMAP_ENDIAN_BIG,
 327         .val_format_endian_default = REGMAP_ENDIAN_BIG,
 328 };
 329
 330 static bool ili9322_volatile_reg(struct device *dev, unsigned int reg)
 331 {
 332         return false;
 333 }
 334
 335 static bool ili9322_writeable_reg(struct device *dev, unsigned int reg)
 336 {
 337         /* Just register 0 is read-only */
 338         if (reg == 0x00)
 339                 return false;
 340         return true;
 341 }
 342
 343 static const struct regmap_config ili9322_regmap_config = {
 344         .reg_bits = 8,
 345         .val_bits = 8,
 346         .max_register = 0x44,
 347         .cache_type = REGCACHE_RBTREE,
 348         .volatile_reg = ili9322_volatile_reg,
 349         .writeable_reg = ili9322_writeable_reg,
 350 };
 351
 352 static int ili9322_init(struct drm_panel *panel, struct ili9322 *ili)
 353 {
 354         struct drm_connector *connector = panel->connector;
 355         u8 reg;
 356         int ret;
 357         int i;
 358
 359         /* Reset display */
 360         ret = regmap_write(ili->regmap, ILI9322_GLOBAL_RESET,
 361                            ILI9322_GLOBAL_RESET_ASSERT);
 362         if (ret) {
 363                 dev_err(ili->dev, "can't issue GRESET (%d)\n", ret);
 364                 return ret;
 365         }
 366
 367         /* Set up the main voltage regulator */
 368         if (ili->vreg1out != U8_MAX) {
 369                 ret = regmap_write(ili->regmap, ILI9322_VREG1_VOLTAGE,
 370                                    ili->vreg1out);
 371                 if (ret) {
 372                         dev_err(ili->dev, "can't set up VREG1OUT (%d)\n", ret);
 373                         return ret;
 374                 }
 375         }
 376
 377         if (ili->vcom_amplitude != U8_MAX) {
 378                 ret = regmap_write(ili->regmap, ILI9322_VCOM_AMP,
 379                                    ili->vcom_amplitude);
 380                 if (ret) {
 381                         dev_err(ili->dev,
 382                                 "can't set up VCOM amplitude (%d)\n", ret);
 383                         return ret;
 384                 }
 385         };
 386
 387         if (ili->vcom_high != U8_MAX) {
 388                 ret = regmap_write(ili->regmap, ILI9322_VCOM_HIGH,
 389                                    ili->vcom_high);
 390                 if (ret) {
 391                         dev_err(ili->dev, "can't set up VCOM high (%d)\n", ret);
 392                         return ret;
 393                 }
 394         };
 395
 396         /* Set up gamma correction */
 397         for (i = 0; i < ARRAY_SIZE(ili->gamma); i++) {
 398                 ret = regmap_write(ili->regmap, ILI9322_GAMMA_1 + i,
 399                                    ili->gamma[i]);
 400                 if (ret) {
 401                         dev_err(ili->dev,
 402                                 "can't write gamma V%d to 0x%02x (%d)\n",
 403                                 i + 1, ILI9322_GAMMA_1 + i, ret);
 404                         return ret;
 405                 }
 406         }
 407
 408         /*
 409          * Polarity and inverted color order for RGB input.
 410          * None of this applies in the BT.656 mode.
 411          */
 412         if (ili->conf->dclk_active_high) {
 413                 reg = ILI9322_POL_DCLK;
 414                 connector->display_info.bus_flags |=
 415                         DRM_BUS_FLAG_PIXDATA_POSEDGE;
 416         } else {
 417                 reg = 0;
 418                 connector->display_info.bus_flags |=
 419                         DRM_BUS_FLAG_PIXDATA_NEGEDGE;
 420         }
 421         if (ili->conf->de_active_high) {
 422                 reg |= ILI9322_POL_DE;
 423                 connector->display_info.bus_flags |=
 424                         DRM_BUS_FLAG_DE_HIGH;
 425         } else {
 426                 connector->display_info.bus_flags |=
 427                         DRM_BUS_FLAG_DE_LOW;
 428         }
 429         if (ili->conf->hsync_active_high)
 430                 reg |= ILI9322_POL_HSYNC;
 431         if (ili->conf->vsync_active_high)
 432                 reg |= ILI9322_POL_VSYNC;
 433         ret = regmap_write(ili->regmap, ILI9322_POL, reg);
 434         if (ret) {
 435                 dev_err(ili->dev, "can't write POL register (%d)\n", ret);
 436                 return ret;
 437         }
 438
 439         /*
 440          * Set up interface control.
 441          * This is not used in the BT.656 mode (no H/Vsync or DE signals).
 442          */
 443         reg = ili->conf->syncmode;
 444         reg |= ILI9322_IF_CTRL_LINE_INVERSION;
 445         ret = regmap_write(ili->regmap, ILI9322_IF_CTRL, reg);
 446         if (ret) {
 447                 dev_err(ili->dev, "can't write IF CTRL register (%d)\n", ret);
 448                 return ret;
 449         }
 450
 451         /* Set up the input mode */
 452         reg = (ili->input << 4);
 453         /* These are inverted, setting to 1 is the default, clearing flips */
 454         if (!ili->conf->flip_horizontal)
 455                 reg |= ILI9322_ENTRY_HDIR;
 456         if (!ili->conf->flip_vertical)
 457                 reg |= ILI9322_ENTRY_VDIR;
 458         reg |= ILI9322_ENTRY_AUTODETECT;
 459         ret = regmap_write(ili->regmap, ILI9322_ENTRY, reg);
 460         if (ret) {
 461                 dev_err(ili->dev, "can't write ENTRY reg (%d)\n", ret);
 462                 return ret;
 463         }
 464         dev_info(ili->dev, "display is in %s mode, syncmode %02x\n",
 465                  ili9322_inputs[ili->input],
 466                  ili->conf->syncmode);
 467
 468         dev_info(ili->dev, "initialized display\n");
 469
 470         return 0;
 471 }
 472
 473 /*
 474  * This power-on sequence if from the datasheet, page 57.
 475  */
 476 static int ili9322_power_on(struct ili9322 *ili)
 477 {
 478         int ret;
 479
 480         /* Assert RESET */
 481         gpiod_set_value(ili->reset_gpio, 1);
 482
 483         ret = regulator_bulk_enable(ARRAY_SIZE(ili->supplies), ili->supplies);
 484         if (ret < 0) {
 485                 dev_err(ili->dev, "unable to enable regulators\n");
 486                 return ret;
 487         }
 488         msleep(20);
 489
 490         /* De-assert RESET */
 491         gpiod_set_value(ili->reset_gpio, 0);
 492
 493         msleep(10);
 494
 495         return 0;
 496 }
 497
 498 static int ili9322_power_off(struct ili9322 *ili)
 499 {
 500         return regulator_bulk_disable(ARRAY_SIZE(ili->supplies), ili->supplies);
 501 }
 502
 503 static int ili9322_disable(struct drm_panel *panel)
 504 {
 505         struct ili9322 *ili = panel_to_ili9322(panel);
 506         int ret;
 507
 508         ret = regmap_write(ili->regmap, ILI9322_POW_CTRL,
 509                            ILI9322_POW_CTRL_STANDBY);
 510         if (ret) {
 511                 dev_err(ili->dev, "unable to go to standby mode\n");
 512                 return ret;
 513         }
 514
 515         return 0;
 516 }
 517
 518 static int ili9322_unprepare(struct drm_panel *panel)
 519 {
 520         struct ili9322 *ili = panel_to_ili9322(panel);
 521
 522         return ili9322_power_off(ili);
 523 }
 524
 525 static int ili9322_prepare(struct drm_panel *panel)
 526 {
 527         struct ili9322 *ili = panel_to_ili9322(panel);
 528         int ret;
 529
 530         ret = ili9322_power_on(ili);
 531         if (ret < 0)
 532                 return ret;
 533
 534         ret = ili9322_init(panel, ili);
 535         if (ret < 0)
 536                 ili9322_unprepare(panel);
 537
 538         return ret;
 539 }
 540
 541 static int ili9322_enable(struct drm_panel *panel)
 542 {
 543         struct ili9322 *ili = panel_to_ili9322(panel);
 544         int ret;
 545
 546         ret = regmap_write(ili->regmap, ILI9322_POW_CTRL,
 547                            ILI9322_POW_CTRL_DEFAULT);
 548         if (ret) {
 549                 dev_err(ili->dev, "unable to enable panel\n");
 550                 return ret;
 551         }
 552
 553         return 0;
 554 }
 555
 556 /* Serial RGB modes */
 557 static const struct drm_display_mode srgb_320x240_mode = {
 558         .clock = 2453500,
 559         .hdisplay = 320,
 560         .hsync_start = 320 + 359,
 561         .hsync_end = 320 + 359 + 1,
 562         .htotal = 320 + 359 + 1 + 241,
 563         .vdisplay = 240,
 564         .vsync_start = 240 + 4,
 565         .vsync_end = 240 + 4 + 1,
 566         .vtotal = 262,
 567         .vrefresh = 60,
 568         .flags = 0,
 569 };
 570
 571 static const struct drm_display_mode srgb_360x240_mode = {
 572         .clock = 2700000,
 573         .hdisplay = 360,
 574         .hsync_start = 360 + 35,
 575         .hsync_end = 360 + 35 + 1,
 576         .htotal = 360 + 35 + 1 + 241,
 577         .vdisplay = 240,
 578         .vsync_start = 240 + 21,
 579         .vsync_end = 240 + 21 + 1,
 580         .vtotal = 262,
 581         .vrefresh = 60,
 582         .flags = 0,
 583 };
 584
 585 /* This is the only mode listed for parallel RGB in the datasheet */
 586 static const struct drm_display_mode prgb_320x240_mode = {
 587         .clock = 6400000,
 588         .hdisplay = 320,
 589         .hsync_start = 320 + 38,
 590         .hsync_end = 320 + 38 + 1,
 591         .htotal = 320 + 38 + 1 + 50,
 592         .vdisplay = 240,
 593         .vsync_start = 240 + 4,
 594         .vsync_end = 240 + 4 + 1,
 595         .vtotal = 262,
 596         .vrefresh = 60,
 597         .flags = 0,
 598 };
 599
 600 /* YUV modes */
 601 static const struct drm_display_mode yuv_640x320_mode = {
 602         .clock = 2454000,
 603         .hdisplay = 640,
 604         .hsync_start = 640 + 252,
 605         .hsync_end = 640 + 252 + 1,
 606         .htotal = 640 + 252 + 1 + 28,
 607         .vdisplay = 320,
 608         .vsync_start = 320 + 4,
 609         .vsync_end = 320 + 4 + 1,
 610         .vtotal = 320 + 4 + 1 + 18,
 611         .vrefresh = 60,
 612         .flags = 0,
 613 };
 614
 615 static const struct drm_display_mode yuv_720x360_mode = {
 616         .clock = 2700000,
 617         .hdisplay = 720,
 618         .hsync_start = 720 + 252,
 619         .hsync_end = 720 + 252 + 1,
 620         .htotal = 720 + 252 + 1 + 24,
 621         .vdisplay = 360,
 622         .vsync_start = 360 + 4,
 623         .vsync_end = 360 + 4 + 1,
 624         .vtotal = 360 + 4 + 1 + 18,
 625         .vrefresh = 60,
 626         .flags = 0,
 627 };
 628
 629 /* BT.656 VGA mode, 640x480 */
 630 static const struct drm_display_mode itu_r_bt_656_640_mode = {
 631         .clock = 2454000,
 632         .hdisplay = 640,
 633         .hsync_start = 640 + 3,
 634         .hsync_end = 640 + 3 + 1,
 635         .htotal = 640 + 3 + 1 + 272,
 636         .vdisplay = 480,
 637         .vsync_start = 480 + 4,
 638         .vsync_end = 480 + 4 + 1,
 639         .vtotal = 500,
 640         .vrefresh = 60,
 641         .flags = 0,
 642 };
 643
 644 /* BT.656 D1 mode 720x480 */
 645 static const struct drm_display_mode itu_r_bt_656_720_mode = {
 646         .clock = 2700000,
 647         .hdisplay = 720,
 648         .hsync_start = 720 + 3,
 649         .hsync_end = 720 + 3 + 1,
 650         .htotal = 720 + 3 + 1 + 272,
 651         .vdisplay = 480,
 652         .vsync_start = 480 + 4,
 653         .vsync_end = 480 + 4 + 1,
 654         .vtotal = 500,
 655         .vrefresh = 60,
 656         .flags = 0,
 657 };
 658
 659 static int ili9322_get_modes(struct drm_panel *panel)
 660 {
 661         struct drm_connector *connector = panel->connector;
 662         struct ili9322 *ili = panel_to_ili9322(panel);
 663         struct drm_display_mode *mode;
 664
 665         strncpy(connector->display_info.name, "ILI9322 TFT LCD driver\0",
 666                 DRM_DISPLAY_INFO_LEN);
 667         connector->display_info.width_mm = ili->conf->width_mm;
 668         connector->display_info.height_mm = ili->conf->height_mm;
 669
 670         switch (ili->input) {
 671         case ILI9322_INPUT_SRGB_DUMMY_320X240:
 672                 mode = drm_mode_duplicate(panel->drm, &srgb_320x240_mode);
 673                 break;
 674         case ILI9322_INPUT_SRGB_DUMMY_360X240:
 675                 mode = drm_mode_duplicate(panel->drm, &srgb_360x240_mode);
 676                 break;
 677         case ILI9322_INPUT_PRGB_THROUGH:
 678         case ILI9322_INPUT_PRGB_ALIGNED:
 679                 mode = drm_mode_duplicate(panel->drm, &prgb_320x240_mode);
 680                 break;
 681         case ILI9322_INPUT_YUV_640X320_YCBCR:
 682                 mode = drm_mode_duplicate(panel->drm, &yuv_640x320_mode);
 683                 break;
 684         case ILI9322_INPUT_YUV_720X360_YCBCR:
 685                 mode = drm_mode_duplicate(panel->drm, &yuv_720x360_mode);
 686                 break;
 687         case ILI9322_INPUT_ITU_R_BT656_720X360_YCBCR:
 688                 mode = drm_mode_duplicate(panel->drm, &itu_r_bt_656_720_mode);
 689                 break;
 690         case ILI9322_INPUT_ITU_R_BT656_640X320_YCBCR:
 691                 mode = drm_mode_duplicate(panel->drm, &itu_r_bt_656_640_mode);
 692                 break;
 693         default:
 694                 mode = NULL;
 695                 break;
 696         }
 697         if (!mode) {
 698                 DRM_ERROR("bad mode or failed to add mode\n");
 699                 return -EINVAL;
 700         }
 701         drm_mode_set_name(mode);
 702         /*
 703          * This is the preferred mode because most people are going
 704          * to want to use the display with VGA type graphics.
 705          */
 706         mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
 707
 708         /* Set up the polarity */
 709         if (ili->conf->hsync_active_high)
 710                 mode->flags |= DRM_MODE_FLAG_PHSYNC;
 711         else
 712                 mode->flags |= DRM_MODE_FLAG_NHSYNC;
 713         if (ili->conf->vsync_active_high)
 714                 mode->flags |= DRM_MODE_FLAG_PVSYNC;
 715         else
 716                 mode->flags |= DRM_MODE_FLAG_NVSYNC;
 717
 718         mode->width_mm = ili->conf->width_mm;
 719         mode->height_mm = ili->conf->height_mm;
 720         drm_mode_probed_add(connector, mode);
 721
 722         return 1; /* Number of modes */
 723 }
 724
 725 static const struct drm_panel_funcs ili9322_drm_funcs = {
 726         .disable = ili9322_disable,
 727         .unprepare = ili9322_unprepare,
 728         .prepare = ili9322_prepare,
 729         .enable = ili9322_enable,
 730         .get_modes = ili9322_get_modes,
 731 };
 732
 733 static int ili9322_probe(struct spi_device *spi)
 734 {
 735         struct device *dev = &spi->dev;
 736         struct ili9322 *ili;
 737         const struct regmap_config *regmap_config;
 738         u8 gamma;
 739         u32 val;
 740         int ret;
 741         int i;
 742
 743         ili = devm_kzalloc(dev, sizeof(struct ili9322), GFP_KERNEL);
 744         if (!ili)
 745                 return -ENOMEM;
 746
 747         spi_set_drvdata(spi, ili);
 748
 749         ili->dev = dev;
 750
 751         /*
 752          * Every new incarnation of this display must have a unique
 753          * data entry for the system in this driver.
 754          */
 755         ili->conf = of_device_get_match_data(dev);
 756         if (!ili->conf) {
 757                 dev_err(dev, "missing device configuration\n");
 758                 return -ENODEV;
 759         }
 760
 761         val = ili->conf->vreg1out_mv;
 762         if (!val) {
 763                 /* Default HW value, do not touch (should be 4.5V) */
 764                 ili->vreg1out = U8_MAX;
 765         } else {
 766                 if (val < 3600) {
 767                         dev_err(dev, "too low VREG1OUT\n");
 768                         return -EINVAL;
 769                 }
 770                 if (val > 6000) {
 771                         dev_err(dev, "too high VREG1OUT\n");
 772                         return -EINVAL;
 773                 }
 774                 if ((val % 100) != 0) {
 775                         dev_err(dev, "VREG1OUT is no even 100 microvolt\n");
 776                         return -EINVAL;
 777                 }
 778                 val -= 3600;
 779                 val /= 100;
 780                 dev_dbg(dev, "VREG1OUT = 0x%02x\n", val);
 781                 ili->vreg1out = val;
 782         }
 783
 784         val = ili->conf->vcom_high_percent;
 785         if (!val) {
 786                 /* Default HW value, do not touch (should be 91%) */
 787                 ili->vcom_high = U8_MAX;
 788         } else {
 789                 if (val < 37) {
 790                         dev_err(dev, "too low VCOM high\n");
 791                         return -EINVAL;
 792                 }
 793                 if (val > 100) {
 794                         dev_err(dev, "too high VCOM high\n");
 795                         return -EINVAL;
 796                 }
 797                 val -= 37;
 798                 dev_dbg(dev, "VCOM high = 0x%02x\n", val);
 799                 ili->vcom_high = val;
 800         }
 801
 802         val = ili->conf->vcom_amplitude_percent;
 803         if (!val) {
 804                 /* Default HW value, do not touch (should be 114%) */
 805                 ili->vcom_high = U8_MAX;
 806         } else {
 807                 if (val < 70) {
 808                         dev_err(dev, "too low VCOM amplitude\n");
 809                         return -EINVAL;
 810                 }
 811                 if (val > 132) {
 812                         dev_err(dev, "too high VCOM amplitude\n");
 813                         return -EINVAL;
 814                 }
 815                 val -= 70;
 816                 val >>= 1; /* Increments of 2% */
 817                 dev_dbg(dev, "VCOM amplitude = 0x%02x\n", val);
 818                 ili->vcom_amplitude = val;
 819         }
 820
 821         for (i = 0; i < ARRAY_SIZE(ili->gamma); i++) {
 822                 val = ili->conf->gamma_corr_neg[i];
 823                 if (val > 15) {
 824                         dev_err(dev, "negative gamma %u > 15, capping\n", val);
 825                         val = 15;
 826                 }
 827                 gamma = val << 4;
 828                 val = ili->conf->gamma_corr_pos[i];
 829                 if (val > 15) {
 830                         dev_err(dev, "positive gamma %u > 15, capping\n", val);
 831                         val = 15;
 832                 }
 833                 gamma |= val;
 834                 ili->gamma[i] = gamma;
 835                 dev_dbg(dev, "gamma V%d: 0x%02x\n", i + 1, gamma);
 836         }
 837
 838         ili->supplies[0].supply = "vcc"; /* 2.7-3.6 V */
 839         ili->supplies[1].supply = "iovcc"; /* 1.65-3.6V */
 840         ili->supplies[2].supply = "vci"; /* 2.7-3.6V */
 841         ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(ili->supplies),
 842                                       ili->supplies);
 843         if (ret < 0)
 844                 return ret;
 845         ret = regulator_set_voltage(ili->supplies[0].consumer,
 846                                     2700000, 3600000);
 847         if (ret)
 848                 return ret;
 849         ret = regulator_set_voltage(ili->supplies[1].consumer,
 850                                     1650000, 3600000);
 851         if (ret)
 852                 return ret;
 853         ret = regulator_set_voltage(ili->supplies[2].consumer,
 854                                     2700000, 3600000);
 855         if (ret)
 856                 return ret;
 857
 858         ili->reset_gpio = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_HIGH);
 859         if (IS_ERR(ili->reset_gpio)) {
 860                 dev_err(dev, "failed to get RESET GPIO\n");
 861                 return PTR_ERR(ili->reset_gpio);
 862         }
 863
 864         spi->bits_per_word = 8;
 865         ret = spi_setup(spi);
 866         if (ret < 0) {
 867                 dev_err(dev, "spi setup failed.\n");
 868                 return ret;
 869         }
 870         regmap_config = &ili9322_regmap_config;
 871         ili->regmap = devm_regmap_init(dev, &ili9322_regmap_bus, dev,
 872                                        regmap_config);
 873         if (IS_ERR(ili->regmap)) {
 874                 dev_err(dev, "failed to allocate register map\n");
 875                 return PTR_ERR(ili->regmap);
 876         }
 877
 878         ret = regmap_read(ili->regmap, ILI9322_CHIP_ID, &val);
 879         if (ret) {
 880                 dev_err(dev, "can't get chip ID (%d)\n", ret);
 881                 return ret;
 882         }
 883         if (val != ILI9322_CHIP_ID_MAGIC) {
 884                 dev_err(dev, "chip ID 0x%0x2, expected 0x%02x\n", val,
 885                         ILI9322_CHIP_ID_MAGIC);
 886                 return -ENODEV;
 887         }
 888
 889         /* Probe the system to find the display setting */
 890         if (ili->conf->input == ILI9322_INPUT_UNKNOWN) {
 891                 ret = regmap_read(ili->regmap, ILI9322_ENTRY, &val);
 892                 if (ret) {
 893                         dev_err(dev, "can't get entry setting (%d)\n", ret);
 894                         return ret;
 895                 }
 896                 /* Input enum corresponds to HW setting */
 897                 ili->input = (val >> 4) & 0x0f;
 898                 if (ili->input >= ILI9322_INPUT_UNKNOWN)
 899                         ili->input = ILI9322_INPUT_UNKNOWN;
 900         } else {
 901                 ili->input = ili->conf->input;
 902         }
 903
 904         drm_panel_init(&ili->panel);
 905         ili->panel.dev = dev;
 906         ili->panel.funcs = &ili9322_drm_funcs;
 907
 908         return drm_panel_add(&ili->panel);
 909 }
 910
 911 static int ili9322_remove(struct spi_device *spi)
 912 {
 913         struct ili9322 *ili = spi_get_drvdata(spi);
 914
 915         ili9322_power_off(ili);
 916         drm_panel_remove(&ili->panel);
 917
 918         return 0;
 919 }
 920
 921 /*
 922  * The D-Link DIR-685 panel is marked LM918A01-1A SY-B4-091116-E0199
 923  */
 924 static const struct ili9322_config ili9322_dir_685 = {
 925         .width_mm = 65,
 926         .height_mm = 50,
 927         .input = ILI9322_INPUT_ITU_R_BT656_640X320_YCBCR,
 928         .vreg1out_mv = 4600,
 929         .vcom_high_percent = 91,
 930         .vcom_amplitude_percent = 114,
 931         .syncmode = ILI9322_IF_CTRL_SYNC_DISABLED,
 932         .dclk_active_high = true,
 933         .gamma_corr_neg = { 0xa, 0x5, 0x7, 0x7, 0x7, 0x5, 0x1, 0x6 },
 934         .gamma_corr_pos = { 0x7, 0x7, 0x3, 0x2, 0x3, 0x5, 0x7, 0x2 },
 935 };
 936
 937 static const struct of_device_id ili9322_of_match[] = {
 938         {
 939                 .compatible = "dlink,dir-685-panel",
 940                 .data = &ili9322_dir_685,
 941         },
 942         {
 943                 .compatible = "ilitek,ili9322",
 944                 .data = NULL,
 945         },
 946         { }
 947 };
 948 MODULE_DEVICE_TABLE(of, ili9322_of_match);
 949
 950 static struct spi_driver ili9322_driver = {
 951         .probe = ili9322_probe,
 952         .remove = ili9322_remove,
 953         .driver = {
 954                 .name = "panel-ilitek-ili9322",
 955                 .of_match_table = ili9322_of_match,
 956         },
 957 };
 958 module_spi_driver(ili9322_driver);
 959
 960 MODULE_AUTHOR("Linus Walleij <linus.walleij@linaro.org>");
 961 MODULE_DESCRIPTION("ILI9322 LCD panel driver");
 962 MODULE_LICENSE("GPL v2");