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@ti.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         __be32 v;
 220         u32 disp_status;
 221         int enabled;
 222
 223         acx565akm_read(ddata, MIPID_CMD_READ_DISP_STATUS, (u8 *)&v, 4);
 224         disp_status = __be32_to_cpu(v);
 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 int 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 int get_cabc_mode(struct panel_drv_data *ddata)
 307 {
 308         return ddata->cabc_mode;
 309 }
 310
 311 static unsigned int 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;
 514         int r;
 515
 516         if (omapdss_device_is_connected(dssdev))
 517                 return 0;
 518
 519         in = omapdss_of_find_source_for_first_ep(dssdev->dev->of_node);
 520         if (IS_ERR(in)) {
 521                 dev_err(dssdev->dev, "failed to find video source\n");
 522                 return PTR_ERR(in);
 523         }
 524
 525         r = in->ops.sdi->connect(in, dssdev);
 526         if (r) {
 527                 omap_dss_put_device(in);
 528                 return r;
 529         }
 530
 531         ddata->in = in;
 532         return 0;
 533 }
 534
 535 static void acx565akm_disconnect(struct omap_dss_device *dssdev)
 536 {
 537         struct panel_drv_data *ddata = to_panel_data(dssdev);
 538         struct omap_dss_device *in = ddata->in;
 539
 540         if (!omapdss_device_is_connected(dssdev))
 541                 return;
 542
 543         in->ops.sdi->disconnect(in, dssdev);
 544
 545         omap_dss_put_device(in);
 546         ddata->in = NULL;
 547 }
 548
 549 static int acx565akm_panel_power_on(struct omap_dss_device *dssdev)
 550 {
 551         struct panel_drv_data *ddata = to_panel_data(dssdev);
 552         struct omap_dss_device *in = ddata->in;
 553         int r;
 554
 555         dev_dbg(&ddata->spi->dev, "%s\n", __func__);
 556
 557         in->ops.sdi->set_timings(in, &ddata->vm);
 558
 559         r = in->ops.sdi->enable(in);
 560         if (r) {
 561                 pr_err("%s sdi enable failed\n", __func__);
 562                 return r;
 563         }
 564
 565         /*FIXME tweak me */
 566         msleep(50);
 567
 568         if (gpio_is_valid(ddata->reset_gpio))
 569                 gpio_set_value(ddata->reset_gpio, 1);
 570
 571         if (ddata->enabled) {
 572                 dev_dbg(&ddata->spi->dev, "panel already enabled\n");
 573                 return 0;
 574         }
 575
 576         /*
 577          * We have to meet all the following delay requirements:
 578          * 1. tRW: reset pulse width 10usec (7.12.1)
 579          * 2. tRT: reset cancel time 5msec (7.12.1)
 580          * 3. Providing PCLK,HS,VS signals for 2 frames = ~50msec worst
 581          *    case (7.6.2)
 582          * 4. 120msec before the sleep out command (7.12.1)
 583          */
 584         msleep(120);
 585
 586         set_sleep_mode(ddata, 0);
 587         ddata->enabled = 1;
 588
 589         /* 5msec between sleep out and the next command. (8.2.16) */
 590         usleep_range(5000, 10000);
 591         set_display_state(ddata, 1);
 592         set_cabc_mode(ddata, ddata->cabc_mode);
 593
 594         return acx565akm_bl_update_status(ddata->bl_dev);
 595 }
 596
 597 static void acx565akm_panel_power_off(struct omap_dss_device *dssdev)
 598 {
 599         struct panel_drv_data *ddata = to_panel_data(dssdev);
 600         struct omap_dss_device *in = ddata->in;
 601
 602         dev_dbg(dssdev->dev, "%s\n", __func__);
 603
 604         if (!ddata->enabled)
 605                 return;
 606
 607         set_display_state(ddata, 0);
 608         set_sleep_mode(ddata, 1);
 609         ddata->enabled = 0;
 610         /*
 611          * We have to provide PCLK,HS,VS signals for 2 frames (worst case
 612          * ~50msec) after sending the sleep in command and asserting the
 613          * reset signal. We probably could assert the reset w/o the delay
 614          * but we still delay to avoid possible artifacts. (7.6.1)
 615          */
 616         msleep(50);
 617
 618         if (gpio_is_valid(ddata->reset_gpio))
 619                 gpio_set_value(ddata->reset_gpio, 0);
 620
 621         /* FIXME need to tweak this delay */
 622         msleep(100);
 623
 624         in->ops.sdi->disable(in);
 625 }
 626
 627 static int acx565akm_enable(struct omap_dss_device *dssdev)
 628 {
 629         struct panel_drv_data *ddata = to_panel_data(dssdev);
 630         int r;
 631
 632         dev_dbg(dssdev->dev, "%s\n", __func__);
 633
 634         if (!omapdss_device_is_connected(dssdev))
 635                 return -ENODEV;
 636
 637         if (omapdss_device_is_enabled(dssdev))
 638                 return 0;
 639
 640         mutex_lock(&ddata->mutex);
 641         r = acx565akm_panel_power_on(dssdev);
 642         mutex_unlock(&ddata->mutex);
 643         if (r)
 644                 return r;
 645
 646         dssdev->state = OMAP_DSS_DISPLAY_ACTIVE;
 647
 648         return 0;
 649 }
 650
 651 static void acx565akm_disable(struct omap_dss_device *dssdev)
 652 {
 653         struct panel_drv_data *ddata = to_panel_data(dssdev);
 654
 655         dev_dbg(dssdev->dev, "%s\n", __func__);
 656
 657         if (!omapdss_device_is_enabled(dssdev))
 658                 return;
 659
 660         mutex_lock(&ddata->mutex);
 661         acx565akm_panel_power_off(dssdev);
 662         mutex_unlock(&ddata->mutex);
 663
 664         dssdev->state = OMAP_DSS_DISPLAY_DISABLED;
 665 }
 666
 667 static void acx565akm_set_timings(struct omap_dss_device *dssdev,
 668                                   struct videomode *vm)
 669 {
 670         struct panel_drv_data *ddata = to_panel_data(dssdev);
 671         struct omap_dss_device *in = ddata->in;
 672
 673         ddata->vm = *vm;
 674         dssdev->panel.vm = *vm;
 675
 676         in->ops.sdi->set_timings(in, vm);
 677 }
 678
 679 static void acx565akm_get_timings(struct omap_dss_device *dssdev,
 680                                   struct videomode *vm)
 681 {
 682         struct panel_drv_data *ddata = to_panel_data(dssdev);
 683
 684         *vm = ddata->vm;
 685 }
 686
 687 static int acx565akm_check_timings(struct omap_dss_device *dssdev,
 688                                    struct videomode *vm)
 689 {
 690         struct panel_drv_data *ddata = to_panel_data(dssdev);
 691         struct omap_dss_device *in = ddata->in;
 692
 693         return in->ops.sdi->check_timings(in, vm);
 694 }
 695
 696 static struct omap_dss_driver acx565akm_ops = {
 697         .connect        = acx565akm_connect,
 698         .disconnect     = acx565akm_disconnect,
 699
 700         .enable         = acx565akm_enable,
 701         .disable        = acx565akm_disable,
 702
 703         .set_timings    = acx565akm_set_timings,
 704         .get_timings    = acx565akm_get_timings,
 705         .check_timings  = acx565akm_check_timings,
 706 };
 707
 708 static int acx565akm_probe_of(struct spi_device *spi)
 709 {
 710         struct panel_drv_data *ddata = dev_get_drvdata(&spi->dev);
 711         struct device_node *np = spi->dev.of_node;
 712
 713         ddata->reset_gpio = of_get_named_gpio(np, "reset-gpios", 0);
 714
 715         return 0;
 716 }
 717
 718 static int acx565akm_probe(struct spi_device *spi)
 719 {
 720         struct panel_drv_data *ddata;
 721         struct omap_dss_device *dssdev;
 722         struct backlight_device *bldev;
 723         int max_brightness, brightness;
 724         struct backlight_properties props;
 725         int r;
 726
 727         dev_dbg(&spi->dev, "%s\n", __func__);
 728
 729         spi->mode = SPI_MODE_3;
 730
 731         ddata = devm_kzalloc(&spi->dev, sizeof(*ddata), GFP_KERNEL);
 732         if (ddata == NULL)
 733                 return -ENOMEM;
 734
 735         dev_set_drvdata(&spi->dev, ddata);
 736
 737         ddata->spi = spi;
 738
 739         mutex_init(&ddata->mutex);
 740
 741         r = acx565akm_probe_of(spi);
 742         if (r)
 743                 return r;
 744
 745         if (gpio_is_valid(ddata->reset_gpio)) {
 746                 r = devm_gpio_request_one(&spi->dev, ddata->reset_gpio,
 747                                 GPIOF_OUT_INIT_LOW, "lcd reset");
 748                 if (r)
 749                         goto err_gpio;
 750         }
 751
 752         if (gpio_is_valid(ddata->reset_gpio))
 753                 gpio_set_value(ddata->reset_gpio, 1);
 754
 755         /*
 756          * After reset we have to wait 5 msec before the first
 757          * command can be sent.
 758          */
 759         usleep_range(5000, 10000);
 760
 761         ddata->enabled = panel_enabled(ddata);
 762
 763         r = panel_detect(ddata);
 764
 765         if (!ddata->enabled && gpio_is_valid(ddata->reset_gpio))
 766                 gpio_set_value(ddata->reset_gpio, 0);
 767
 768         if (r) {
 769                 dev_err(&spi->dev, "%s panel detect error\n", __func__);
 770                 goto err_detect;
 771         }
 772
 773         memset(&props, 0, sizeof(props));
 774         props.fb_blank = FB_BLANK_UNBLANK;
 775         props.power = FB_BLANK_UNBLANK;
 776         props.type = BACKLIGHT_RAW;
 777
 778         bldev = backlight_device_register("acx565akm", &ddata->spi->dev,
 779                         ddata, &acx565akm_bl_ops, &props);
 780         if (IS_ERR(bldev)) {
 781                 r = PTR_ERR(bldev);
 782                 goto err_reg_bl;
 783         }
 784         ddata->bl_dev = bldev;
 785         if (ddata->has_cabc) {
 786                 r = sysfs_create_group(&bldev->dev.kobj, &bldev_attr_group);
 787                 if (r) {
 788                         dev_err(&bldev->dev,
 789                                 "%s failed to create sysfs files\n", __func__);
 790                         goto err_sysfs;
 791                 }
 792                 ddata->cabc_mode = get_hw_cabc_mode(ddata);
 793         }
 794
 795         max_brightness = 255;
 796
 797         if (ddata->has_bc)
 798                 brightness = acx565akm_get_actual_brightness(ddata);
 799         else
 800                 brightness = 0;
 801
 802         bldev->props.max_brightness = max_brightness;
 803         bldev->props.brightness = brightness;
 804
 805         acx565akm_bl_update_status(bldev);
 806
 807
 808         ddata->vm = acx565akm_panel_vm;
 809
 810         dssdev = &ddata->dssdev;
 811         dssdev->dev = &spi->dev;
 812         dssdev->driver = &acx565akm_ops;
 813         dssdev->type = OMAP_DISPLAY_TYPE_SDI;
 814         dssdev->owner = THIS_MODULE;
 815         dssdev->panel.vm = ddata->vm;
 816
 817         r = omapdss_register_display(dssdev);
 818         if (r) {
 819                 dev_err(&spi->dev, "Failed to register panel\n");
 820                 goto err_reg;
 821         }
 822
 823         return 0;
 824
 825 err_reg:
 826         sysfs_remove_group(&bldev->dev.kobj, &bldev_attr_group);
 827 err_sysfs:
 828         backlight_device_unregister(bldev);
 829 err_reg_bl:
 830 err_detect:
 831 err_gpio:
 832         return r;
 833 }
 834
 835 static int acx565akm_remove(struct spi_device *spi)
 836 {
 837         struct panel_drv_data *ddata = dev_get_drvdata(&spi->dev);
 838         struct omap_dss_device *dssdev = &ddata->dssdev;
 839
 840         dev_dbg(&ddata->spi->dev, "%s\n", __func__);
 841
 842         sysfs_remove_group(&ddata->bl_dev->dev.kobj, &bldev_attr_group);
 843         backlight_device_unregister(ddata->bl_dev);
 844
 845         omapdss_unregister_display(dssdev);
 846
 847         acx565akm_disable(dssdev);
 848         acx565akm_disconnect(dssdev);
 849
 850         return 0;
 851 }
 852
 853 static const struct of_device_id acx565akm_of_match[] = {
 854         { .compatible = "omapdss,sony,acx565akm", },
 855         {},
 856 };
 857 MODULE_DEVICE_TABLE(of, acx565akm_of_match);
 858
 859 static struct spi_driver acx565akm_driver = {
 860         .driver = {
 861                 .name   = "acx565akm",
 862                 .of_match_table = acx565akm_of_match,
 863                 .suppress_bind_attrs = true,
 864         },
 865         .probe  = acx565akm_probe,
 866         .remove = acx565akm_remove,
 867 };
 868
 869 module_spi_driver(acx565akm_driver);
 870
 871 MODULE_ALIAS("spi:sony,acx565akm");
 872 MODULE_AUTHOR("Nokia Corporation");
 873 MODULE_DESCRIPTION("acx565akm LCD Driver");
 874 MODULE_LICENSE("GPL");