drivers/gpu/drm/omapdrm/displays/panel-sony-acx565akm.c

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