linux/drivers/gpu/drm/omapdrm/displays/panel-sony-acx565akm.c
<<
>>
Prefs
   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
  65struct 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
  92static 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
 110static 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
 160static inline void acx565akm_cmd(struct panel_drv_data *ddata, int cmd)
 161{
 162        acx565akm_transfer(ddata, cmd, NULL, 0, NULL, 0);
 163}
 164
 165static 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
 171static 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
 177static 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
 183static 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
 193static 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
 210static 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
 217static 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
 232static 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
 275static 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
 292static 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
 306static unsigned get_cabc_mode(struct panel_drv_data *ddata)
 307{
 308        return ddata->cabc_mode;
 309}
 310
 311static 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
 319static 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
 332static 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
 342static 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
 363static 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
 383static 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
 395static 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
 407static 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
 414static const char * const cabc_modes[] = {
 415        "off",          /* always used when CABC is not supported */
 416        "ui",
 417        "still-image",
 418        "moving-image",
 419};
 420
 421static 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
 442static 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
 475static 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
 495static DEVICE_ATTR(cabc_mode, S_IRUGO | S_IWUSR,
 496                show_cabc_mode, store_cabc_mode);
 497static DEVICE_ATTR(cabc_available_modes, S_IRUGO,
 498                show_cabc_available_modes, NULL);
 499
 500static struct attribute *bldev_attrs[] = {
 501        &dev_attr_cabc_mode.attr,
 502        &dev_attr_cabc_available_modes.attr,
 503        NULL,
 504};
 505
 506static const struct attribute_group bldev_attr_group = {
 507        .attrs = bldev_attrs,
 508};
 509
 510static 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
 526static 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
 537static 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
 585static 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
 615static 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
 639static 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
 655static 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
 667static 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
 675static 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
 684static 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
 696static 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
 712static 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
 822err_reg:
 823        sysfs_remove_group(&bldev->dev.kobj, &bldev_attr_group);
 824err_sysfs:
 825        backlight_device_unregister(bldev);
 826err_reg_bl:
 827err_detect:
 828err_gpio:
 829        omap_dss_put_device(ddata->in);
 830        return r;
 831}
 832
 833static 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
 854static const struct of_device_id acx565akm_of_match[] = {
 855        { .compatible = "omapdss,sony,acx565akm", },
 856        {},
 857};
 858MODULE_DEVICE_TABLE(of, acx565akm_of_match);
 859
 860static 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
 870module_spi_driver(acx565akm_driver);
 871
 872MODULE_ALIAS("spi:sony,acx565akm");
 873MODULE_AUTHOR("Nokia Corporation");
 874MODULE_DESCRIPTION("acx565akm LCD Driver");
 875MODULE_LICENSE("GPL");
 876