Pileus Git - ~andy/linux/blob - drivers/video/omap2/displays/panel-taal.c

   1 /*
   2  * Taal DSI command mode panel
   3  *
   4  * Copyright (C) 2009 Nokia Corporation
   5  * Author: Tomi Valkeinen <tomi.valkeinen@nokia.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License version 2 as published by
   9  * the Free Software Foundation.
  10  *
  11  * This program is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  14  * more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along with
  17  * this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 /*#define DEBUG*/
  21
  22 #include <linux/module.h>
  23 #include <linux/delay.h>
  24 #include <linux/err.h>
  25 #include <linux/jiffies.h>
  26 #include <linux/sched.h>
  27 #include <linux/backlight.h>
  28 #include <linux/fb.h>
  29 #include <linux/interrupt.h>
  30 #include <linux/gpio.h>
  31 #include <linux/workqueue.h>
  32 #include <linux/slab.h>
  33 #include <linux/regulator/consumer.h>
  34 #include <linux/mutex.h>
  35
  36 #include <video/omapdss.h>
  37 #include <video/omap-panel-nokia-dsi.h>
  38 #include <video/mipi_display.h>
  39
  40 /* DSI Virtual channel. Hardcoded for now. */
  41 #define TCH 0
  42
  43 #define DCS_READ_NUM_ERRORS     0x05
  44 #define DCS_BRIGHTNESS          0x51
  45 #define DCS_CTRL_DISPLAY        0x53
  46 #define DCS_WRITE_CABC          0x55
  47 #define DCS_READ_CABC           0x56
  48 #define DCS_GET_ID1             0xda
  49 #define DCS_GET_ID2             0xdb
  50 #define DCS_GET_ID3             0xdc
  51
  52 static irqreturn_t taal_te_isr(int irq, void *data);
  53 static void taal_te_timeout_work_callback(struct work_struct *work);
  54 static int _taal_enable_te(struct omap_dss_device *dssdev, bool enable);
  55
  56 static int taal_panel_reset(struct omap_dss_device *dssdev);
  57
  58 struct panel_regulator {
  59         struct regulator *regulator;
  60         const char *name;
  61         int min_uV;
  62         int max_uV;
  63 };
  64
  65 static void free_regulators(struct panel_regulator *regulators, int n)
  66 {
  67         int i;
  68
  69         for (i = 0; i < n; i++) {
  70                 /* disable/put in reverse order */
  71                 regulator_disable(regulators[n - i - 1].regulator);
  72                 regulator_put(regulators[n - i - 1].regulator);
  73         }
  74 }
  75
  76 static int init_regulators(struct omap_dss_device *dssdev,
  77                         struct panel_regulator *regulators, int n)
  78 {
  79         int r, i, v;
  80
  81         for (i = 0; i < n; i++) {
  82                 struct regulator *reg;
  83
  84                 reg = regulator_get(&dssdev->dev, regulators[i].name);
  85                 if (IS_ERR(reg)) {
  86                         dev_err(&dssdev->dev, "failed to get regulator %s\n",
  87                                 regulators[i].name);
  88                         r = PTR_ERR(reg);
  89                         goto err;
  90                 }
  91
  92                 /* FIXME: better handling of fixed vs. variable regulators */
  93                 v = regulator_get_voltage(reg);
  94                 if (v < regulators[i].min_uV || v > regulators[i].max_uV) {
  95                         r = regulator_set_voltage(reg, regulators[i].min_uV,
  96                                                 regulators[i].max_uV);
  97                         if (r) {
  98                                 dev_err(&dssdev->dev,
  99                                         "failed to set regulator %s voltage\n",
 100                                         regulators[i].name);
 101                                 regulator_put(reg);
 102                                 goto err;
 103                         }
 104                 }
 105
 106                 r = regulator_enable(reg);
 107                 if (r) {
 108                         dev_err(&dssdev->dev, "failed to enable regulator %s\n",
 109                                 regulators[i].name);
 110                         regulator_put(reg);
 111                         goto err;
 112                 }
 113
 114                 regulators[i].regulator = reg;
 115         }
 116
 117         return 0;
 118
 119 err:
 120         free_regulators(regulators, i);
 121
 122         return r;
 123 }
 124
 125 /**
 126  * struct panel_config - panel configuration
 127  * @name: panel name
 128  * @type: panel type
 129  * @timings: panel resolution
 130  * @sleep: various panel specific delays, passed to msleep() if non-zero
 131  * @reset_sequence: reset sequence timings, passed to udelay() if non-zero
 132  * @regulators: array of panel regulators
 133  * @num_regulators: number of regulators in the array
 134  */
 135 struct panel_config {
 136         const char *name;
 137         int type;
 138
 139         struct omap_video_timings timings;
 140
 141         struct {
 142                 unsigned int sleep_in;
 143                 unsigned int sleep_out;
 144                 unsigned int hw_reset;
 145                 unsigned int enable_te;
 146         } sleep;
 147
 148         struct {
 149                 unsigned int high;
 150                 unsigned int low;
 151         } reset_sequence;
 152
 153         struct panel_regulator *regulators;
 154         int num_regulators;
 155 };
 156
 157 enum {
 158         PANEL_TAAL,
 159 };
 160
 161 static struct panel_config panel_configs[] = {
 162         {
 163                 .name           = "taal",
 164                 .type           = PANEL_TAAL,
 165                 .timings        = {
 166                         .x_res          = 864,
 167                         .y_res          = 480,
 168                 },
 169                 .sleep          = {
 170                         .sleep_in       = 5,
 171                         .sleep_out      = 5,
 172                         .hw_reset       = 5,
 173                         .enable_te      = 100, /* possible panel bug */
 174                 },
 175                 .reset_sequence = {
 176                         .high           = 10,
 177                         .low            = 10,
 178                 },
 179         },
 180 };
 181
 182 struct taal_data {
 183         struct mutex lock;
 184
 185         struct backlight_device *bldev;
 186
 187         unsigned long   hw_guard_end;   /* next value of jiffies when we can
 188                                          * issue the next sleep in/out command
 189                                          */
 190         unsigned long   hw_guard_wait;  /* max guard time in jiffies */
 191
 192         struct omap_dss_device *dssdev;
 193
 194         bool enabled;
 195         u8 rotate;
 196         bool mirror;
 197
 198         bool te_enabled;
 199
 200         atomic_t do_update;
 201         int channel;
 202
 203         struct delayed_work te_timeout_work;
 204
 205         bool cabc_broken;
 206         unsigned cabc_mode;
 207
 208         bool intro_printed;
 209
 210         struct workqueue_struct *workqueue;
 211
 212         struct delayed_work esd_work;
 213         unsigned esd_interval;
 214
 215         bool ulps_enabled;
 216         unsigned ulps_timeout;
 217         struct delayed_work ulps_work;
 218
 219         struct panel_config *panel_config;
 220 };
 221
 222 static inline struct nokia_dsi_panel_data
 223 *get_panel_data(const struct omap_dss_device *dssdev)
 224 {
 225         return (struct nokia_dsi_panel_data *) dssdev->data;
 226 }
 227
 228 static void taal_esd_work(struct work_struct *work);
 229 static void taal_ulps_work(struct work_struct *work);
 230
 231 static void hw_guard_start(struct taal_data *td, int guard_msec)
 232 {
 233         td->hw_guard_wait = msecs_to_jiffies(guard_msec);
 234         td->hw_guard_end = jiffies + td->hw_guard_wait;
 235 }
 236
 237 static void hw_guard_wait(struct taal_data *td)
 238 {
 239         unsigned long wait = td->hw_guard_end - jiffies;
 240
 241         if ((long)wait > 0 && wait <= td->hw_guard_wait) {
 242                 set_current_state(TASK_UNINTERRUPTIBLE);
 243                 schedule_timeout(wait);
 244         }
 245 }
 246
 247 static int taal_dcs_read_1(struct taal_data *td, u8 dcs_cmd, u8 *data)
 248 {
 249         int r;
 250         u8 buf[1];
 251
 252         r = dsi_vc_dcs_read(td->dssdev, td->channel, dcs_cmd, buf, 1);
 253
 254         if (r < 0)
 255                 return r;
 256
 257         *data = buf[0];
 258
 259         return 0;
 260 }
 261
 262 static int taal_dcs_write_0(struct taal_data *td, u8 dcs_cmd)
 263 {
 264         return dsi_vc_dcs_write(td->dssdev, td->channel, &dcs_cmd, 1);
 265 }
 266
 267 static int taal_dcs_write_1(struct taal_data *td, u8 dcs_cmd, u8 param)
 268 {
 269         u8 buf[2];
 270         buf[0] = dcs_cmd;
 271         buf[1] = param;
 272         return dsi_vc_dcs_write(td->dssdev, td->channel, buf, 2);
 273 }
 274
 275 static int taal_sleep_in(struct taal_data *td)
 276
 277 {
 278         u8 cmd;
 279         int r;
 280
 281         hw_guard_wait(td);
 282
 283         cmd = MIPI_DCS_ENTER_SLEEP_MODE;
 284         r = dsi_vc_dcs_write_nosync(td->dssdev, td->channel, &cmd, 1);
 285         if (r)
 286                 return r;
 287
 288         hw_guard_start(td, 120);
 289
 290         if (td->panel_config->sleep.sleep_in)
 291                 msleep(td->panel_config->sleep.sleep_in);
 292
 293         return 0;
 294 }
 295
 296 static int taal_sleep_out(struct taal_data *td)
 297 {
 298         int r;
 299
 300         hw_guard_wait(td);
 301
 302         r = taal_dcs_write_0(td, MIPI_DCS_EXIT_SLEEP_MODE);
 303         if (r)
 304                 return r;
 305
 306         hw_guard_start(td, 120);
 307
 308         if (td->panel_config->sleep.sleep_out)
 309                 msleep(td->panel_config->sleep.sleep_out);
 310
 311         return 0;
 312 }
 313
 314 static int taal_get_id(struct taal_data *td, u8 *id1, u8 *id2, u8 *id3)
 315 {
 316         int r;
 317
 318         r = taal_dcs_read_1(td, DCS_GET_ID1, id1);
 319         if (r)
 320                 return r;
 321         r = taal_dcs_read_1(td, DCS_GET_ID2, id2);
 322         if (r)
 323                 return r;
 324         r = taal_dcs_read_1(td, DCS_GET_ID3, id3);
 325         if (r)
 326                 return r;
 327
 328         return 0;
 329 }
 330
 331 static int taal_set_addr_mode(struct taal_data *td, u8 rotate, bool mirror)
 332 {
 333         int r;
 334         u8 mode;
 335         int b5, b6, b7;
 336
 337         r = taal_dcs_read_1(td, MIPI_DCS_GET_ADDRESS_MODE, &mode);
 338         if (r)
 339                 return r;
 340
 341         switch (rotate) {
 342         default:
 343         case 0:
 344                 b7 = 0;
 345                 b6 = 0;
 346                 b5 = 0;
 347                 break;
 348         case 1:
 349                 b7 = 0;
 350                 b6 = 1;
 351                 b5 = 1;
 352                 break;
 353         case 2:
 354                 b7 = 1;
 355                 b6 = 1;
 356                 b5 = 0;
 357                 break;
 358         case 3:
 359                 b7 = 1;
 360                 b6 = 0;
 361                 b5 = 1;
 362                 break;
 363         }
 364
 365         if (mirror)
 366                 b6 = !b6;
 367
 368         mode &= ~((1<<7) | (1<<6) | (1<<5));
 369         mode |= (b7 << 7) | (b6 << 6) | (b5 << 5);
 370
 371         return taal_dcs_write_1(td, MIPI_DCS_SET_ADDRESS_MODE, mode);
 372 }
 373
 374 static int taal_set_update_window(struct taal_data *td,
 375                 u16 x, u16 y, u16 w, u16 h)
 376 {
 377         int r;
 378         u16 x1 = x;
 379         u16 x2 = x + w - 1;
 380         u16 y1 = y;
 381         u16 y2 = y + h - 1;
 382
 383         u8 buf[5];
 384         buf[0] = MIPI_DCS_SET_COLUMN_ADDRESS;
 385         buf[1] = (x1 >> 8) & 0xff;
 386         buf[2] = (x1 >> 0) & 0xff;
 387         buf[3] = (x2 >> 8) & 0xff;
 388         buf[4] = (x2 >> 0) & 0xff;
 389
 390         r = dsi_vc_dcs_write_nosync(td->dssdev, td->channel, buf, sizeof(buf));
 391         if (r)
 392                 return r;
 393
 394         buf[0] = MIPI_DCS_SET_PAGE_ADDRESS;
 395         buf[1] = (y1 >> 8) & 0xff;
 396         buf[2] = (y1 >> 0) & 0xff;
 397         buf[3] = (y2 >> 8) & 0xff;
 398         buf[4] = (y2 >> 0) & 0xff;
 399
 400         r = dsi_vc_dcs_write_nosync(td->dssdev, td->channel, buf, sizeof(buf));
 401         if (r)
 402                 return r;
 403
 404         dsi_vc_send_bta_sync(td->dssdev, td->channel);
 405
 406         return r;
 407 }
 408
 409 static void taal_queue_esd_work(struct omap_dss_device *dssdev)
 410 {
 411         struct taal_data *td = dev_get_drvdata(&dssdev->dev);
 412
 413         if (td->esd_interval > 0)
 414                 queue_delayed_work(td->workqueue, &td->esd_work,
 415                                 msecs_to_jiffies(td->esd_interval));
 416 }
 417
 418 static void taal_cancel_esd_work(struct omap_dss_device *dssdev)
 419 {
 420         struct taal_data *td = dev_get_drvdata(&dssdev->dev);
 421
 422         cancel_delayed_work(&td->esd_work);
 423 }
 424
 425 static void taal_queue_ulps_work(struct omap_dss_device *dssdev)
 426 {
 427         struct taal_data *td = dev_get_drvdata(&dssdev->dev);
 428
 429         if (td->ulps_timeout > 0)
 430                 queue_delayed_work(td->workqueue, &td->ulps_work,
 431                                 msecs_to_jiffies(td->ulps_timeout));
 432 }
 433
 434 static void taal_cancel_ulps_work(struct omap_dss_device *dssdev)
 435 {
 436         struct taal_data *td = dev_get_drvdata(&dssdev->dev);
 437
 438         cancel_delayed_work(&td->ulps_work);
 439 }
 440
 441 static int taal_enter_ulps(struct omap_dss_device *dssdev)
 442 {
 443         struct taal_data *td = dev_get_drvdata(&dssdev->dev);
 444         struct nokia_dsi_panel_data *panel_data = get_panel_data(dssdev);
 445         int r;
 446
 447         if (td->ulps_enabled)
 448                 return 0;
 449
 450         taal_cancel_ulps_work(dssdev);
 451
 452         r = _taal_enable_te(dssdev, false);
 453         if (r)
 454                 goto err;
 455
 456         disable_irq(gpio_to_irq(panel_data->ext_te_gpio));
 457
 458         omapdss_dsi_display_disable(dssdev, false, true);
 459
 460         td->ulps_enabled = true;
 461
 462         return 0;
 463
 464 err:
 465         dev_err(&dssdev->dev, "enter ULPS failed");
 466         taal_panel_reset(dssdev);
 467
 468         td->ulps_enabled = false;
 469
 470         taal_queue_ulps_work(dssdev);
 471
 472         return r;
 473 }
 474
 475 static int taal_exit_ulps(struct omap_dss_device *dssdev)
 476 {
 477         struct taal_data *td = dev_get_drvdata(&dssdev->dev);
 478         struct nokia_dsi_panel_data *panel_data = get_panel_data(dssdev);
 479         int r;
 480
 481         if (!td->ulps_enabled)
 482                 return 0;
 483
 484         r = omapdss_dsi_display_enable(dssdev);
 485         if (r) {
 486                 dev_err(&dssdev->dev, "failed to enable DSI\n");
 487                 goto err1;
 488         }
 489
 490         omapdss_dsi_vc_enable_hs(dssdev, td->channel, true);
 491
 492         r = _taal_enable_te(dssdev, true);
 493         if (r) {
 494                 dev_err(&dssdev->dev, "failed to re-enable TE");
 495                 goto err2;
 496         }
 497
 498         enable_irq(gpio_to_irq(panel_data->ext_te_gpio));
 499
 500         taal_queue_ulps_work(dssdev);
 501
 502         td->ulps_enabled = false;
 503
 504         return 0;
 505
 506 err2:
 507         dev_err(&dssdev->dev, "failed to exit ULPS");
 508
 509         r = taal_panel_reset(dssdev);
 510         if (!r) {
 511                 enable_irq(gpio_to_irq(panel_data->ext_te_gpio));
 512                 td->ulps_enabled = false;
 513         }
 514 err1:
 515         taal_queue_ulps_work(dssdev);
 516
 517         return r;
 518 }
 519
 520 static int taal_wake_up(struct omap_dss_device *dssdev)
 521 {
 522         struct taal_data *td = dev_get_drvdata(&dssdev->dev);
 523
 524         if (td->ulps_enabled)
 525                 return taal_exit_ulps(dssdev);
 526
 527         taal_cancel_ulps_work(dssdev);
 528         taal_queue_ulps_work(dssdev);
 529         return 0;
 530 }
 531
 532 static int taal_bl_update_status(struct backlight_device *dev)
 533 {
 534         struct omap_dss_device *dssdev = dev_get_drvdata(&dev->dev);
 535         struct taal_data *td = dev_get_drvdata(&dssdev->dev);
 536         int r;
 537         int level;
 538
 539         if (dev->props.fb_blank == FB_BLANK_UNBLANK &&
 540                         dev->props.power == FB_BLANK_UNBLANK)
 541                 level = dev->props.brightness;
 542         else
 543                 level = 0;
 544
 545         dev_dbg(&dssdev->dev, "update brightness to %d\n", level);
 546
 547         mutex_lock(&td->lock);
 548
 549         if (td->enabled) {
 550                 dsi_bus_lock(dssdev);
 551
 552                 r = taal_wake_up(dssdev);
 553                 if (!r)
 554                         r = taal_dcs_write_1(td, DCS_BRIGHTNESS, level);
 555
 556                 dsi_bus_unlock(dssdev);
 557         } else {
 558                 r = 0;
 559         }
 560
 561         mutex_unlock(&td->lock);
 562
 563         return r;
 564 }
 565
 566 static int taal_bl_get_intensity(struct backlight_device *dev)
 567 {
 568         if (dev->props.fb_blank == FB_BLANK_UNBLANK &&
 569                         dev->props.power == FB_BLANK_UNBLANK)
 570                 return dev->props.brightness;
 571
 572         return 0;
 573 }
 574
 575 static const struct backlight_ops taal_bl_ops = {
 576         .get_brightness = taal_bl_get_intensity,
 577         .update_status  = taal_bl_update_status,
 578 };
 579
 580 static void taal_get_timings(struct omap_dss_device *dssdev,
 581                         struct omap_video_timings *timings)
 582 {
 583         *timings = dssdev->panel.timings;
 584 }
 585
 586 static void taal_get_resolution(struct omap_dss_device *dssdev,
 587                 u16 *xres, u16 *yres)
 588 {
 589         struct taal_data *td = dev_get_drvdata(&dssdev->dev);
 590
 591         if (td->rotate == 0 || td->rotate == 2) {
 592                 *xres = dssdev->panel.timings.x_res;
 593                 *yres = dssdev->panel.timings.y_res;
 594         } else {
 595                 *yres = dssdev->panel.timings.x_res;
 596                 *xres = dssdev->panel.timings.y_res;
 597         }
 598 }
 599
 600 static ssize_t taal_num_errors_show(struct device *dev,
 601                 struct device_attribute *attr, char *buf)
 602 {
 603         struct omap_dss_device *dssdev = to_dss_device(dev);
 604         struct taal_data *td = dev_get_drvdata(&dssdev->dev);
 605         u8 errors;
 606         int r;
 607
 608         mutex_lock(&td->lock);
 609
 610         if (td->enabled) {
 611                 dsi_bus_lock(dssdev);
 612
 613                 r = taal_wake_up(dssdev);
 614                 if (!r)
 615                         r = taal_dcs_read_1(td, DCS_READ_NUM_ERRORS, &errors);
 616
 617                 dsi_bus_unlock(dssdev);
 618         } else {
 619                 r = -ENODEV;
 620         }
 621
 622         mutex_unlock(&td->lock);
 623
 624         if (r)
 625                 return r;
 626
 627         return snprintf(buf, PAGE_SIZE, "%d\n", errors);
 628 }
 629
 630 static ssize_t taal_hw_revision_show(struct device *dev,
 631                 struct device_attribute *attr, char *buf)
 632 {
 633         struct omap_dss_device *dssdev = to_dss_device(dev);
 634         struct taal_data *td = dev_get_drvdata(&dssdev->dev);
 635         u8 id1, id2, id3;
 636         int r;
 637
 638         mutex_lock(&td->lock);
 639
 640         if (td->enabled) {
 641                 dsi_bus_lock(dssdev);
 642
 643                 r = taal_wake_up(dssdev);
 644                 if (!r)
 645                         r = taal_get_id(td, &id1, &id2, &id3);
 646
 647                 dsi_bus_unlock(dssdev);
 648         } else {
 649                 r = -ENODEV;
 650         }
 651
 652         mutex_unlock(&td->lock);
 653
 654         if (r)
 655                 return r;
 656
 657         return snprintf(buf, PAGE_SIZE, "%02x.%02x.%02x\n", id1, id2, id3);
 658 }
 659
 660 static const char *cabc_modes[] = {
 661         "off",          /* used also always when CABC is not supported */
 662         "ui",
 663         "still-image",
 664         "moving-image",
 665 };
 666
 667 static ssize_t show_cabc_mode(struct device *dev,
 668                 struct device_attribute *attr,
 669                 char *buf)
 670 {
 671         struct omap_dss_device *dssdev = to_dss_device(dev);
 672         struct taal_data *td = dev_get_drvdata(&dssdev->dev);
 673         const char *mode_str;
 674         int mode;
 675         int len;
 676
 677         mode = td->cabc_mode;
 678
 679         mode_str = "unknown";
 680         if (mode >= 0 && mode < ARRAY_SIZE(cabc_modes))
 681                 mode_str = cabc_modes[mode];
 682         len = snprintf(buf, PAGE_SIZE, "%s\n", mode_str);
 683
 684         return len < PAGE_SIZE - 1 ? len : PAGE_SIZE - 1;
 685 }
 686
 687 static ssize_t store_cabc_mode(struct device *dev,
 688                 struct device_attribute *attr,
 689                 const char *buf, size_t count)
 690 {
 691         struct omap_dss_device *dssdev = to_dss_device(dev);
 692         struct taal_data *td = dev_get_drvdata(&dssdev->dev);
 693         int i;
 694         int r;
 695
 696         for (i = 0; i < ARRAY_SIZE(cabc_modes); i++) {
 697                 if (sysfs_streq(cabc_modes[i], buf))
 698                         break;
 699         }
 700
 701         if (i == ARRAY_SIZE(cabc_modes))
 702                 return -EINVAL;
 703
 704         mutex_lock(&td->lock);
 705
 706         if (td->enabled) {
 707                 dsi_bus_lock(dssdev);
 708
 709                 if (!td->cabc_broken) {
 710                         r = taal_wake_up(dssdev);
 711                         if (r)
 712                                 goto err;
 713
 714                         r = taal_dcs_write_1(td, DCS_WRITE_CABC, i);
 715                         if (r)
 716                                 goto err;
 717                 }
 718
 719                 dsi_bus_unlock(dssdev);
 720         }
 721
 722         td->cabc_mode = i;
 723
 724         mutex_unlock(&td->lock);
 725
 726         return count;
 727 err:
 728         dsi_bus_unlock(dssdev);
 729         mutex_unlock(&td->lock);
 730         return r;
 731 }
 732
 733 static ssize_t show_cabc_available_modes(struct device *dev,
 734                 struct device_attribute *attr,
 735                 char *buf)
 736 {
 737         int len;
 738         int i;
 739
 740         for (i = 0, len = 0;
 741              len < PAGE_SIZE && i < ARRAY_SIZE(cabc_modes); i++)
 742                 len += snprintf(&buf[len], PAGE_SIZE - len, "%s%s%s",
 743                         i ? " " : "", cabc_modes[i],
 744                         i == ARRAY_SIZE(cabc_modes) - 1 ? "\n" : "");
 745
 746         return len < PAGE_SIZE ? len : PAGE_SIZE - 1;
 747 }
 748
 749 static ssize_t taal_store_esd_interval(struct device *dev,
 750                 struct device_attribute *attr,
 751                 const char *buf, size_t count)
 752 {
 753         struct omap_dss_device *dssdev = to_dss_device(dev);
 754         struct taal_data *td = dev_get_drvdata(&dssdev->dev);
 755
 756         unsigned long t;
 757         int r;
 758
 759         r = strict_strtoul(buf, 10, &t);
 760         if (r)
 761                 return r;
 762
 763         mutex_lock(&td->lock);
 764         taal_cancel_esd_work(dssdev);
 765         td->esd_interval = t;
 766         if (td->enabled)
 767                 taal_queue_esd_work(dssdev);
 768         mutex_unlock(&td->lock);
 769
 770         return count;
 771 }
 772
 773 static ssize_t taal_show_esd_interval(struct device *dev,
 774                 struct device_attribute *attr,
 775                 char *buf)
 776 {
 777         struct omap_dss_device *dssdev = to_dss_device(dev);
 778         struct taal_data *td = dev_get_drvdata(&dssdev->dev);
 779         unsigned t;
 780
 781         mutex_lock(&td->lock);
 782         t = td->esd_interval;
 783         mutex_unlock(&td->lock);
 784
 785         return snprintf(buf, PAGE_SIZE, "%u\n", t);
 786 }
 787
 788 static ssize_t taal_store_ulps(struct device *dev,
 789                 struct device_attribute *attr,
 790                 const char *buf, size_t count)
 791 {
 792         struct omap_dss_device *dssdev = to_dss_device(dev);
 793         struct taal_data *td = dev_get_drvdata(&dssdev->dev);
 794         unsigned long t;
 795         int r;
 796
 797         r = strict_strtoul(buf, 10, &t);
 798         if (r)
 799                 return r;
 800
 801         mutex_lock(&td->lock);
 802
 803         if (td->enabled) {
 804                 dsi_bus_lock(dssdev);
 805
 806                 if (t)
 807                         r = taal_enter_ulps(dssdev);
 808                 else
 809                         r = taal_wake_up(dssdev);
 810
 811                 dsi_bus_unlock(dssdev);
 812         }
 813
 814         mutex_unlock(&td->lock);
 815
 816         if (r)
 817                 return r;
 818
 819         return count;
 820 }
 821
 822 static ssize_t taal_show_ulps(struct device *dev,
 823                 struct device_attribute *attr,
 824                 char *buf)
 825 {
 826         struct omap_dss_device *dssdev = to_dss_device(dev);
 827         struct taal_data *td = dev_get_drvdata(&dssdev->dev);
 828         unsigned t;
 829
 830         mutex_lock(&td->lock);
 831         t = td->ulps_enabled;
 832         mutex_unlock(&td->lock);
 833
 834         return snprintf(buf, PAGE_SIZE, "%u\n", t);
 835 }
 836
 837 static ssize_t taal_store_ulps_timeout(struct device *dev,
 838                 struct device_attribute *attr,
 839                 const char *buf, size_t count)
 840 {
 841         struct omap_dss_device *dssdev = to_dss_device(dev);
 842         struct taal_data *td = dev_get_drvdata(&dssdev->dev);
 843         unsigned long t;
 844         int r;
 845
 846         r = strict_strtoul(buf, 10, &t);
 847         if (r)
 848                 return r;
 849
 850         mutex_lock(&td->lock);
 851         td->ulps_timeout = t;
 852
 853         if (td->enabled) {
 854                 /* taal_wake_up will restart the timer */
 855                 dsi_bus_lock(dssdev);
 856                 r = taal_wake_up(dssdev);
 857                 dsi_bus_unlock(dssdev);
 858         }
 859
 860         mutex_unlock(&td->lock);
 861
 862         if (r)
 863                 return r;
 864
 865         return count;
 866 }
 867
 868 static ssize_t taal_show_ulps_timeout(struct device *dev,
 869                 struct device_attribute *attr,
 870                 char *buf)
 871 {
 872         struct omap_dss_device *dssdev = to_dss_device(dev);
 873         struct taal_data *td = dev_get_drvdata(&dssdev->dev);
 874         unsigned t;
 875
 876         mutex_lock(&td->lock);
 877         t = td->ulps_timeout;
 878         mutex_unlock(&td->lock);
 879
 880         return snprintf(buf, PAGE_SIZE, "%u\n", t);
 881 }
 882
 883 static DEVICE_ATTR(num_dsi_errors, S_IRUGO, taal_num_errors_show, NULL);
 884 static DEVICE_ATTR(hw_revision, S_IRUGO, taal_hw_revision_show, NULL);
 885 static DEVICE_ATTR(cabc_mode, S_IRUGO | S_IWUSR,
 886                 show_cabc_mode, store_cabc_mode);
 887 static DEVICE_ATTR(cabc_available_modes, S_IRUGO,
 888                 show_cabc_available_modes, NULL);
 889 static DEVICE_ATTR(esd_interval, S_IRUGO | S_IWUSR,
 890                 taal_show_esd_interval, taal_store_esd_interval);
 891 static DEVICE_ATTR(ulps, S_IRUGO | S_IWUSR,
 892                 taal_show_ulps, taal_store_ulps);
 893 static DEVICE_ATTR(ulps_timeout, S_IRUGO | S_IWUSR,
 894                 taal_show_ulps_timeout, taal_store_ulps_timeout);
 895
 896 static struct attribute *taal_attrs[] = {
 897         &dev_attr_num_dsi_errors.attr,
 898         &dev_attr_hw_revision.attr,
 899         &dev_attr_cabc_mode.attr,
 900         &dev_attr_cabc_available_modes.attr,
 901         &dev_attr_esd_interval.attr,
 902         &dev_attr_ulps.attr,
 903         &dev_attr_ulps_timeout.attr,
 904         NULL,
 905 };
 906
 907 static struct attribute_group taal_attr_group = {
 908         .attrs = taal_attrs,
 909 };
 910
 911 static void taal_hw_reset(struct omap_dss_device *dssdev)
 912 {
 913         struct taal_data *td = dev_get_drvdata(&dssdev->dev);
 914         struct nokia_dsi_panel_data *panel_data = get_panel_data(dssdev);
 915
 916         if (panel_data->reset_gpio == -1)
 917                 return;
 918
 919         gpio_set_value(panel_data->reset_gpio, 1);
 920         if (td->panel_config->reset_sequence.high)
 921                 udelay(td->panel_config->reset_sequence.high);
 922         /* reset the panel */
 923         gpio_set_value(panel_data->reset_gpio, 0);
 924         /* assert reset */
 925         if (td->panel_config->reset_sequence.low)
 926                 udelay(td->panel_config->reset_sequence.low);
 927         gpio_set_value(panel_data->reset_gpio, 1);
 928         /* wait after releasing reset */
 929         if (td->panel_config->sleep.hw_reset)
 930                 msleep(td->panel_config->sleep.hw_reset);
 931 }
 932
 933 static int taal_probe(struct omap_dss_device *dssdev)
 934 {
 935         struct backlight_properties props;
 936         struct taal_data *td;
 937         struct backlight_device *bldev = NULL;
 938         struct nokia_dsi_panel_data *panel_data = get_panel_data(dssdev);
 939         struct panel_config *panel_config = NULL;
 940         int r, i;
 941
 942         dev_dbg(&dssdev->dev, "probe\n");
 943
 944         if (!panel_data || !panel_data->name) {
 945                 r = -EINVAL;
 946                 goto err;
 947         }
 948
 949         for (i = 0; i < ARRAY_SIZE(panel_configs); i++) {
 950                 if (strcmp(panel_data->name, panel_configs[i].name) == 0) {
 951                         panel_config = &panel_configs[i];
 952                         break;
 953                 }
 954         }
 955
 956         if (!panel_config) {
 957                 r = -EINVAL;
 958                 goto err;
 959         }
 960
 961         dssdev->panel.config = OMAP_DSS_LCD_TFT;
 962         dssdev->panel.timings = panel_config->timings;
 963         dssdev->panel.dsi_pix_fmt = OMAP_DSS_DSI_FMT_RGB888;
 964
 965         td = kzalloc(sizeof(*td), GFP_KERNEL);
 966         if (!td) {
 967                 r = -ENOMEM;
 968                 goto err;
 969         }
 970         td->dssdev = dssdev;
 971         td->panel_config = panel_config;
 972         td->esd_interval = panel_data->esd_interval;
 973         td->ulps_enabled = false;
 974         td->ulps_timeout = panel_data->ulps_timeout;
 975
 976         mutex_init(&td->lock);
 977
 978         atomic_set(&td->do_update, 0);
 979
 980         r = init_regulators(dssdev, panel_config->regulators,
 981                         panel_config->num_regulators);
 982         if (r)
 983                 goto err_reg;
 984
 985         td->workqueue = create_singlethread_workqueue("taal_esd");
 986         if (td->workqueue == NULL) {
 987                 dev_err(&dssdev->dev, "can't create ESD workqueue\n");
 988                 r = -ENOMEM;
 989                 goto err_wq;
 990         }
 991         INIT_DELAYED_WORK_DEFERRABLE(&td->esd_work, taal_esd_work);
 992         INIT_DELAYED_WORK(&td->ulps_work, taal_ulps_work);
 993
 994         dev_set_drvdata(&dssdev->dev, td);
 995
 996         if (gpio_is_valid(panel_data->reset_gpio)) {
 997                 r = gpio_request_one(panel_data->reset_gpio, GPIOF_OUT_INIT_LOW,
 998                                 "taal rst");
 999                 if (r) {
1000                         dev_err(&dssdev->dev, "failed to request reset gpio\n");
1001                         goto err_rst_gpio;
1002                 }
1003         }
1004
1005         taal_hw_reset(dssdev);
1006
1007         if (panel_data->use_dsi_backlight) {
1008                 memset(&props, 0, sizeof(struct backlight_properties));
1009                 props.max_brightness = 255;
1010
1011                 props.type = BACKLIGHT_RAW;
1012                 bldev = backlight_device_register(dev_name(&dssdev->dev),
1013                                 &dssdev->dev, dssdev, &taal_bl_ops, &props);
1014                 if (IS_ERR(bldev)) {
1015                         r = PTR_ERR(bldev);
1016                         goto err_bl;
1017                 }
1018
1019                 td->bldev = bldev;
1020
1021                 bldev->props.fb_blank = FB_BLANK_UNBLANK;
1022                 bldev->props.power = FB_BLANK_UNBLANK;
1023                 bldev->props.brightness = 255;
1024
1025                 taal_bl_update_status(bldev);
1026         }
1027
1028         if (panel_data->use_ext_te) {
1029                 int gpio = panel_data->ext_te_gpio;
1030
1031                 r = gpio_request_one(gpio, GPIOF_IN, "taal irq");
1032                 if (r) {
1033                         dev_err(&dssdev->dev, "GPIO request failed\n");
1034                         goto err_gpio;
1035                 }
1036
1037                 r = request_irq(gpio_to_irq(gpio), taal_te_isr,
1038                                 IRQF_TRIGGER_RISING,
1039                                 "taal vsync", dssdev);
1040
1041                 if (r) {
1042                         dev_err(&dssdev->dev, "IRQ request failed\n");
1043                         gpio_free(gpio);
1044                         goto err_irq;
1045                 }
1046
1047                 INIT_DELAYED_WORK_DEFERRABLE(&td->te_timeout_work,
1048                                         taal_te_timeout_work_callback);
1049
1050                 dev_dbg(&dssdev->dev, "Using GPIO TE\n");
1051         }
1052
1053         r = omap_dsi_request_vc(dssdev, &td->channel);
1054         if (r) {
1055                 dev_err(&dssdev->dev, "failed to get virtual channel\n");
1056                 goto err_req_vc;
1057         }
1058
1059         r = omap_dsi_set_vc_id(dssdev, td->channel, TCH);
1060         if (r) {
1061                 dev_err(&dssdev->dev, "failed to set VC_ID\n");
1062                 goto err_vc_id;
1063         }
1064
1065         r = sysfs_create_group(&dssdev->dev.kobj, &taal_attr_group);
1066         if (r) {
1067                 dev_err(&dssdev->dev, "failed to create sysfs files\n");
1068                 goto err_vc_id;
1069         }
1070
1071         return 0;
1072
1073 err_vc_id:
1074         omap_dsi_release_vc(dssdev, td->channel);
1075 err_req_vc:
1076         if (panel_data->use_ext_te)
1077                 free_irq(gpio_to_irq(panel_data->ext_te_gpio), dssdev);
1078 err_irq:
1079         if (panel_data->use_ext_te)
1080                 gpio_free(panel_data->ext_te_gpio);
1081 err_gpio:
1082         if (bldev != NULL)
1083                 backlight_device_unregister(bldev);
1084 err_bl:
1085         if (gpio_is_valid(panel_data->reset_gpio))
1086                 gpio_free(panel_data->reset_gpio);
1087 err_rst_gpio:
1088         destroy_workqueue(td->workqueue);
1089 err_wq:
1090         free_regulators(panel_config->regulators, panel_config->num_regulators);
1091 err_reg:
1092         kfree(td);
1093 err:
1094         return r;
1095 }
1096
1097 static void __exit taal_remove(struct omap_dss_device *dssdev)
1098 {
1099         struct taal_data *td = dev_get_drvdata(&dssdev->dev);
1100         struct nokia_dsi_panel_data *panel_data = get_panel_data(dssdev);
1101         struct backlight_device *bldev;
1102
1103         dev_dbg(&dssdev->dev, "remove\n");
1104
1105         sysfs_remove_group(&dssdev->dev.kobj, &taal_attr_group);
1106         omap_dsi_release_vc(dssdev, td->channel);
1107
1108         if (panel_data->use_ext_te) {
1109                 int gpio = panel_data->ext_te_gpio;
1110                 free_irq(gpio_to_irq(gpio), dssdev);
1111                 gpio_free(gpio);
1112         }
1113
1114         bldev = td->bldev;
1115         if (bldev != NULL) {
1116                 bldev->props.power = FB_BLANK_POWERDOWN;
1117                 taal_bl_update_status(bldev);
1118                 backlight_device_unregister(bldev);
1119         }
1120
1121         taal_cancel_ulps_work(dssdev);
1122         taal_cancel_esd_work(dssdev);
1123         destroy_workqueue(td->workqueue);
1124
1125         /* reset, to be sure that the panel is in a valid state */
1126         taal_hw_reset(dssdev);
1127
1128         free_regulators(td->panel_config->regulators,
1129                         td->panel_config->num_regulators);
1130
1131         if (gpio_is_valid(panel_data->reset_gpio))
1132                 gpio_free(panel_data->reset_gpio);
1133
1134         kfree(td);
1135 }
1136
1137 static int taal_power_on(struct omap_dss_device *dssdev)
1138 {
1139         struct taal_data *td = dev_get_drvdata(&dssdev->dev);
1140         struct nokia_dsi_panel_data *panel_data = get_panel_data(dssdev);
1141         u8 id1, id2, id3;
1142         int r;
1143
1144         r = omapdss_dsi_configure_pins(dssdev, &panel_data->pin_config);
1145         if (r) {
1146                 dev_err(&dssdev->dev, "failed to configure DSI pins\n");
1147                 goto err0;
1148         };
1149
1150         r = omapdss_dsi_display_enable(dssdev);
1151         if (r) {
1152                 dev_err(&dssdev->dev, "failed to enable DSI\n");
1153                 goto err0;
1154         }
1155
1156         taal_hw_reset(dssdev);
1157
1158         omapdss_dsi_vc_enable_hs(dssdev, td->channel, false);
1159
1160         r = taal_sleep_out(td);
1161         if (r)
1162                 goto err;
1163
1164         r = taal_get_id(td, &id1, &id2, &id3);
1165         if (r)
1166                 goto err;
1167
1168         /* on early Taal revisions CABC is broken */
1169         if (td->panel_config->type == PANEL_TAAL &&
1170                 (id2 == 0x00 || id2 == 0xff || id2 == 0x81))
1171                 td->cabc_broken = true;
1172
1173         r = taal_dcs_write_1(td, DCS_BRIGHTNESS, 0xff);
1174         if (r)
1175                 goto err;
1176
1177         r = taal_dcs_write_1(td, DCS_CTRL_DISPLAY,
1178                         (1<<2) | (1<<5));       /* BL | BCTRL */
1179         if (r)
1180                 goto err;
1181
1182         r = taal_dcs_write_1(td, MIPI_DCS_SET_PIXEL_FORMAT,
1183                 MIPI_DCS_PIXEL_FMT_24BIT);
1184         if (r)
1185                 goto err;
1186
1187         r = taal_set_addr_mode(td, td->rotate, td->mirror);
1188         if (r)
1189                 goto err;
1190
1191         if (!td->cabc_broken) {
1192                 r = taal_dcs_write_1(td, DCS_WRITE_CABC, td->cabc_mode);
1193                 if (r)
1194                         goto err;
1195         }
1196
1197         r = taal_dcs_write_0(td, MIPI_DCS_SET_DISPLAY_ON);
1198         if (r)
1199                 goto err;
1200
1201         r = _taal_enable_te(dssdev, td->te_enabled);
1202         if (r)
1203                 goto err;
1204
1205         r = dsi_enable_video_output(dssdev, td->channel);
1206         if (r)
1207                 goto err;
1208
1209         td->enabled = 1;
1210
1211         if (!td->intro_printed) {
1212                 dev_info(&dssdev->dev, "%s panel revision %02x.%02x.%02x\n",
1213                         td->panel_config->name, id1, id2, id3);
1214                 if (td->cabc_broken)
1215                         dev_info(&dssdev->dev,
1216                                         "old Taal version, CABC disabled\n");
1217                 td->intro_printed = true;
1218         }
1219
1220         omapdss_dsi_vc_enable_hs(dssdev, td->channel, true);
1221
1222         return 0;
1223 err:
1224         dev_err(&dssdev->dev, "error while enabling panel, issuing HW reset\n");
1225
1226         taal_hw_reset(dssdev);
1227
1228         omapdss_dsi_display_disable(dssdev, true, false);
1229 err0:
1230         return r;
1231 }
1232
1233 static void taal_power_off(struct omap_dss_device *dssdev)
1234 {
1235         struct taal_data *td = dev_get_drvdata(&dssdev->dev);
1236         int r;
1237
1238         dsi_disable_video_output(dssdev, td->channel);
1239
1240         r = taal_dcs_write_0(td, MIPI_DCS_SET_DISPLAY_OFF);
1241         if (!r)
1242                 r = taal_sleep_in(td);
1243
1244         if (r) {
1245                 dev_err(&dssdev->dev,
1246                                 "error disabling panel, issuing HW reset\n");
1247                 taal_hw_reset(dssdev);
1248         }
1249
1250         omapdss_dsi_display_disable(dssdev, true, false);
1251
1252         td->enabled = 0;
1253 }
1254
1255 static int taal_panel_reset(struct omap_dss_device *dssdev)
1256 {
1257         dev_err(&dssdev->dev, "performing LCD reset\n");
1258
1259         taal_power_off(dssdev);
1260         taal_hw_reset(dssdev);
1261         return taal_power_on(dssdev);
1262 }
1263
1264 static int taal_enable(struct omap_dss_device *dssdev)
1265 {
1266         struct taal_data *td = dev_get_drvdata(&dssdev->dev);
1267         int r;
1268
1269         dev_dbg(&dssdev->dev, "enable\n");
1270
1271         mutex_lock(&td->lock);
1272
1273         if (dssdev->state != OMAP_DSS_DISPLAY_DISABLED) {
1274                 r = -EINVAL;
1275                 goto err;
1276         }
1277
1278         dsi_bus_lock(dssdev);
1279
1280         r = taal_power_on(dssdev);
1281
1282         dsi_bus_unlock(dssdev);
1283
1284         if (r)
1285                 goto err;
1286
1287         taal_queue_esd_work(dssdev);
1288
1289         dssdev->state = OMAP_DSS_DISPLAY_ACTIVE;
1290
1291         mutex_unlock(&td->lock);
1292
1293         return 0;
1294 err:
1295         dev_dbg(&dssdev->dev, "enable failed\n");
1296         mutex_unlock(&td->lock);
1297         return r;
1298 }
1299
1300 static void taal_disable(struct omap_dss_device *dssdev)
1301 {
1302         struct taal_data *td = dev_get_drvdata(&dssdev->dev);
1303
1304         dev_dbg(&dssdev->dev, "disable\n");
1305
1306         mutex_lock(&td->lock);
1307
1308         taal_cancel_ulps_work(dssdev);
1309         taal_cancel_esd_work(dssdev);
1310
1311         dsi_bus_lock(dssdev);
1312
1313         if (dssdev->state == OMAP_DSS_DISPLAY_ACTIVE) {
1314                 int r;
1315
1316                 r = taal_wake_up(dssdev);
1317                 if (!r)
1318                         taal_power_off(dssdev);
1319         }
1320
1321         dsi_bus_unlock(dssdev);
1322
1323         dssdev->state = OMAP_DSS_DISPLAY_DISABLED;
1324
1325         mutex_unlock(&td->lock);
1326 }
1327
1328 static int taal_suspend(struct omap_dss_device *dssdev)
1329 {
1330         struct taal_data *td = dev_get_drvdata(&dssdev->dev);
1331         int r;
1332
1333         dev_dbg(&dssdev->dev, "suspend\n");
1334
1335         mutex_lock(&td->lock);
1336
1337         if (dssdev->state != OMAP_DSS_DISPLAY_ACTIVE) {
1338                 r = -EINVAL;
1339                 goto err;
1340         }
1341
1342         taal_cancel_ulps_work(dssdev);
1343         taal_cancel_esd_work(dssdev);
1344
1345         dsi_bus_lock(dssdev);
1346
1347         r = taal_wake_up(dssdev);
1348         if (!r)
1349                 taal_power_off(dssdev);
1350
1351         dsi_bus_unlock(dssdev);
1352
1353         dssdev->state = OMAP_DSS_DISPLAY_SUSPENDED;
1354
1355         mutex_unlock(&td->lock);
1356
1357         return 0;
1358 err:
1359         mutex_unlock(&td->lock);
1360         return r;
1361 }
1362
1363 static int taal_resume(struct omap_dss_device *dssdev)
1364 {
1365         struct taal_data *td = dev_get_drvdata(&dssdev->dev);
1366         int r;
1367
1368         dev_dbg(&dssdev->dev, "resume\n");
1369
1370         mutex_lock(&td->lock);
1371
1372         if (dssdev->state != OMAP_DSS_DISPLAY_SUSPENDED) {
1373                 r = -EINVAL;
1374                 goto err;
1375         }
1376
1377         dsi_bus_lock(dssdev);
1378
1379         r = taal_power_on(dssdev);
1380
1381         dsi_bus_unlock(dssdev);
1382
1383         if (r) {
1384                 dssdev->state = OMAP_DSS_DISPLAY_DISABLED;
1385         } else {
1386                 dssdev->state = OMAP_DSS_DISPLAY_ACTIVE;
1387                 taal_queue_esd_work(dssdev);
1388         }
1389
1390         mutex_unlock(&td->lock);
1391
1392         return r;
1393 err:
1394         mutex_unlock(&td->lock);
1395         return r;
1396 }
1397
1398 static void taal_framedone_cb(int err, void *data)
1399 {
1400         struct omap_dss_device *dssdev = data;
1401         dev_dbg(&dssdev->dev, "framedone, err %d\n", err);
1402         dsi_bus_unlock(dssdev);
1403 }
1404
1405 static irqreturn_t taal_te_isr(int irq, void *data)
1406 {
1407         struct omap_dss_device *dssdev = data;
1408         struct taal_data *td = dev_get_drvdata(&dssdev->dev);
1409         int old;
1410         int r;
1411
1412         old = atomic_cmpxchg(&td->do_update, 1, 0);
1413
1414         if (old) {
1415                 cancel_delayed_work(&td->te_timeout_work);
1416
1417                 r = omap_dsi_update(dssdev, td->channel, taal_framedone_cb,
1418                                 dssdev);
1419                 if (r)
1420                         goto err;
1421         }
1422
1423         return IRQ_HANDLED;
1424 err:
1425         dev_err(&dssdev->dev, "start update failed\n");
1426         dsi_bus_unlock(dssdev);
1427         return IRQ_HANDLED;
1428 }
1429
1430 static void taal_te_timeout_work_callback(struct work_struct *work)
1431 {
1432         struct taal_data *td = container_of(work, struct taal_data,
1433                                         te_timeout_work.work);
1434         struct omap_dss_device *dssdev = td->dssdev;
1435
1436         dev_err(&dssdev->dev, "TE not received for 250ms!\n");
1437
1438         atomic_set(&td->do_update, 0);
1439         dsi_bus_unlock(dssdev);
1440 }
1441
1442 static int taal_update(struct omap_dss_device *dssdev,
1443                                     u16 x, u16 y, u16 w, u16 h)
1444 {
1445         struct taal_data *td = dev_get_drvdata(&dssdev->dev);
1446         struct nokia_dsi_panel_data *panel_data = get_panel_data(dssdev);
1447         int r;
1448
1449         dev_dbg(&dssdev->dev, "update %d, %d, %d x %d\n", x, y, w, h);
1450
1451         mutex_lock(&td->lock);
1452         dsi_bus_lock(dssdev);
1453
1454         r = taal_wake_up(dssdev);
1455         if (r)
1456                 goto err;
1457
1458         if (!td->enabled) {
1459                 r = 0;
1460                 goto err;
1461         }
1462
1463         /* XXX no need to send this every frame, but dsi break if not done */
1464         r = taal_set_update_window(td, 0, 0,
1465                         td->panel_config->timings.x_res,
1466                         td->panel_config->timings.y_res);
1467         if (r)
1468                 goto err;
1469
1470         if (td->te_enabled && panel_data->use_ext_te) {
1471                 schedule_delayed_work(&td->te_timeout_work,
1472                                 msecs_to_jiffies(250));
1473                 atomic_set(&td->do_update, 1);
1474         } else {
1475                 r = omap_dsi_update(dssdev, td->channel, taal_framedone_cb,
1476                                 dssdev);
1477                 if (r)
1478                         goto err;
1479         }
1480
1481         /* note: no bus_unlock here. unlock is in framedone_cb */
1482         mutex_unlock(&td->lock);
1483         return 0;
1484 err:
1485         dsi_bus_unlock(dssdev);
1486         mutex_unlock(&td->lock);
1487         return r;
1488 }
1489
1490 static int taal_sync(struct omap_dss_device *dssdev)
1491 {
1492         struct taal_data *td = dev_get_drvdata(&dssdev->dev);
1493
1494         dev_dbg(&dssdev->dev, "sync\n");
1495
1496         mutex_lock(&td->lock);
1497         dsi_bus_lock(dssdev);
1498         dsi_bus_unlock(dssdev);
1499         mutex_unlock(&td->lock);
1500
1501         dev_dbg(&dssdev->dev, "sync done\n");
1502
1503         return 0;
1504 }
1505
1506 static int _taal_enable_te(struct omap_dss_device *dssdev, bool enable)
1507 {
1508         struct taal_data *td = dev_get_drvdata(&dssdev->dev);
1509         struct nokia_dsi_panel_data *panel_data = get_panel_data(dssdev);
1510         int r;
1511
1512         if (enable)
1513                 r = taal_dcs_write_1(td, MIPI_DCS_SET_TEAR_ON, 0);
1514         else
1515                 r = taal_dcs_write_0(td, MIPI_DCS_SET_TEAR_OFF);
1516
1517         if (!panel_data->use_ext_te)
1518                 omapdss_dsi_enable_te(dssdev, enable);
1519
1520         if (td->panel_config->sleep.enable_te)
1521                 msleep(td->panel_config->sleep.enable_te);
1522
1523         return r;
1524 }
1525
1526 static int taal_enable_te(struct omap_dss_device *dssdev, bool enable)
1527 {
1528         struct taal_data *td = dev_get_drvdata(&dssdev->dev);
1529         int r;
1530
1531         mutex_lock(&td->lock);
1532
1533         if (td->te_enabled == enable)
1534                 goto end;
1535
1536         dsi_bus_lock(dssdev);
1537
1538         if (td->enabled) {
1539                 r = taal_wake_up(dssdev);
1540                 if (r)
1541                         goto err;
1542
1543                 r = _taal_enable_te(dssdev, enable);
1544                 if (r)
1545                         goto err;
1546         }
1547
1548         td->te_enabled = enable;
1549
1550         dsi_bus_unlock(dssdev);
1551 end:
1552         mutex_unlock(&td->lock);
1553
1554         return 0;
1555 err:
1556         dsi_bus_unlock(dssdev);
1557         mutex_unlock(&td->lock);
1558
1559         return r;
1560 }
1561
1562 static int taal_get_te(struct omap_dss_device *dssdev)
1563 {
1564         struct taal_data *td = dev_get_drvdata(&dssdev->dev);
1565         int r;
1566
1567         mutex_lock(&td->lock);
1568         r = td->te_enabled;
1569         mutex_unlock(&td->lock);
1570
1571         return r;
1572 }
1573
1574 static int taal_rotate(struct omap_dss_device *dssdev, u8 rotate)
1575 {
1576         struct taal_data *td = dev_get_drvdata(&dssdev->dev);
1577         int r;
1578
1579         dev_dbg(&dssdev->dev, "rotate %d\n", rotate);
1580
1581         mutex_lock(&td->lock);
1582
1583         if (td->rotate == rotate)
1584                 goto end;
1585
1586         dsi_bus_lock(dssdev);
1587
1588         if (td->enabled) {
1589                 r = taal_wake_up(dssdev);
1590                 if (r)
1591                         goto err;
1592
1593                 r = taal_set_addr_mode(td, rotate, td->mirror);
1594                 if (r)
1595                         goto err;
1596         }
1597
1598         td->rotate = rotate;
1599
1600         dsi_bus_unlock(dssdev);
1601 end:
1602         mutex_unlock(&td->lock);
1603         return 0;
1604 err:
1605         dsi_bus_unlock(dssdev);
1606         mutex_unlock(&td->lock);
1607         return r;
1608 }
1609
1610 static u8 taal_get_rotate(struct omap_dss_device *dssdev)
1611 {
1612         struct taal_data *td = dev_get_drvdata(&dssdev->dev);
1613         int r;
1614
1615         mutex_lock(&td->lock);
1616         r = td->rotate;
1617         mutex_unlock(&td->lock);
1618
1619         return r;
1620 }
1621
1622 static int taal_mirror(struct omap_dss_device *dssdev, bool enable)
1623 {
1624         struct taal_data *td = dev_get_drvdata(&dssdev->dev);
1625         int r;
1626
1627         dev_dbg(&dssdev->dev, "mirror %d\n", enable);
1628
1629         mutex_lock(&td->lock);
1630
1631         if (td->mirror == enable)
1632                 goto end;
1633
1634         dsi_bus_lock(dssdev);
1635         if (td->enabled) {
1636                 r = taal_wake_up(dssdev);
1637                 if (r)
1638                         goto err;
1639
1640                 r = taal_set_addr_mode(td, td->rotate, enable);
1641                 if (r)
1642                         goto err;
1643         }
1644
1645         td->mirror = enable;
1646
1647         dsi_bus_unlock(dssdev);
1648 end:
1649         mutex_unlock(&td->lock);
1650         return 0;
1651 err:
1652         dsi_bus_unlock(dssdev);
1653         mutex_unlock(&td->lock);
1654         return r;
1655 }
1656
1657 static bool taal_get_mirror(struct omap_dss_device *dssdev)
1658 {
1659         struct taal_data *td = dev_get_drvdata(&dssdev->dev);
1660         int r;
1661
1662         mutex_lock(&td->lock);
1663         r = td->mirror;
1664         mutex_unlock(&td->lock);
1665
1666         return r;
1667 }
1668
1669 static int taal_run_test(struct omap_dss_device *dssdev, int test_num)
1670 {
1671         struct taal_data *td = dev_get_drvdata(&dssdev->dev);
1672         u8 id1, id2, id3;
1673         int r;
1674
1675         mutex_lock(&td->lock);
1676
1677         if (!td->enabled) {
1678                 r = -ENODEV;
1679                 goto err1;
1680         }
1681
1682         dsi_bus_lock(dssdev);
1683
1684         r = taal_wake_up(dssdev);
1685         if (r)
1686                 goto err2;
1687
1688         r = taal_dcs_read_1(td, DCS_GET_ID1, &id1);
1689         if (r)
1690                 goto err2;
1691         r = taal_dcs_read_1(td, DCS_GET_ID2, &id2);
1692         if (r)
1693                 goto err2;
1694         r = taal_dcs_read_1(td, DCS_GET_ID3, &id3);
1695         if (r)
1696                 goto err2;
1697
1698         dsi_bus_unlock(dssdev);
1699         mutex_unlock(&td->lock);
1700         return 0;
1701 err2:
1702         dsi_bus_unlock(dssdev);
1703 err1:
1704         mutex_unlock(&td->lock);
1705         return r;
1706 }
1707
1708 static int taal_memory_read(struct omap_dss_device *dssdev,
1709                 void *buf, size_t size,
1710                 u16 x, u16 y, u16 w, u16 h)
1711 {
1712         int r;
1713         int first = 1;
1714         int plen;
1715         unsigned buf_used = 0;
1716         struct taal_data *td = dev_get_drvdata(&dssdev->dev);
1717
1718         if (size < w * h * 3)
1719                 return -ENOMEM;
1720
1721         mutex_lock(&td->lock);
1722
1723         if (!td->enabled) {
1724                 r = -ENODEV;
1725                 goto err1;
1726         }
1727
1728         size = min(w * h * 3,
1729                         dssdev->panel.timings.x_res *
1730                         dssdev->panel.timings.y_res * 3);
1731
1732         dsi_bus_lock(dssdev);
1733
1734         r = taal_wake_up(dssdev);
1735         if (r)
1736                 goto err2;
1737
1738         /* plen 1 or 2 goes into short packet. until checksum error is fixed,
1739          * use short packets. plen 32 works, but bigger packets seem to cause
1740          * an error. */
1741         if (size % 2)
1742                 plen = 1;
1743         else
1744                 plen = 2;
1745
1746         taal_set_update_window(td, x, y, w, h);
1747
1748         r = dsi_vc_set_max_rx_packet_size(dssdev, td->channel, plen);
1749         if (r)
1750                 goto err2;
1751
1752         while (buf_used < size) {
1753                 u8 dcs_cmd = first ? 0x2e : 0x3e;
1754                 first = 0;
1755
1756                 r = dsi_vc_dcs_read(dssdev, td->channel, dcs_cmd,
1757                                 buf + buf_used, size - buf_used);
1758
1759                 if (r < 0) {
1760                         dev_err(&dssdev->dev, "read error\n");
1761                         goto err3;
1762                 }
1763
1764                 buf_used += r;
1765
1766                 if (r < plen) {
1767                         dev_err(&dssdev->dev, "short read\n");
1768                         break;
1769                 }
1770
1771                 if (signal_pending(current)) {
1772                         dev_err(&dssdev->dev, "signal pending, "
1773                                         "aborting memory read\n");
1774                         r = -ERESTARTSYS;
1775                         goto err3;
1776                 }
1777         }
1778
1779         r = buf_used;
1780
1781 err3:
1782         dsi_vc_set_max_rx_packet_size(dssdev, td->channel, 1);
1783 err2:
1784         dsi_bus_unlock(dssdev);
1785 err1:
1786         mutex_unlock(&td->lock);
1787         return r;
1788 }
1789
1790 static void taal_ulps_work(struct work_struct *work)
1791 {
1792         struct taal_data *td = container_of(work, struct taal_data,
1793                         ulps_work.work);
1794         struct omap_dss_device *dssdev = td->dssdev;
1795
1796         mutex_lock(&td->lock);
1797
1798         if (dssdev->state != OMAP_DSS_DISPLAY_ACTIVE || !td->enabled) {
1799                 mutex_unlock(&td->lock);
1800                 return;
1801         }
1802
1803         dsi_bus_lock(dssdev);
1804
1805         taal_enter_ulps(dssdev);
1806
1807         dsi_bus_unlock(dssdev);
1808         mutex_unlock(&td->lock);
1809 }
1810
1811 static void taal_esd_work(struct work_struct *work)
1812 {
1813         struct taal_data *td = container_of(work, struct taal_data,
1814                         esd_work.work);
1815         struct omap_dss_device *dssdev = td->dssdev;
1816         struct nokia_dsi_panel_data *panel_data = get_panel_data(dssdev);
1817         u8 state1, state2;
1818         int r;
1819
1820         mutex_lock(&td->lock);
1821
1822         if (!td->enabled) {
1823                 mutex_unlock(&td->lock);
1824                 return;
1825         }
1826
1827         dsi_bus_lock(dssdev);
1828
1829         r = taal_wake_up(dssdev);
1830         if (r) {
1831                 dev_err(&dssdev->dev, "failed to exit ULPS\n");
1832                 goto err;
1833         }
1834
1835         r = taal_dcs_read_1(td, MIPI_DCS_GET_DIAGNOSTIC_RESULT, &state1);
1836         if (r) {
1837                 dev_err(&dssdev->dev, "failed to read Taal status\n");
1838                 goto err;
1839         }
1840
1841         /* Run self diagnostics */
1842         r = taal_sleep_out(td);
1843         if (r) {
1844                 dev_err(&dssdev->dev, "failed to run Taal self-diagnostics\n");
1845                 goto err;
1846         }
1847
1848         r = taal_dcs_read_1(td, MIPI_DCS_GET_DIAGNOSTIC_RESULT, &state2);
1849         if (r) {
1850                 dev_err(&dssdev->dev, "failed to read Taal status\n");
1851                 goto err;
1852         }
1853
1854         /* Each sleep out command will trigger a self diagnostic and flip
1855          * Bit6 if the test passes.
1856          */
1857         if (!((state1 ^ state2) & (1 << 6))) {
1858                 dev_err(&dssdev->dev, "LCD self diagnostics failed\n");
1859                 goto err;
1860         }
1861         /* Self-diagnostics result is also shown on TE GPIO line. We need
1862          * to re-enable TE after self diagnostics */
1863         if (td->te_enabled && panel_data->use_ext_te) {
1864                 r = taal_dcs_write_1(td, MIPI_DCS_SET_TEAR_ON, 0);
1865                 if (r)
1866                         goto err;
1867         }
1868
1869         dsi_bus_unlock(dssdev);
1870
1871         taal_queue_esd_work(dssdev);
1872
1873         mutex_unlock(&td->lock);
1874         return;
1875 err:
1876         dev_err(&dssdev->dev, "performing LCD reset\n");
1877
1878         taal_panel_reset(dssdev);
1879
1880         dsi_bus_unlock(dssdev);
1881
1882         taal_queue_esd_work(dssdev);
1883
1884         mutex_unlock(&td->lock);
1885 }
1886
1887 static struct omap_dss_driver taal_driver = {
1888         .probe          = taal_probe,
1889         .remove         = __exit_p(taal_remove),
1890
1891         .enable         = taal_enable,
1892         .disable        = taal_disable,
1893         .suspend        = taal_suspend,
1894         .resume         = taal_resume,
1895
1896         .update         = taal_update,
1897         .sync           = taal_sync,
1898
1899         .get_resolution = taal_get_resolution,
1900         .get_recommended_bpp = omapdss_default_get_recommended_bpp,
1901
1902         .enable_te      = taal_enable_te,
1903         .get_te         = taal_get_te,
1904
1905         .set_rotate     = taal_rotate,
1906         .get_rotate     = taal_get_rotate,
1907         .set_mirror     = taal_mirror,
1908         .get_mirror     = taal_get_mirror,
1909         .run_test       = taal_run_test,
1910         .memory_read    = taal_memory_read,
1911
1912         .get_timings    = taal_get_timings,
1913
1914         .driver         = {
1915                 .name   = "taal",
1916                 .owner  = THIS_MODULE,
1917         },
1918 };
1919
1920 static int __init taal_init(void)
1921 {
1922         omap_dss_register_driver(&taal_driver);
1923
1924         return 0;
1925 }
1926
1927 static void __exit taal_exit(void)
1928 {
1929         omap_dss_unregister_driver(&taal_driver);
1930 }
1931
1932 module_init(taal_init);
1933 module_exit(taal_exit);
1934
1935 MODULE_AUTHOR("Tomi Valkeinen <tomi.valkeinen@nokia.com>");
1936 MODULE_DESCRIPTION("Taal Driver");
1937 MODULE_LICENSE("GPL");