drivers/video/fbdev/omap2/omapfb/displays/panel-sony-acx565akm.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Sony ACX565AKM LCD Panel driver
   4  *
   5  * Copyright (C) 2010 Nokia Corporation
   6  *
   7  * Original Driver Author: Imre Deak <imre.deak@nokia.com>
   8  * Based on panel-generic.c by Tomi Valkeinen <tomi.valkeinen@nokia.com>
   9  * Adapted to new DSS2 framework: Roger Quadros <roger.quadros@nokia.com>
  10  */
  11
  12 #include <linux/kernel.h>
  13 #include <linux/module.h>
  14 #include <linux/platform_device.h>
  15 #include <linux/delay.h>
  16 #include <linux/spi/spi.h>
  17 #include <linux/jiffies.h>
  18 #include <linux/sched.h>
  19 #include <linux/backlight.h>
  20 #include <linux/fb.h>
  21 #include <linux/gpio/consumer.h>
  22 #include <linux/of.h>
  23
  24 #include <video/omapfb_dss.h>
  25
  26 #define MIPID_CMD_READ_DISP_ID          0x04
  27 #define MIPID_CMD_READ_RED              0x06
  28 #define MIPID_CMD_READ_GREEN            0x07
  29 #define MIPID_CMD_READ_BLUE             0x08
  30 #define MIPID_CMD_READ_DISP_STATUS      0x09
  31 #define MIPID_CMD_RDDSDR                0x0F
  32 #define MIPID_CMD_SLEEP_IN              0x10
  33 #define MIPID_CMD_SLEEP_OUT             0x11
  34 #define MIPID_CMD_DISP_OFF              0x28
  35 #define MIPID_CMD_DISP_ON               0x29
  36 #define MIPID_CMD_WRITE_DISP_BRIGHTNESS 0x51
  37 #define MIPID_CMD_READ_DISP_BRIGHTNESS  0x52
  38 #define MIPID_CMD_WRITE_CTRL_DISP       0x53
  39
  40 #define CTRL_DISP_BRIGHTNESS_CTRL_ON    (1 << 5)
  41 #define CTRL_DISP_AMBIENT_LIGHT_CTRL_ON (1 << 4)
  42 #define CTRL_DISP_BACKLIGHT_ON          (1 << 2)
  43 #define CTRL_DISP_AUTO_BRIGHTNESS_ON    (1 << 1)
  44
  45 #define MIPID_CMD_READ_CTRL_DISP        0x54
  46 #define MIPID_CMD_WRITE_CABC            0x55
  47 #define MIPID_CMD_READ_CABC             0x56
  48
  49 #define MIPID_VER_LPH8923               3
  50 #define MIPID_VER_LS041Y3               4
  51 #define MIPID_VER_L4F00311              8
  52 #define MIPID_VER_ACX565AKM             9
  53
  54 struct panel_drv_data {
  55         struct omap_dss_device  dssdev;
  56         struct omap_dss_device *in;
  57
  58         struct gpio_desc *reset_gpio;
  59
  60         int datapairs;
  61
  62         struct omap_video_timings videomode;
  63
  64         char            *name;
  65         int             enabled;
  66         int             model;
  67         int             revision;
  68         u8              display_id[3];
  69         unsigned        has_bc:1;
  70         unsigned        has_cabc:1;
  71         unsigned        cabc_mode;
  72         unsigned long   hw_guard_end;           /* next value of jiffies
  73                                                    when we can issue the
  74                                                    next sleep in/out command */
  75         unsigned long   hw_guard_wait;          /* max guard time in jiffies */
  76
  77         struct spi_device       *spi;
  78         struct mutex            mutex;
  79
  80         struct backlight_device *bl_dev;
  81 };
  82
  83 static const struct omap_video_timings acx565akm_panel_timings = {
  84         .x_res          = 800,
  85         .y_res          = 480,
  86         .pixelclock     = 24000000,
  87         .hfp            = 28,
  88         .hsw            = 4,
  89         .hbp            = 24,
  90         .vfp            = 3,
  91         .vsw            = 3,
  92         .vbp            = 4,
  93
  94         .vsync_level    = OMAPDSS_SIG_ACTIVE_LOW,
  95         .hsync_level    = OMAPDSS_SIG_ACTIVE_LOW,
  96
  97         .data_pclk_edge = OMAPDSS_DRIVE_SIG_RISING_EDGE,
  98         .de_level       = OMAPDSS_SIG_ACTIVE_HIGH,
  99         .sync_pclk_edge = OMAPDSS_DRIVE_SIG_FALLING_EDGE,
 100 };
 101
 102 #define to_panel_data(p) container_of(p, struct panel_drv_data, dssdev)
 103
 104 static void acx565akm_transfer(struct panel_drv_data *ddata, int cmd,
 105                               const u8 *wbuf, int wlen, u8 *rbuf, int rlen)
 106 {
 107         struct spi_message      m;
 108         struct spi_transfer     *x, xfer[5];
 109         int                     r;
 110
 111         BUG_ON(ddata->spi == NULL);
 112
 113         spi_message_init(&m);
 114
 115         memset(xfer, 0, sizeof(xfer));
 116         x = &xfer[0];
 117
 118         cmd &=  0xff;
 119         x->tx_buf = &cmd;
 120         x->bits_per_word = 9;
 121         x->len = 2;
 122
 123         if (rlen > 1 && wlen == 0) {
 124                 /*
 125                  * Between the command and the response data there is a
 126                  * dummy clock cycle. Add an extra bit after the command
 127                  * word to account for this.
 128                  */
 129                 x->bits_per_word = 10;
 130                 cmd <<= 1;
 131         }
 132         spi_message_add_tail(x, &m);
 133
 134         if (wlen) {
 135                 x++;
 136                 x->tx_buf = wbuf;
 137                 x->len = wlen;
 138                 x->bits_per_word = 9;
 139                 spi_message_add_tail(x, &m);
 140         }
 141
 142         if (rlen) {
 143                 x++;
 144                 x->rx_buf       = rbuf;
 145                 x->len          = rlen;
 146                 spi_message_add_tail(x, &m);
 147         }
 148
 149         r = spi_sync(ddata->spi, &m);
 150         if (r < 0)
 151                 dev_dbg(&ddata->spi->dev, "spi_sync %d\n", r);
 152 }
 153
 154 static inline void acx565akm_cmd(struct panel_drv_data *ddata, int cmd)
 155 {
 156         acx565akm_transfer(ddata, cmd, NULL, 0, NULL, 0);
 157 }
 158
 159 static inline void acx565akm_write(struct panel_drv_data *ddata,
 160                                int reg, const u8 *buf, int len)
 161 {
 162         acx565akm_transfer(ddata, reg, buf, len, NULL, 0);
 163 }
 164
 165 static inline void acx565akm_read(struct panel_drv_data *ddata,
 166                               int reg, u8 *buf, int len)
 167 {
 168         acx565akm_transfer(ddata, reg, NULL, 0, buf, len);
 169 }
 170
 171 static void hw_guard_start(struct panel_drv_data *ddata, int guard_msec)
 172 {
 173         ddata->hw_guard_wait = msecs_to_jiffies(guard_msec);
 174         ddata->hw_guard_end = jiffies + ddata->hw_guard_wait;
 175 }
 176
 177 static void hw_guard_wait(struct panel_drv_data *ddata)
 178 {
 179         unsigned long wait = ddata->hw_guard_end - jiffies;
 180
 181         if ((long)wait > 0 && wait <= ddata->hw_guard_wait) {
 182                 set_current_state(TASK_UNINTERRUPTIBLE);
 183                 schedule_timeout(wait);
 184         }
 185 }
 186
 187 static void set_sleep_mode(struct panel_drv_data *ddata, int on)
 188 {
 189         int cmd;
 190
 191         if (on)
 192                 cmd = MIPID_CMD_SLEEP_IN;
 193         else
 194                 cmd = MIPID_CMD_SLEEP_OUT;
 195         /*
 196          * We have to keep 120msec between sleep in/out commands.
 197          * (8.2.15, 8.2.16).
 198          */
 199         hw_guard_wait(ddata);
 200         acx565akm_cmd(ddata, cmd);
 201         hw_guard_start(ddata, 120);
 202 }
 203
 204 static void set_display_state(struct panel_drv_data *ddata, int enabled)
 205 {
 206         int cmd = enabled ? MIPID_CMD_DISP_ON : MIPID_CMD_DISP_OFF;
 207
 208         acx565akm_cmd(ddata, cmd);
 209 }
 210
 211 static int panel_enabled(struct panel_drv_data *ddata)
 212 {
 213         u32 disp_status;
 214         int enabled;
 215
 216         acx565akm_read(ddata, MIPID_CMD_READ_DISP_STATUS,
 217                         (u8 *)&disp_status, 4);
 218         disp_status = __be32_to_cpu(disp_status);
 219         enabled = (disp_status & (1 << 17)) && (disp_status & (1 << 10));
 220         dev_dbg(&ddata->spi->dev,
 221                 "LCD panel %senabled by bootloader (status 0x%04x)\n",
 222                 enabled ? "" : "not ", disp_status);
 223         return enabled;
 224 }
 225
 226 static int panel_detect(struct panel_drv_data *ddata)
 227 {
 228         acx565akm_read(ddata, MIPID_CMD_READ_DISP_ID, ddata->display_id, 3);
 229         dev_dbg(&ddata->spi->dev, "MIPI display ID: %02x%02x%02x\n",
 230                 ddata->display_id[0],
 231                 ddata->display_id[1],
 232                 ddata->display_id[2]);
 233
 234         switch (ddata->display_id[0]) {
 235         case 0x10:
 236                 ddata->model = MIPID_VER_ACX565AKM;
 237                 ddata->name = "acx565akm";
 238                 ddata->has_bc = 1;
 239                 ddata->has_cabc = 1;
 240                 break;
 241         case 0x29:
 242                 ddata->model = MIPID_VER_L4F00311;
 243                 ddata->name = "l4f00311";
 244                 break;
 245         case 0x45:
 246                 ddata->model = MIPID_VER_LPH8923;
 247                 ddata->name = "lph8923";
 248                 break;
 249         case 0x83:
 250                 ddata->model = MIPID_VER_LS041Y3;
 251                 ddata->name = "ls041y3";
 252                 break;
 253         default:
 254                 ddata->name = "unknown";
 255                 dev_err(&ddata->spi->dev, "invalid display ID\n");
 256                 return -ENODEV;
 257         }
 258
 259         ddata->revision = ddata->display_id[1];
 260
 261         dev_info(&ddata->spi->dev, "omapfb: %s rev %02x LCD detected\n",
 262                         ddata->name, ddata->revision);
 263
 264         return 0;
 265 }
 266
 267 /*----------------------Backlight Control-------------------------*/
 268
 269 static void enable_backlight_ctrl(struct panel_drv_data *ddata, int enable)
 270 {
 271         u16 ctrl;
 272
 273         acx565akm_read(ddata, MIPID_CMD_READ_CTRL_DISP, (u8 *)&ctrl, 1);
 274         if (enable) {
 275                 ctrl |= CTRL_DISP_BRIGHTNESS_CTRL_ON |
 276                         CTRL_DISP_BACKLIGHT_ON;
 277         } else {
 278                 ctrl &= ~(CTRL_DISP_BRIGHTNESS_CTRL_ON |
 279                           CTRL_DISP_BACKLIGHT_ON);
 280         }
 281
 282         ctrl |= 1 << 8;
 283         acx565akm_write(ddata, MIPID_CMD_WRITE_CTRL_DISP, (u8 *)&ctrl, 2);
 284 }
 285
 286 static void set_cabc_mode(struct panel_drv_data *ddata, unsigned mode)
 287 {
 288         u16 cabc_ctrl;
 289
 290         ddata->cabc_mode = mode;
 291         if (!ddata->enabled)
 292                 return;
 293         cabc_ctrl = 0;
 294         acx565akm_read(ddata, MIPID_CMD_READ_CABC, (u8 *)&cabc_ctrl, 1);
 295         cabc_ctrl &= ~3;
 296         cabc_ctrl |= (1 << 8) | (mode & 3);
 297         acx565akm_write(ddata, MIPID_CMD_WRITE_CABC, (u8 *)&cabc_ctrl, 2);
 298 }
 299
 300 static unsigned get_cabc_mode(struct panel_drv_data *ddata)
 301 {
 302         return ddata->cabc_mode;
 303 }
 304
 305 static unsigned get_hw_cabc_mode(struct panel_drv_data *ddata)
 306 {
 307         u8 cabc_ctrl;
 308
 309         acx565akm_read(ddata, MIPID_CMD_READ_CABC, &cabc_ctrl, 1);
 310         return cabc_ctrl & 3;
 311 }
 312
 313 static void acx565akm_set_brightness(struct panel_drv_data *ddata, int level)
 314 {
 315         int bv;
 316
 317         bv = level | (1 << 8);
 318         acx565akm_write(ddata, MIPID_CMD_WRITE_DISP_BRIGHTNESS, (u8 *)&bv, 2);
 319
 320         if (level)
 321                 enable_backlight_ctrl(ddata, 1);
 322         else
 323                 enable_backlight_ctrl(ddata, 0);
 324 }
 325
 326 static int acx565akm_get_actual_brightness(struct panel_drv_data *ddata)
 327 {
 328         u8 bv;
 329
 330         acx565akm_read(ddata, MIPID_CMD_READ_DISP_BRIGHTNESS, &bv, 1);
 331
 332         return bv;
 333 }
 334
 335
 336 static int acx565akm_bl_update_status(struct backlight_device *dev)
 337 {
 338         struct panel_drv_data *ddata = dev_get_drvdata(&dev->dev);
 339         int level;
 340
 341         dev_dbg(&ddata->spi->dev, "%s\n", __func__);
 342
 343         level = backlight_get_brightness(dev);
 344
 345         if (ddata->has_bc)
 346                 acx565akm_set_brightness(ddata, level);
 347         else
 348                 return -ENODEV;
 349
 350         return 0;
 351 }
 352
 353 static int acx565akm_bl_get_intensity(struct backlight_device *dev)
 354 {
 355         struct panel_drv_data *ddata = dev_get_drvdata(&dev->dev);
 356
 357         dev_dbg(&dev->dev, "%s\n", __func__);
 358
 359         if (!ddata->has_bc)
 360                 return -ENODEV;
 361
 362         if (!backlight_is_blank(dev)) {
 363                 if (ddata->has_bc)
 364                         return acx565akm_get_actual_brightness(ddata);
 365                 else
 366                         return dev->props.brightness;
 367         }
 368
 369         return 0;
 370 }
 371
 372 static int acx565akm_bl_update_status_locked(struct backlight_device *dev)
 373 {
 374         struct panel_drv_data *ddata = dev_get_drvdata(&dev->dev);
 375         int r;
 376
 377         mutex_lock(&ddata->mutex);
 378         r = acx565akm_bl_update_status(dev);
 379         mutex_unlock(&ddata->mutex);
 380
 381         return r;
 382 }
 383
 384 static int acx565akm_bl_get_intensity_locked(struct backlight_device *dev)
 385 {
 386         struct panel_drv_data *ddata = dev_get_drvdata(&dev->dev);
 387         int r;
 388
 389         mutex_lock(&ddata->mutex);
 390         r = acx565akm_bl_get_intensity(dev);
 391         mutex_unlock(&ddata->mutex);
 392
 393         return r;
 394 }
 395
 396 static const struct backlight_ops acx565akm_bl_ops = {
 397         .get_brightness = acx565akm_bl_get_intensity_locked,
 398         .update_status  = acx565akm_bl_update_status_locked,
 399 };
 400
 401 /*--------------------Auto Brightness control via Sysfs---------------------*/
 402
 403 static const char * const cabc_modes[] = {
 404         "off",          /* always used when CABC is not supported */
 405         "ui",
 406         "still-image",
 407         "moving-image",
 408 };
 409
 410 static ssize_t show_cabc_mode(struct device *dev,
 411                 struct device_attribute *attr,
 412                 char *buf)
 413 {
 414         struct panel_drv_data *ddata = dev_get_drvdata(dev);
 415         const char *mode_str;
 416         int mode;
 417         int len;
 418
 419         if (!ddata->has_cabc)
 420                 mode = 0;
 421         else
 422                 mode = get_cabc_mode(ddata);
 423         mode_str = "unknown";
 424         if (mode >= 0 && mode < ARRAY_SIZE(cabc_modes))
 425                 mode_str = cabc_modes[mode];
 426         len = snprintf(buf, PAGE_SIZE, "%s\n", mode_str);
 427
 428         return len < PAGE_SIZE - 1 ? len : PAGE_SIZE - 1;
 429 }
 430
 431 static ssize_t store_cabc_mode(struct device *dev,
 432                 struct device_attribute *attr,
 433                 const char *buf, size_t count)
 434 {
 435         struct panel_drv_data *ddata = dev_get_drvdata(dev);
 436         int i;
 437
 438         for (i = 0; i < ARRAY_SIZE(cabc_modes); i++) {
 439                 const char *mode_str = cabc_modes[i];
 440                 int cmp_len = strlen(mode_str);
 441
 442                 if (count > 0 && buf[count - 1] == '\n')
 443                         count--;
 444                 if (count != cmp_len)
 445                         continue;
 446
 447                 if (strncmp(buf, mode_str, cmp_len) == 0)
 448                         break;
 449         }
 450
 451         if (i == ARRAY_SIZE(cabc_modes))
 452                 return -EINVAL;
 453
 454         if (!ddata->has_cabc && i != 0)
 455                 return -EINVAL;
 456
 457         mutex_lock(&ddata->mutex);
 458         set_cabc_mode(ddata, i);
 459         mutex_unlock(&ddata->mutex);
 460
 461         return count;
 462 }
 463
 464 static ssize_t show_cabc_available_modes(struct device *dev,
 465                 struct device_attribute *attr,
 466                 char *buf)
 467 {
 468         struct panel_drv_data *ddata = dev_get_drvdata(dev);
 469         int len = 0;
 470         int i;
 471
 472         if (!ddata->has_cabc)
 473                 return sysfs_emit(buf, "%s\n", cabc_modes[0]);
 474
 475         for (i = 0; i < ARRAY_SIZE(cabc_modes); i++)
 476                 len += sysfs_emit_at(buf, len, "%s ", cabc_modes[i]);
 477
 478         /* Remove the trailing space */
 479         if (len)
 480                 buf[len - 1] = '\n';
 481
 482         return len;
 483 }
 484
 485 static DEVICE_ATTR(cabc_mode, S_IRUGO | S_IWUSR,
 486                 show_cabc_mode, store_cabc_mode);
 487 static DEVICE_ATTR(cabc_available_modes, S_IRUGO,
 488                 show_cabc_available_modes, NULL);
 489
 490 static struct attribute *bldev_attrs[] = {
 491         &dev_attr_cabc_mode.attr,
 492         &dev_attr_cabc_available_modes.attr,
 493         NULL,
 494 };
 495
 496 static const struct attribute_group bldev_attr_group = {
 497         .attrs = bldev_attrs,
 498 };
 499
 500 static int acx565akm_connect(struct omap_dss_device *dssdev)
 501 {
 502         struct panel_drv_data *ddata = to_panel_data(dssdev);
 503         struct omap_dss_device *in = ddata->in;
 504
 505         if (omapdss_device_is_connected(dssdev))
 506                 return 0;
 507
 508         return in->ops.sdi->connect(in, dssdev);
 509 }
 510
 511 static void acx565akm_disconnect(struct omap_dss_device *dssdev)
 512 {
 513         struct panel_drv_data *ddata = to_panel_data(dssdev);
 514         struct omap_dss_device *in = ddata->in;
 515
 516         if (!omapdss_device_is_connected(dssdev))
 517                 return;
 518
 519         in->ops.sdi->disconnect(in, dssdev);
 520 }
 521
 522 static int acx565akm_panel_power_on(struct omap_dss_device *dssdev)
 523 {
 524         struct panel_drv_data *ddata = to_panel_data(dssdev);
 525         struct omap_dss_device *in = ddata->in;
 526         int r;
 527
 528         dev_dbg(&ddata->spi->dev, "%s\n", __func__);
 529
 530         in->ops.sdi->set_timings(in, &ddata->videomode);
 531
 532         if (ddata->datapairs > 0)
 533                 in->ops.sdi->set_datapairs(in, ddata->datapairs);
 534
 535         r = in->ops.sdi->enable(in);
 536         if (r) {
 537                 pr_err("%s sdi enable failed\n", __func__);
 538                 return r;
 539         }
 540
 541         /*FIXME tweak me */
 542         msleep(50);
 543
 544         /*
 545          * Note that we appear to activate the reset line here. However
 546          * existing DTSes specified incorrect polarity for it (active high),
 547          * so in fact this deasserts the reset line.
 548          */
 549         if (ddata->reset_gpio)
 550                 gpiod_set_value_cansleep(ddata->reset_gpio, 1);
 551
 552         if (ddata->enabled) {
 553                 dev_dbg(&ddata->spi->dev, "panel already enabled\n");
 554                 return 0;
 555         }
 556
 557         /*
 558          * We have to meet all the following delay requirements:
 559          * 1. tRW: reset pulse width 10usec (7.12.1)
 560          * 2. tRT: reset cancel time 5msec (7.12.1)
 561          * 3. Providing PCLK,HS,VS signals for 2 frames = ~50msec worst
 562          *    case (7.6.2)
 563          * 4. 120msec before the sleep out command (7.12.1)
 564          */
 565         msleep(120);
 566
 567         set_sleep_mode(ddata, 0);
 568         ddata->enabled = 1;
 569
 570         /* 5msec between sleep out and the next command. (8.2.16) */
 571         usleep_range(5000, 10000);
 572         set_display_state(ddata, 1);
 573         set_cabc_mode(ddata, ddata->cabc_mode);
 574
 575         return acx565akm_bl_update_status(ddata->bl_dev);
 576 }
 577
 578 static void acx565akm_panel_power_off(struct omap_dss_device *dssdev)
 579 {
 580         struct panel_drv_data *ddata = to_panel_data(dssdev);
 581         struct omap_dss_device *in = ddata->in;
 582
 583         dev_dbg(dssdev->dev, "%s\n", __func__);
 584
 585         if (!ddata->enabled)
 586                 return;
 587
 588         set_display_state(ddata, 0);
 589         set_sleep_mode(ddata, 1);
 590         ddata->enabled = 0;
 591         /*
 592          * We have to provide PCLK,HS,VS signals for 2 frames (worst case
 593          * ~50msec) after sending the sleep in command and asserting the
 594          * reset signal. We probably could assert the reset w/o the delay
 595          * but we still delay to avoid possible artifacts. (7.6.1)
 596          */
 597         msleep(50);
 598
 599         /* see comment in acx565akm_panel_power_on() */
 600         if (ddata->reset_gpio)
 601                 gpiod_set_value_cansleep(ddata->reset_gpio, 0);
 602
 603         /* FIXME need to tweak this delay */
 604         msleep(100);
 605
 606         in->ops.sdi->disable(in);
 607 }
 608
 609 static int acx565akm_enable(struct omap_dss_device *dssdev)
 610 {
 611         struct panel_drv_data *ddata = to_panel_data(dssdev);
 612         int r;
 613
 614         dev_dbg(dssdev->dev, "%s\n", __func__);
 615
 616         if (!omapdss_device_is_connected(dssdev))
 617                 return -ENODEV;
 618
 619         if (omapdss_device_is_enabled(dssdev))
 620                 return 0;
 621
 622         mutex_lock(&ddata->mutex);
 623         r = acx565akm_panel_power_on(dssdev);
 624         mutex_unlock(&ddata->mutex);
 625         if (r)
 626                 return r;
 627
 628         dssdev->state = OMAP_DSS_DISPLAY_ACTIVE;
 629
 630         return 0;
 631 }
 632
 633 static void acx565akm_disable(struct omap_dss_device *dssdev)
 634 {
 635         struct panel_drv_data *ddata = to_panel_data(dssdev);
 636
 637         dev_dbg(dssdev->dev, "%s\n", __func__);
 638
 639         if (!omapdss_device_is_enabled(dssdev))
 640                 return;
 641
 642         mutex_lock(&ddata->mutex);
 643         acx565akm_panel_power_off(dssdev);
 644         mutex_unlock(&ddata->mutex);
 645
 646         dssdev->state = OMAP_DSS_DISPLAY_DISABLED;
 647 }
 648
 649 static void acx565akm_set_timings(struct omap_dss_device *dssdev,
 650                 struct omap_video_timings *timings)
 651 {
 652         struct panel_drv_data *ddata = to_panel_data(dssdev);
 653         struct omap_dss_device *in = ddata->in;
 654
 655         ddata->videomode = *timings;
 656         dssdev->panel.timings = *timings;
 657
 658         in->ops.sdi->set_timings(in, timings);
 659 }
 660
 661 static void acx565akm_get_timings(struct omap_dss_device *dssdev,
 662                 struct omap_video_timings *timings)
 663 {
 664         struct panel_drv_data *ddata = to_panel_data(dssdev);
 665
 666         *timings = ddata->videomode;
 667 }
 668
 669 static int acx565akm_check_timings(struct omap_dss_device *dssdev,
 670                 struct omap_video_timings *timings)
 671 {
 672         struct panel_drv_data *ddata = to_panel_data(dssdev);
 673         struct omap_dss_device *in = ddata->in;
 674
 675         return in->ops.sdi->check_timings(in, timings);
 676 }
 677
 678 static struct omap_dss_driver acx565akm_ops = {
 679         .connect        = acx565akm_connect,
 680         .disconnect     = acx565akm_disconnect,
 681
 682         .enable         = acx565akm_enable,
 683         .disable        = acx565akm_disable,
 684
 685         .set_timings    = acx565akm_set_timings,
 686         .get_timings    = acx565akm_get_timings,
 687         .check_timings  = acx565akm_check_timings,
 688
 689         .get_resolution = omapdss_default_get_resolution,
 690 };
 691
 692 static int acx565akm_probe(struct spi_device *spi)
 693 {
 694         struct panel_drv_data *ddata;
 695         struct omap_dss_device *dssdev;
 696         struct backlight_device *bldev;
 697         int max_brightness, brightness;
 698         struct backlight_properties props;
 699         int r;
 700
 701         dev_dbg(&spi->dev, "%s\n", __func__);
 702
 703         if (!spi->dev.of_node)
 704                 return -ENODEV;
 705
 706         spi->mode = SPI_MODE_3;
 707
 708         ddata = devm_kzalloc(&spi->dev, sizeof(*ddata), GFP_KERNEL);
 709         if (ddata == NULL)
 710                 return -ENOMEM;
 711
 712         dev_set_drvdata(&spi->dev, ddata);
 713
 714         ddata->spi = spi;
 715
 716         mutex_init(&ddata->mutex);
 717
 718         ddata->in = omapdss_of_find_source_for_first_ep(spi->dev.of_node);
 719         r = PTR_ERR_OR_ZERO(ddata->in);
 720         if (r) {
 721                 dev_err(&spi->dev, "failed to find video source\n");
 722                 return r;
 723         }
 724
 725         ddata->reset_gpio = devm_gpiod_get_optional(&spi->dev, "reset",
 726                                                     GPIOD_OUT_LOW);
 727         r = PTR_ERR_OR_ZERO(ddata->reset_gpio);
 728         if (r)
 729                 goto err_gpio;
 730
 731         if (ddata->reset_gpio) {
 732                 gpiod_set_consumer_name(ddata->reset_gpio, "lcd reset");
 733
 734                 /* release the reset line */
 735                 gpiod_set_value_cansleep(ddata->reset_gpio, 1);
 736         }
 737
 738         /*
 739          * After reset we have to wait 5 msec before the first
 740          * command can be sent.
 741          */
 742         usleep_range(5000, 10000);
 743
 744         ddata->enabled = panel_enabled(ddata);
 745
 746         r = panel_detect(ddata);
 747
 748         if (!ddata->enabled && ddata->reset_gpio)
 749                 gpiod_set_value_cansleep(ddata->reset_gpio, 0);
 750
 751         if (r) {
 752                 dev_err(&spi->dev, "%s panel detect error\n", __func__);
 753                 goto err_detect;
 754         }
 755
 756         memset(&props, 0, sizeof(props));
 757         props.power = BACKLIGHT_POWER_ON;
 758         props.type = BACKLIGHT_RAW;
 759
 760         bldev = backlight_device_register("acx565akm", &ddata->spi->dev,
 761                         ddata, &acx565akm_bl_ops, &props);
 762         if (IS_ERR(bldev)) {
 763                 r = PTR_ERR(bldev);
 764                 goto err_reg_bl;
 765         }
 766         ddata->bl_dev = bldev;
 767         if (ddata->has_cabc) {
 768                 r = sysfs_create_group(&bldev->dev.kobj, &bldev_attr_group);
 769                 if (r) {
 770                         dev_err(&bldev->dev,
 771                                 "%s failed to create sysfs files\n", __func__);
 772                         goto err_sysfs;
 773                 }
 774                 ddata->cabc_mode = get_hw_cabc_mode(ddata);
 775         }
 776
 777         max_brightness = 255;
 778
 779         if (ddata->has_bc)
 780                 brightness = acx565akm_get_actual_brightness(ddata);
 781         else
 782                 brightness = 0;
 783
 784         bldev->props.max_brightness = max_brightness;
 785         bldev->props.brightness = brightness;
 786
 787         acx565akm_bl_update_status(bldev);
 788
 789
 790         ddata->videomode = acx565akm_panel_timings;
 791
 792         dssdev = &ddata->dssdev;
 793         dssdev->dev = &spi->dev;
 794         dssdev->driver = &acx565akm_ops;
 795         dssdev->type = OMAP_DISPLAY_TYPE_SDI;
 796         dssdev->owner = THIS_MODULE;
 797         dssdev->panel.timings = ddata->videomode;
 798
 799         r = omapdss_register_display(dssdev);
 800         if (r) {
 801                 dev_err(&spi->dev, "Failed to register panel\n");
 802                 goto err_reg;
 803         }
 804
 805         return 0;
 806
 807 err_reg:
 808         sysfs_remove_group(&bldev->dev.kobj, &bldev_attr_group);
 809 err_sysfs:
 810         backlight_device_unregister(bldev);
 811 err_reg_bl:
 812 err_detect:
 813 err_gpio:
 814         omap_dss_put_device(ddata->in);
 815         return r;
 816 }
 817
 818 static void acx565akm_remove(struct spi_device *spi)
 819 {
 820         struct panel_drv_data *ddata = dev_get_drvdata(&spi->dev);
 821         struct omap_dss_device *dssdev = &ddata->dssdev;
 822         struct omap_dss_device *in = ddata->in;
 823
 824         dev_dbg(&ddata->spi->dev, "%s\n", __func__);
 825
 826         sysfs_remove_group(&ddata->bl_dev->dev.kobj, &bldev_attr_group);
 827         backlight_device_unregister(ddata->bl_dev);
 828
 829         omapdss_unregister_display(dssdev);
 830
 831         acx565akm_disable(dssdev);
 832         acx565akm_disconnect(dssdev);
 833
 834         omap_dss_put_device(in);
 835 }
 836
 837 static const struct of_device_id acx565akm_of_match[] = {
 838         { .compatible = "omapdss,sony,acx565akm", },
 839         {},
 840 };
 841 MODULE_DEVICE_TABLE(of, acx565akm_of_match);
 842
 843 static struct spi_driver acx565akm_driver = {
 844         .driver = {
 845                 .name   = "acx565akm",
 846                 .of_match_table = acx565akm_of_match,
 847                 .suppress_bind_attrs = true,
 848         },
 849         .probe  = acx565akm_probe,
 850         .remove = acx565akm_remove,
 851 };
 852
 853 module_spi_driver(acx565akm_driver);
 854
 855 MODULE_AUTHOR("Nokia Corporation");
 856 MODULE_DESCRIPTION("acx565akm LCD Driver");
 857 MODULE_LICENSE("GPL");