drivers/video/fbdev/omap2/omapfb/displays/panel-dsi-cm.c

   1 /*
   2  * Generic DSI Command Mode panel driver
   3  *
   4  * Copyright (C) 2013 Texas Instruments
   5  * Author: Tomi Valkeinen <tomi.valkeinen@ti.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
  12 /* #define DEBUG */
  13
  14 #include <linux/backlight.h>
  15 #include <linux/delay.h>
  16 #include <linux/fb.h>
  17 #include <linux/gpio.h>
  18 #include <linux/interrupt.h>
  19 #include <linux/jiffies.h>
  20 #include <linux/module.h>
  21 #include <linux/platform_device.h>
  22 #include <linux/sched/signal.h>
  23 #include <linux/slab.h>
  24 #include <linux/workqueue.h>
  25 #include <linux/of_device.h>
  26 #include <linux/of_gpio.h>
  27
  28 #include <video/omapfb_dss.h>
  29 #include <video/mipi_display.h>
  30
  31 /* DSI Virtual channel. Hardcoded for now. */
  32 #define TCH 0
  33
  34 #define DCS_READ_NUM_ERRORS     0x05
  35 #define DCS_BRIGHTNESS          0x51
  36 #define DCS_CTRL_DISPLAY        0x53
  37 #define DCS_GET_ID1             0xda
  38 #define DCS_GET_ID2             0xdb
  39 #define DCS_GET_ID3             0xdc
  40
  41 struct panel_drv_data {
  42         struct omap_dss_device dssdev;
  43         struct omap_dss_device *in;
  44
  45         struct omap_video_timings timings;
  46
  47         struct platform_device *pdev;
  48
  49         struct mutex lock;
  50
  51         struct backlight_device *bldev;
  52
  53         unsigned long   hw_guard_end;   /* next value of jiffies when we can
  54                                          * issue the next sleep in/out command
  55                                          */
  56         unsigned long   hw_guard_wait;  /* max guard time in jiffies */
  57
  58         /* panel HW configuration from DT or platform data */
  59         int reset_gpio;
  60         int ext_te_gpio;
  61
  62         bool use_dsi_backlight;
  63
  64         struct omap_dsi_pin_config pin_config;
  65
  66         /* runtime variables */
  67         bool enabled;
  68
  69         bool te_enabled;
  70
  71         atomic_t do_update;
  72         int channel;
  73
  74         struct delayed_work te_timeout_work;
  75
  76         bool intro_printed;
  77
  78         bool ulps_enabled;
  79         unsigned ulps_timeout;
  80         struct delayed_work ulps_work;
  81 };
  82
  83 #define to_panel_data(p) container_of(p, struct panel_drv_data, dssdev)
  84
  85 static irqreturn_t dsicm_te_isr(int irq, void *data);
  86 static void dsicm_te_timeout_work_callback(struct work_struct *work);
  87 static int _dsicm_enable_te(struct panel_drv_data *ddata, bool enable);
  88
  89 static int dsicm_panel_reset(struct panel_drv_data *ddata);
  90
  91 static void dsicm_ulps_work(struct work_struct *work);
  92
  93 static void hw_guard_start(struct panel_drv_data *ddata, int guard_msec)
  94 {
  95         ddata->hw_guard_wait = msecs_to_jiffies(guard_msec);
  96         ddata->hw_guard_end = jiffies + ddata->hw_guard_wait;
  97 }
  98
  99 static void hw_guard_wait(struct panel_drv_data *ddata)
 100 {
 101         unsigned long wait = ddata->hw_guard_end - jiffies;
 102
 103         if ((long)wait > 0 && time_before_eq(wait, ddata->hw_guard_wait)) {
 104                 set_current_state(TASK_UNINTERRUPTIBLE);
 105                 schedule_timeout(wait);
 106         }
 107 }
 108
 109 static int dsicm_dcs_read_1(struct panel_drv_data *ddata, u8 dcs_cmd, u8 *data)
 110 {
 111         struct omap_dss_device *in = ddata->in;
 112         int r;
 113         u8 buf[1];
 114
 115         r = in->ops.dsi->dcs_read(in, ddata->channel, dcs_cmd, buf, 1);
 116
 117         if (r < 0)
 118                 return r;
 119
 120         *data = buf[0];
 121
 122         return 0;
 123 }
 124
 125 static int dsicm_dcs_write_0(struct panel_drv_data *ddata, u8 dcs_cmd)
 126 {
 127         struct omap_dss_device *in = ddata->in;
 128         return in->ops.dsi->dcs_write(in, ddata->channel, &dcs_cmd, 1);
 129 }
 130
 131 static int dsicm_dcs_write_1(struct panel_drv_data *ddata, u8 dcs_cmd, u8 param)
 132 {
 133         struct omap_dss_device *in = ddata->in;
 134         u8 buf[2] = { dcs_cmd, param };
 135
 136         return in->ops.dsi->dcs_write(in, ddata->channel, buf, 2);
 137 }
 138
 139 static int dsicm_sleep_in(struct panel_drv_data *ddata)
 140
 141 {
 142         struct omap_dss_device *in = ddata->in;
 143         u8 cmd;
 144         int r;
 145
 146         hw_guard_wait(ddata);
 147
 148         cmd = MIPI_DCS_ENTER_SLEEP_MODE;
 149         r = in->ops.dsi->dcs_write_nosync(in, ddata->channel, &cmd, 1);
 150         if (r)
 151                 return r;
 152
 153         hw_guard_start(ddata, 120);
 154
 155         usleep_range(5000, 10000);
 156
 157         return 0;
 158 }
 159
 160 static int dsicm_sleep_out(struct panel_drv_data *ddata)
 161 {
 162         int r;
 163
 164         hw_guard_wait(ddata);
 165
 166         r = dsicm_dcs_write_0(ddata, MIPI_DCS_EXIT_SLEEP_MODE);
 167         if (r)
 168                 return r;
 169
 170         hw_guard_start(ddata, 120);
 171
 172         usleep_range(5000, 10000);
 173
 174         return 0;
 175 }
 176
 177 static int dsicm_get_id(struct panel_drv_data *ddata, u8 *id1, u8 *id2, u8 *id3)
 178 {
 179         int r;
 180
 181         r = dsicm_dcs_read_1(ddata, DCS_GET_ID1, id1);
 182         if (r)
 183                 return r;
 184         r = dsicm_dcs_read_1(ddata, DCS_GET_ID2, id2);
 185         if (r)
 186                 return r;
 187         r = dsicm_dcs_read_1(ddata, DCS_GET_ID3, id3);
 188         if (r)
 189                 return r;
 190
 191         return 0;
 192 }
 193
 194 static int dsicm_set_update_window(struct panel_drv_data *ddata,
 195                 u16 x, u16 y, u16 w, u16 h)
 196 {
 197         struct omap_dss_device *in = ddata->in;
 198         int r;
 199         u16 x1 = x;
 200         u16 x2 = x + w - 1;
 201         u16 y1 = y;
 202         u16 y2 = y + h - 1;
 203
 204         u8 buf[5];
 205         buf[0] = MIPI_DCS_SET_COLUMN_ADDRESS;
 206         buf[1] = (x1 >> 8) & 0xff;
 207         buf[2] = (x1 >> 0) & 0xff;
 208         buf[3] = (x2 >> 8) & 0xff;
 209         buf[4] = (x2 >> 0) & 0xff;
 210
 211         r = in->ops.dsi->dcs_write_nosync(in, ddata->channel, buf, sizeof(buf));
 212         if (r)
 213                 return r;
 214
 215         buf[0] = MIPI_DCS_SET_PAGE_ADDRESS;
 216         buf[1] = (y1 >> 8) & 0xff;
 217         buf[2] = (y1 >> 0) & 0xff;
 218         buf[3] = (y2 >> 8) & 0xff;
 219         buf[4] = (y2 >> 0) & 0xff;
 220
 221         r = in->ops.dsi->dcs_write_nosync(in, ddata->channel, buf, sizeof(buf));
 222         if (r)
 223                 return r;
 224
 225         in->ops.dsi->bta_sync(in, ddata->channel);
 226
 227         return r;
 228 }
 229
 230 static void dsicm_queue_ulps_work(struct panel_drv_data *ddata)
 231 {
 232         if (ddata->ulps_timeout > 0)
 233                 schedule_delayed_work(&ddata->ulps_work,
 234                                 msecs_to_jiffies(ddata->ulps_timeout));
 235 }
 236
 237 static void dsicm_cancel_ulps_work(struct panel_drv_data *ddata)
 238 {
 239         cancel_delayed_work(&ddata->ulps_work);
 240 }
 241
 242 static int dsicm_enter_ulps(struct panel_drv_data *ddata)
 243 {
 244         struct omap_dss_device *in = ddata->in;
 245         int r;
 246
 247         if (ddata->ulps_enabled)
 248                 return 0;
 249
 250         dsicm_cancel_ulps_work(ddata);
 251
 252         r = _dsicm_enable_te(ddata, false);
 253         if (r)
 254                 goto err;
 255
 256         if (gpio_is_valid(ddata->ext_te_gpio))
 257                 disable_irq(gpio_to_irq(ddata->ext_te_gpio));
 258
 259         in->ops.dsi->disable(in, false, true);
 260
 261         ddata->ulps_enabled = true;
 262
 263         return 0;
 264
 265 err:
 266         dev_err(&ddata->pdev->dev, "enter ULPS failed");
 267         dsicm_panel_reset(ddata);
 268
 269         ddata->ulps_enabled = false;
 270
 271         dsicm_queue_ulps_work(ddata);
 272
 273         return r;
 274 }
 275
 276 static int dsicm_exit_ulps(struct panel_drv_data *ddata)
 277 {
 278         struct omap_dss_device *in = ddata->in;
 279         int r;
 280
 281         if (!ddata->ulps_enabled)
 282                 return 0;
 283
 284         r = in->ops.dsi->enable(in);
 285         if (r) {
 286                 dev_err(&ddata->pdev->dev, "failed to enable DSI\n");
 287                 goto err1;
 288         }
 289
 290         in->ops.dsi->enable_hs(in, ddata->channel, true);
 291
 292         r = _dsicm_enable_te(ddata, true);
 293         if (r) {
 294                 dev_err(&ddata->pdev->dev, "failed to re-enable TE");
 295                 goto err2;
 296         }
 297
 298         if (gpio_is_valid(ddata->ext_te_gpio))
 299                 enable_irq(gpio_to_irq(ddata->ext_te_gpio));
 300
 301         dsicm_queue_ulps_work(ddata);
 302
 303         ddata->ulps_enabled = false;
 304
 305         return 0;
 306
 307 err2:
 308         dev_err(&ddata->pdev->dev, "failed to exit ULPS");
 309
 310         r = dsicm_panel_reset(ddata);
 311         if (!r) {
 312                 if (gpio_is_valid(ddata->ext_te_gpio))
 313                         enable_irq(gpio_to_irq(ddata->ext_te_gpio));
 314                 ddata->ulps_enabled = false;
 315         }
 316 err1:
 317         dsicm_queue_ulps_work(ddata);
 318
 319         return r;
 320 }
 321
 322 static int dsicm_wake_up(struct panel_drv_data *ddata)
 323 {
 324         if (ddata->ulps_enabled)
 325                 return dsicm_exit_ulps(ddata);
 326
 327         dsicm_cancel_ulps_work(ddata);
 328         dsicm_queue_ulps_work(ddata);
 329         return 0;
 330 }
 331
 332 static int dsicm_bl_update_status(struct backlight_device *dev)
 333 {
 334         struct panel_drv_data *ddata = dev_get_drvdata(&dev->dev);
 335         struct omap_dss_device *in = ddata->in;
 336         int r;
 337         int level;
 338
 339         if (dev->props.fb_blank == FB_BLANK_UNBLANK &&
 340                         dev->props.power == FB_BLANK_UNBLANK)
 341                 level = dev->props.brightness;
 342         else
 343                 level = 0;
 344
 345         dev_dbg(&ddata->pdev->dev, "update brightness to %d\n", level);
 346
 347         mutex_lock(&ddata->lock);
 348
 349         if (ddata->enabled) {
 350                 in->ops.dsi->bus_lock(in);
 351
 352                 r = dsicm_wake_up(ddata);
 353                 if (!r)
 354                         r = dsicm_dcs_write_1(ddata, DCS_BRIGHTNESS, level);
 355
 356                 in->ops.dsi->bus_unlock(in);
 357         } else {
 358                 r = 0;
 359         }
 360
 361         mutex_unlock(&ddata->lock);
 362
 363         return r;
 364 }
 365
 366 static int dsicm_bl_get_intensity(struct backlight_device *dev)
 367 {
 368         if (dev->props.fb_blank == FB_BLANK_UNBLANK &&
 369                         dev->props.power == FB_BLANK_UNBLANK)
 370                 return dev->props.brightness;
 371
 372         return 0;
 373 }
 374
 375 static const struct backlight_ops dsicm_bl_ops = {
 376         .get_brightness = dsicm_bl_get_intensity,
 377         .update_status  = dsicm_bl_update_status,
 378 };
 379
 380 static void dsicm_get_resolution(struct omap_dss_device *dssdev,
 381                 u16 *xres, u16 *yres)
 382 {
 383         *xres = dssdev->panel.timings.x_res;
 384         *yres = dssdev->panel.timings.y_res;
 385 }
 386
 387 static ssize_t dsicm_num_errors_show(struct device *dev,
 388                 struct device_attribute *attr, char *buf)
 389 {
 390         struct panel_drv_data *ddata = dev_get_drvdata(dev);
 391         struct omap_dss_device *in = ddata->in;
 392         u8 errors = 0;
 393         int r;
 394
 395         mutex_lock(&ddata->lock);
 396
 397         if (ddata->enabled) {
 398                 in->ops.dsi->bus_lock(in);
 399
 400                 r = dsicm_wake_up(ddata);
 401                 if (!r)
 402                         r = dsicm_dcs_read_1(ddata, DCS_READ_NUM_ERRORS,
 403                                         &errors);
 404
 405                 in->ops.dsi->bus_unlock(in);
 406         } else {
 407                 r = -ENODEV;
 408         }
 409
 410         mutex_unlock(&ddata->lock);
 411
 412         if (r)
 413                 return r;
 414
 415         return snprintf(buf, PAGE_SIZE, "%d\n", errors);
 416 }
 417
 418 static ssize_t dsicm_hw_revision_show(struct device *dev,
 419                 struct device_attribute *attr, char *buf)
 420 {
 421         struct panel_drv_data *ddata = dev_get_drvdata(dev);
 422         struct omap_dss_device *in = ddata->in;
 423         u8 id1, id2, id3;
 424         int r;
 425
 426         mutex_lock(&ddata->lock);
 427
 428         if (ddata->enabled) {
 429                 in->ops.dsi->bus_lock(in);
 430
 431                 r = dsicm_wake_up(ddata);
 432                 if (!r)
 433                         r = dsicm_get_id(ddata, &id1, &id2, &id3);
 434
 435                 in->ops.dsi->bus_unlock(in);
 436         } else {
 437                 r = -ENODEV;
 438         }
 439
 440         mutex_unlock(&ddata->lock);
 441
 442         if (r)
 443                 return r;
 444
 445         return snprintf(buf, PAGE_SIZE, "%02x.%02x.%02x\n", id1, id2, id3);
 446 }
 447
 448 static ssize_t dsicm_store_ulps(struct device *dev,
 449                 struct device_attribute *attr,
 450                 const char *buf, size_t count)
 451 {
 452         struct panel_drv_data *ddata = dev_get_drvdata(dev);
 453         struct omap_dss_device *in = ddata->in;
 454         unsigned long t;
 455         int r;
 456
 457         r = kstrtoul(buf, 0, &t);
 458         if (r)
 459                 return r;
 460
 461         mutex_lock(&ddata->lock);
 462
 463         if (ddata->enabled) {
 464                 in->ops.dsi->bus_lock(in);
 465
 466                 if (t)
 467                         r = dsicm_enter_ulps(ddata);
 468                 else
 469                         r = dsicm_wake_up(ddata);
 470
 471                 in->ops.dsi->bus_unlock(in);
 472         }
 473
 474         mutex_unlock(&ddata->lock);
 475
 476         if (r)
 477                 return r;
 478
 479         return count;
 480 }
 481
 482 static ssize_t dsicm_show_ulps(struct device *dev,
 483                 struct device_attribute *attr,
 484                 char *buf)
 485 {
 486         struct panel_drv_data *ddata = dev_get_drvdata(dev);
 487         unsigned t;
 488
 489         mutex_lock(&ddata->lock);
 490         t = ddata->ulps_enabled;
 491         mutex_unlock(&ddata->lock);
 492
 493         return snprintf(buf, PAGE_SIZE, "%u\n", t);
 494 }
 495
 496 static ssize_t dsicm_store_ulps_timeout(struct device *dev,
 497                 struct device_attribute *attr,
 498                 const char *buf, size_t count)
 499 {
 500         struct panel_drv_data *ddata = dev_get_drvdata(dev);
 501         struct omap_dss_device *in = ddata->in;
 502         unsigned long t;
 503         int r;
 504
 505         r = kstrtoul(buf, 0, &t);
 506         if (r)
 507                 return r;
 508
 509         mutex_lock(&ddata->lock);
 510         ddata->ulps_timeout = t;
 511
 512         if (ddata->enabled) {
 513                 /* dsicm_wake_up will restart the timer */
 514                 in->ops.dsi->bus_lock(in);
 515                 r = dsicm_wake_up(ddata);
 516                 in->ops.dsi->bus_unlock(in);
 517         }
 518
 519         mutex_unlock(&ddata->lock);
 520
 521         if (r)
 522                 return r;
 523
 524         return count;
 525 }
 526
 527 static ssize_t dsicm_show_ulps_timeout(struct device *dev,
 528                 struct device_attribute *attr,
 529                 char *buf)
 530 {
 531         struct panel_drv_data *ddata = dev_get_drvdata(dev);
 532         unsigned t;
 533
 534         mutex_lock(&ddata->lock);
 535         t = ddata->ulps_timeout;
 536         mutex_unlock(&ddata->lock);
 537
 538         return snprintf(buf, PAGE_SIZE, "%u\n", t);
 539 }
 540
 541 static DEVICE_ATTR(num_dsi_errors, S_IRUGO, dsicm_num_errors_show, NULL);
 542 static DEVICE_ATTR(hw_revision, S_IRUGO, dsicm_hw_revision_show, NULL);
 543 static DEVICE_ATTR(ulps, S_IRUGO | S_IWUSR,
 544                 dsicm_show_ulps, dsicm_store_ulps);
 545 static DEVICE_ATTR(ulps_timeout, S_IRUGO | S_IWUSR,
 546                 dsicm_show_ulps_timeout, dsicm_store_ulps_timeout);
 547
 548 static struct attribute *dsicm_attrs[] = {
 549         &dev_attr_num_dsi_errors.attr,
 550         &dev_attr_hw_revision.attr,
 551         &dev_attr_ulps.attr,
 552         &dev_attr_ulps_timeout.attr,
 553         NULL,
 554 };
 555
 556 static const struct attribute_group dsicm_attr_group = {
 557         .attrs = dsicm_attrs,
 558 };
 559
 560 static void dsicm_hw_reset(struct panel_drv_data *ddata)
 561 {
 562         if (!gpio_is_valid(ddata->reset_gpio))
 563                 return;
 564
 565         gpio_set_value(ddata->reset_gpio, 1);
 566         udelay(10);
 567         /* reset the panel */
 568         gpio_set_value(ddata->reset_gpio, 0);
 569         /* assert reset */
 570         udelay(10);
 571         gpio_set_value(ddata->reset_gpio, 1);
 572         /* wait after releasing reset */
 573         usleep_range(5000, 10000);
 574 }
 575
 576 static int dsicm_power_on(struct panel_drv_data *ddata)
 577 {
 578         struct omap_dss_device *in = ddata->in;
 579         u8 id1, id2, id3;
 580         int r;
 581         struct omap_dss_dsi_config dsi_config = {
 582                 .mode = OMAP_DSS_DSI_CMD_MODE,
 583                 .pixel_format = OMAP_DSS_DSI_FMT_RGB888,
 584                 .timings = &ddata->timings,
 585                 .hs_clk_min = 150000000,
 586                 .hs_clk_max = 300000000,
 587                 .lp_clk_min = 7000000,
 588                 .lp_clk_max = 10000000,
 589         };
 590
 591         if (ddata->pin_config.num_pins > 0) {
 592                 r = in->ops.dsi->configure_pins(in, &ddata->pin_config);
 593                 if (r) {
 594                         dev_err(&ddata->pdev->dev,
 595                                 "failed to configure DSI pins\n");
 596                         goto err0;
 597                 }
 598         }
 599
 600         r = in->ops.dsi->set_config(in, &dsi_config);
 601         if (r) {
 602                 dev_err(&ddata->pdev->dev, "failed to configure DSI\n");
 603                 goto err0;
 604         }
 605
 606         r = in->ops.dsi->enable(in);
 607         if (r) {
 608                 dev_err(&ddata->pdev->dev, "failed to enable DSI\n");
 609                 goto err0;
 610         }
 611
 612         dsicm_hw_reset(ddata);
 613
 614         in->ops.dsi->enable_hs(in, ddata->channel, false);
 615
 616         r = dsicm_sleep_out(ddata);
 617         if (r)
 618                 goto err;
 619
 620         r = dsicm_get_id(ddata, &id1, &id2, &id3);
 621         if (r)
 622                 goto err;
 623
 624         r = dsicm_dcs_write_1(ddata, DCS_BRIGHTNESS, 0xff);
 625         if (r)
 626                 goto err;
 627
 628         r = dsicm_dcs_write_1(ddata, DCS_CTRL_DISPLAY,
 629                         (1<<2) | (1<<5));       /* BL | BCTRL */
 630         if (r)
 631                 goto err;
 632
 633         r = dsicm_dcs_write_1(ddata, MIPI_DCS_SET_PIXEL_FORMAT,
 634                 MIPI_DCS_PIXEL_FMT_24BIT);
 635         if (r)
 636                 goto err;
 637
 638         r = dsicm_dcs_write_0(ddata, MIPI_DCS_SET_DISPLAY_ON);
 639         if (r)
 640                 goto err;
 641
 642         r = _dsicm_enable_te(ddata, ddata->te_enabled);
 643         if (r)
 644                 goto err;
 645
 646         r = in->ops.dsi->enable_video_output(in, ddata->channel);
 647         if (r)
 648                 goto err;
 649
 650         ddata->enabled = 1;
 651
 652         if (!ddata->intro_printed) {
 653                 dev_info(&ddata->pdev->dev, "panel revision %02x.%02x.%02x\n",
 654                         id1, id2, id3);
 655                 ddata->intro_printed = true;
 656         }
 657
 658         in->ops.dsi->enable_hs(in, ddata->channel, true);
 659
 660         return 0;
 661 err:
 662         dev_err(&ddata->pdev->dev, "error while enabling panel, issuing HW reset\n");
 663
 664         dsicm_hw_reset(ddata);
 665
 666         in->ops.dsi->disable(in, true, false);
 667 err0:
 668         return r;
 669 }
 670
 671 static void dsicm_power_off(struct panel_drv_data *ddata)
 672 {
 673         struct omap_dss_device *in = ddata->in;
 674         int r;
 675
 676         in->ops.dsi->disable_video_output(in, ddata->channel);
 677
 678         r = dsicm_dcs_write_0(ddata, MIPI_DCS_SET_DISPLAY_OFF);
 679         if (!r)
 680                 r = dsicm_sleep_in(ddata);
 681
 682         if (r) {
 683                 dev_err(&ddata->pdev->dev,
 684                                 "error disabling panel, issuing HW reset\n");
 685                 dsicm_hw_reset(ddata);
 686         }
 687
 688         in->ops.dsi->disable(in, true, false);
 689
 690         ddata->enabled = 0;
 691 }
 692
 693 static int dsicm_panel_reset(struct panel_drv_data *ddata)
 694 {
 695         dev_err(&ddata->pdev->dev, "performing LCD reset\n");
 696
 697         dsicm_power_off(ddata);
 698         dsicm_hw_reset(ddata);
 699         return dsicm_power_on(ddata);
 700 }
 701
 702 static int dsicm_connect(struct omap_dss_device *dssdev)
 703 {
 704         struct panel_drv_data *ddata = to_panel_data(dssdev);
 705         struct omap_dss_device *in = ddata->in;
 706         struct device *dev = &ddata->pdev->dev;
 707         int r;
 708
 709         if (omapdss_device_is_connected(dssdev))
 710                 return 0;
 711
 712         r = in->ops.dsi->connect(in, dssdev);
 713         if (r) {
 714                 dev_err(dev, "Failed to connect to video source\n");
 715                 return r;
 716         }
 717
 718         r = in->ops.dsi->request_vc(ddata->in, &ddata->channel);
 719         if (r) {
 720                 dev_err(dev, "failed to get virtual channel\n");
 721                 goto err_req_vc;
 722         }
 723
 724         r = in->ops.dsi->set_vc_id(ddata->in, ddata->channel, TCH);
 725         if (r) {
 726                 dev_err(dev, "failed to set VC_ID\n");
 727                 goto err_vc_id;
 728         }
 729
 730         return 0;
 731
 732 err_vc_id:
 733         in->ops.dsi->release_vc(ddata->in, ddata->channel);
 734 err_req_vc:
 735         in->ops.dsi->disconnect(in, dssdev);
 736         return r;
 737 }
 738
 739 static void dsicm_disconnect(struct omap_dss_device *dssdev)
 740 {
 741         struct panel_drv_data *ddata = to_panel_data(dssdev);
 742         struct omap_dss_device *in = ddata->in;
 743
 744         if (!omapdss_device_is_connected(dssdev))
 745                 return;
 746
 747         in->ops.dsi->release_vc(in, ddata->channel);
 748         in->ops.dsi->disconnect(in, dssdev);
 749 }
 750
 751 static int dsicm_enable(struct omap_dss_device *dssdev)
 752 {
 753         struct panel_drv_data *ddata = to_panel_data(dssdev);
 754         struct omap_dss_device *in = ddata->in;
 755         int r;
 756
 757         dev_dbg(&ddata->pdev->dev, "enable\n");
 758
 759         mutex_lock(&ddata->lock);
 760
 761         if (!omapdss_device_is_connected(dssdev)) {
 762                 r = -ENODEV;
 763                 goto err;
 764         }
 765
 766         if (omapdss_device_is_enabled(dssdev)) {
 767                 r = 0;
 768                 goto err;
 769         }
 770
 771         in->ops.dsi->bus_lock(in);
 772
 773         r = dsicm_power_on(ddata);
 774
 775         in->ops.dsi->bus_unlock(in);
 776
 777         if (r)
 778                 goto err;
 779
 780         dssdev->state = OMAP_DSS_DISPLAY_ACTIVE;
 781
 782         mutex_unlock(&ddata->lock);
 783
 784         return 0;
 785 err:
 786         dev_dbg(&ddata->pdev->dev, "enable failed\n");
 787         mutex_unlock(&ddata->lock);
 788         return r;
 789 }
 790
 791 static void dsicm_disable(struct omap_dss_device *dssdev)
 792 {
 793         struct panel_drv_data *ddata = to_panel_data(dssdev);
 794         struct omap_dss_device *in = ddata->in;
 795         int r;
 796
 797         dev_dbg(&ddata->pdev->dev, "disable\n");
 798
 799         mutex_lock(&ddata->lock);
 800
 801         dsicm_cancel_ulps_work(ddata);
 802
 803         in->ops.dsi->bus_lock(in);
 804
 805         if (omapdss_device_is_enabled(dssdev)) {
 806                 r = dsicm_wake_up(ddata);
 807                 if (!r)
 808                         dsicm_power_off(ddata);
 809         }
 810
 811         in->ops.dsi->bus_unlock(in);
 812
 813         dssdev->state = OMAP_DSS_DISPLAY_DISABLED;
 814
 815         mutex_unlock(&ddata->lock);
 816 }
 817
 818 static void dsicm_framedone_cb(int err, void *data)
 819 {
 820         struct panel_drv_data *ddata = data;
 821         struct omap_dss_device *in = ddata->in;
 822
 823         dev_dbg(&ddata->pdev->dev, "framedone, err %d\n", err);
 824         in->ops.dsi->bus_unlock(ddata->in);
 825 }
 826
 827 static irqreturn_t dsicm_te_isr(int irq, void *data)
 828 {
 829         struct panel_drv_data *ddata = data;
 830         struct omap_dss_device *in = ddata->in;
 831         int old;
 832         int r;
 833
 834         old = atomic_cmpxchg(&ddata->do_update, 1, 0);
 835
 836         if (old) {
 837                 cancel_delayed_work(&ddata->te_timeout_work);
 838
 839                 r = in->ops.dsi->update(in, ddata->channel, dsicm_framedone_cb,
 840                                 ddata);
 841                 if (r)
 842                         goto err;
 843         }
 844
 845         return IRQ_HANDLED;
 846 err:
 847         dev_err(&ddata->pdev->dev, "start update failed\n");
 848         in->ops.dsi->bus_unlock(in);
 849         return IRQ_HANDLED;
 850 }
 851
 852 static void dsicm_te_timeout_work_callback(struct work_struct *work)
 853 {
 854         struct panel_drv_data *ddata = container_of(work, struct panel_drv_data,
 855                                         te_timeout_work.work);
 856         struct omap_dss_device *in = ddata->in;
 857
 858         dev_err(&ddata->pdev->dev, "TE not received for 250ms!\n");
 859
 860         atomic_set(&ddata->do_update, 0);
 861         in->ops.dsi->bus_unlock(in);
 862 }
 863
 864 static int dsicm_update(struct omap_dss_device *dssdev,
 865                                     u16 x, u16 y, u16 w, u16 h)
 866 {
 867         struct panel_drv_data *ddata = to_panel_data(dssdev);
 868         struct omap_dss_device *in = ddata->in;
 869         int r;
 870
 871         dev_dbg(&ddata->pdev->dev, "update %d, %d, %d x %d\n", x, y, w, h);
 872
 873         mutex_lock(&ddata->lock);
 874         in->ops.dsi->bus_lock(in);
 875
 876         r = dsicm_wake_up(ddata);
 877         if (r)
 878                 goto err;
 879
 880         if (!ddata->enabled) {
 881                 r = 0;
 882                 goto err;
 883         }
 884
 885         /* XXX no need to send this every frame, but dsi break if not done */
 886         r = dsicm_set_update_window(ddata, 0, 0,
 887                         dssdev->panel.timings.x_res,
 888                         dssdev->panel.timings.y_res);
 889         if (r)
 890                 goto err;
 891
 892         if (ddata->te_enabled && gpio_is_valid(ddata->ext_te_gpio)) {
 893                 schedule_delayed_work(&ddata->te_timeout_work,
 894                                 msecs_to_jiffies(250));
 895                 atomic_set(&ddata->do_update, 1);
 896         } else {
 897                 r = in->ops.dsi->update(in, ddata->channel, dsicm_framedone_cb,
 898                                 ddata);
 899                 if (r)
 900                         goto err;
 901         }
 902
 903         /* note: no bus_unlock here. unlock is in framedone_cb */
 904         mutex_unlock(&ddata->lock);
 905         return 0;
 906 err:
 907         in->ops.dsi->bus_unlock(in);
 908         mutex_unlock(&ddata->lock);
 909         return r;
 910 }
 911
 912 static int dsicm_sync(struct omap_dss_device *dssdev)
 913 {
 914         struct panel_drv_data *ddata = to_panel_data(dssdev);
 915         struct omap_dss_device *in = ddata->in;
 916
 917         dev_dbg(&ddata->pdev->dev, "sync\n");
 918
 919         mutex_lock(&ddata->lock);
 920         in->ops.dsi->bus_lock(in);
 921         in->ops.dsi->bus_unlock(in);
 922         mutex_unlock(&ddata->lock);
 923
 924         dev_dbg(&ddata->pdev->dev, "sync done\n");
 925
 926         return 0;
 927 }
 928
 929 static int _dsicm_enable_te(struct panel_drv_data *ddata, bool enable)
 930 {
 931         struct omap_dss_device *in = ddata->in;
 932         int r;
 933
 934         if (enable)
 935                 r = dsicm_dcs_write_1(ddata, MIPI_DCS_SET_TEAR_ON, 0);
 936         else
 937                 r = dsicm_dcs_write_0(ddata, MIPI_DCS_SET_TEAR_OFF);
 938
 939         if (!gpio_is_valid(ddata->ext_te_gpio))
 940                 in->ops.dsi->enable_te(in, enable);
 941
 942         /* possible panel bug */
 943         msleep(100);
 944
 945         return r;
 946 }
 947
 948 static int dsicm_enable_te(struct omap_dss_device *dssdev, bool enable)
 949 {
 950         struct panel_drv_data *ddata = to_panel_data(dssdev);
 951         struct omap_dss_device *in = ddata->in;
 952         int r;
 953
 954         mutex_lock(&ddata->lock);
 955
 956         if (ddata->te_enabled == enable)
 957                 goto end;
 958
 959         in->ops.dsi->bus_lock(in);
 960
 961         if (ddata->enabled) {
 962                 r = dsicm_wake_up(ddata);
 963                 if (r)
 964                         goto err;
 965
 966                 r = _dsicm_enable_te(ddata, enable);
 967                 if (r)
 968                         goto err;
 969         }
 970
 971         ddata->te_enabled = enable;
 972
 973         in->ops.dsi->bus_unlock(in);
 974 end:
 975         mutex_unlock(&ddata->lock);
 976
 977         return 0;
 978 err:
 979         in->ops.dsi->bus_unlock(in);
 980         mutex_unlock(&ddata->lock);
 981
 982         return r;
 983 }
 984
 985 static int dsicm_get_te(struct omap_dss_device *dssdev)
 986 {
 987         struct panel_drv_data *ddata = to_panel_data(dssdev);
 988         int r;
 989
 990         mutex_lock(&ddata->lock);
 991         r = ddata->te_enabled;
 992         mutex_unlock(&ddata->lock);
 993
 994         return r;
 995 }
 996
 997 static int dsicm_memory_read(struct omap_dss_device *dssdev,
 998                 void *buf, size_t size,
 999                 u16 x, u16 y, u16 w, u16 h)
1000 {
1001         struct panel_drv_data *ddata = to_panel_data(dssdev);
1002         struct omap_dss_device *in = ddata->in;
1003         int r;
1004         int first = 1;
1005         int plen;
1006         unsigned buf_used = 0;
1007
1008         if (size < w * h * 3)
1009                 return -ENOMEM;
1010
1011         mutex_lock(&ddata->lock);
1012
1013         if (!ddata->enabled) {
1014                 r = -ENODEV;
1015                 goto err1;
1016         }
1017
1018         size = min(w * h * 3,
1019                         dssdev->panel.timings.x_res *
1020                         dssdev->panel.timings.y_res * 3);
1021
1022         in->ops.dsi->bus_lock(in);
1023
1024         r = dsicm_wake_up(ddata);
1025         if (r)
1026                 goto err2;
1027
1028         /* plen 1 or 2 goes into short packet. until checksum error is fixed,
1029          * use short packets. plen 32 works, but bigger packets seem to cause
1030          * an error. */
1031         if (size % 2)
1032                 plen = 1;
1033         else
1034                 plen = 2;
1035
1036         dsicm_set_update_window(ddata, x, y, w, h);
1037
1038         r = in->ops.dsi->set_max_rx_packet_size(in, ddata->channel, plen);
1039         if (r)
1040                 goto err2;
1041
1042         while (buf_used < size) {
1043                 u8 dcs_cmd = first ? 0x2e : 0x3e;
1044                 first = 0;
1045
1046                 r = in->ops.dsi->dcs_read(in, ddata->channel, dcs_cmd,
1047                                 buf + buf_used, size - buf_used);
1048
1049                 if (r < 0) {
1050                         dev_err(dssdev->dev, "read error\n");
1051                         goto err3;
1052                 }
1053
1054                 buf_used += r;
1055
1056                 if (r < plen) {
1057                         dev_err(&ddata->pdev->dev, "short read\n");
1058                         break;
1059                 }
1060
1061                 if (signal_pending(current)) {
1062                         dev_err(&ddata->pdev->dev, "signal pending, "
1063                                         "aborting memory read\n");
1064                         r = -ERESTARTSYS;
1065                         goto err3;
1066                 }
1067         }
1068
1069         r = buf_used;
1070
1071 err3:
1072         in->ops.dsi->set_max_rx_packet_size(in, ddata->channel, 1);
1073 err2:
1074         in->ops.dsi->bus_unlock(in);
1075 err1:
1076         mutex_unlock(&ddata->lock);
1077         return r;
1078 }
1079
1080 static void dsicm_ulps_work(struct work_struct *work)
1081 {
1082         struct panel_drv_data *ddata = container_of(work, struct panel_drv_data,
1083                         ulps_work.work);
1084         struct omap_dss_device *dssdev = &ddata->dssdev;
1085         struct omap_dss_device *in = ddata->in;
1086
1087         mutex_lock(&ddata->lock);
1088
1089         if (dssdev->state != OMAP_DSS_DISPLAY_ACTIVE || !ddata->enabled) {
1090                 mutex_unlock(&ddata->lock);
1091                 return;
1092         }
1093
1094         in->ops.dsi->bus_lock(in);
1095
1096         dsicm_enter_ulps(ddata);
1097
1098         in->ops.dsi->bus_unlock(in);
1099         mutex_unlock(&ddata->lock);
1100 }
1101
1102 static struct omap_dss_driver dsicm_ops = {
1103         .connect        = dsicm_connect,
1104         .disconnect     = dsicm_disconnect,
1105
1106         .enable         = dsicm_enable,
1107         .disable        = dsicm_disable,
1108
1109         .update         = dsicm_update,
1110         .sync           = dsicm_sync,
1111
1112         .get_resolution = dsicm_get_resolution,
1113         .get_recommended_bpp = omapdss_default_get_recommended_bpp,
1114
1115         .enable_te      = dsicm_enable_te,
1116         .get_te         = dsicm_get_te,
1117
1118         .memory_read    = dsicm_memory_read,
1119 };
1120
1121 static int dsicm_probe_of(struct platform_device *pdev)
1122 {
1123         struct device_node *node = pdev->dev.of_node;
1124         struct panel_drv_data *ddata = platform_get_drvdata(pdev);
1125         struct omap_dss_device *in;
1126         int gpio;
1127
1128         gpio = of_get_named_gpio(node, "reset-gpios", 0);
1129         if (!gpio_is_valid(gpio)) {
1130                 dev_err(&pdev->dev, "failed to parse reset gpio\n");
1131                 return gpio;
1132         }
1133         ddata->reset_gpio = gpio;
1134
1135         gpio = of_get_named_gpio(node, "te-gpios", 0);
1136         if (gpio_is_valid(gpio) || gpio == -ENOENT) {
1137                 ddata->ext_te_gpio = gpio;
1138         } else {
1139                 dev_err(&pdev->dev, "failed to parse TE gpio\n");
1140                 return gpio;
1141         }
1142
1143         in = omapdss_of_find_source_for_first_ep(node);
1144         if (IS_ERR(in)) {
1145                 dev_err(&pdev->dev, "failed to find video source\n");
1146                 return PTR_ERR(in);
1147         }
1148
1149         ddata->in = in;
1150
1151         /* TODO: ulps, backlight */
1152
1153         return 0;
1154 }
1155
1156 static int dsicm_probe(struct platform_device *pdev)
1157 {
1158         struct backlight_properties props;
1159         struct panel_drv_data *ddata;
1160         struct backlight_device *bldev = NULL;
1161         struct device *dev = &pdev->dev;
1162         struct omap_dss_device *dssdev;
1163         int r;
1164
1165         dev_dbg(dev, "probe\n");
1166
1167         if (!pdev->dev.of_node)
1168                 return -ENODEV;
1169
1170         ddata = devm_kzalloc(dev, sizeof(*ddata), GFP_KERNEL);
1171         if (!ddata)
1172                 return -ENOMEM;
1173
1174         platform_set_drvdata(pdev, ddata);
1175         ddata->pdev = pdev;
1176
1177         r = dsicm_probe_of(pdev);
1178         if (r)
1179                 return r;
1180
1181         ddata->timings.x_res = 864;
1182         ddata->timings.y_res = 480;
1183         ddata->timings.pixelclock = 864 * 480 * 60;
1184
1185         dssdev = &ddata->dssdev;
1186         dssdev->dev = dev;
1187         dssdev->driver = &dsicm_ops;
1188         dssdev->panel.timings = ddata->timings;
1189         dssdev->type = OMAP_DISPLAY_TYPE_DSI;
1190         dssdev->owner = THIS_MODULE;
1191
1192         dssdev->panel.dsi_pix_fmt = OMAP_DSS_DSI_FMT_RGB888;
1193         dssdev->caps = OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE |
1194                 OMAP_DSS_DISPLAY_CAP_TEAR_ELIM;
1195
1196         r = omapdss_register_display(dssdev);
1197         if (r) {
1198                 dev_err(dev, "Failed to register panel\n");
1199                 goto err_reg;
1200         }
1201
1202         mutex_init(&ddata->lock);
1203
1204         atomic_set(&ddata->do_update, 0);
1205
1206         if (gpio_is_valid(ddata->reset_gpio)) {
1207                 r = devm_gpio_request_one(dev, ddata->reset_gpio,
1208                                 GPIOF_OUT_INIT_LOW, "taal rst");
1209                 if (r) {
1210                         dev_err(dev, "failed to request reset gpio\n");
1211                         return r;
1212                 }
1213         }
1214
1215         if (gpio_is_valid(ddata->ext_te_gpio)) {
1216                 r = devm_gpio_request_one(dev, ddata->ext_te_gpio,
1217                                 GPIOF_IN, "taal irq");
1218                 if (r) {
1219                         dev_err(dev, "GPIO request failed\n");
1220                         return r;
1221                 }
1222
1223                 r = devm_request_irq(dev, gpio_to_irq(ddata->ext_te_gpio),
1224                                 dsicm_te_isr,
1225                                 IRQF_TRIGGER_RISING,
1226                                 "taal vsync", ddata);
1227
1228                 if (r) {
1229                         dev_err(dev, "IRQ request failed\n");
1230                         return r;
1231                 }
1232
1233                 INIT_DEFERRABLE_WORK(&ddata->te_timeout_work,
1234                                         dsicm_te_timeout_work_callback);
1235
1236                 dev_dbg(dev, "Using GPIO TE\n");
1237         }
1238
1239         INIT_DELAYED_WORK(&ddata->ulps_work, dsicm_ulps_work);
1240
1241         dsicm_hw_reset(ddata);
1242
1243         if (ddata->use_dsi_backlight) {
1244                 memset(&props, 0, sizeof(struct backlight_properties));
1245                 props.max_brightness = 255;
1246
1247                 props.type = BACKLIGHT_RAW;
1248                 bldev = backlight_device_register(dev_name(dev),
1249                                 dev, ddata, &dsicm_bl_ops, &props);
1250                 if (IS_ERR(bldev)) {
1251                         r = PTR_ERR(bldev);
1252                         goto err_reg;
1253                 }
1254
1255                 ddata->bldev = bldev;
1256
1257                 bldev->props.fb_blank = FB_BLANK_UNBLANK;
1258                 bldev->props.power = FB_BLANK_UNBLANK;
1259                 bldev->props.brightness = 255;
1260
1261                 dsicm_bl_update_status(bldev);
1262         }
1263
1264         r = sysfs_create_group(&dev->kobj, &dsicm_attr_group);
1265         if (r) {
1266                 dev_err(dev, "failed to create sysfs files\n");
1267                 goto err_sysfs_create;
1268         }
1269
1270         return 0;
1271
1272 err_sysfs_create:
1273         if (bldev != NULL)
1274                 backlight_device_unregister(bldev);
1275 err_reg:
1276         return r;
1277 }
1278
1279 static int __exit dsicm_remove(struct platform_device *pdev)
1280 {
1281         struct panel_drv_data *ddata = platform_get_drvdata(pdev);
1282         struct omap_dss_device *dssdev = &ddata->dssdev;
1283         struct backlight_device *bldev;
1284
1285         dev_dbg(&pdev->dev, "remove\n");
1286
1287         omapdss_unregister_display(dssdev);
1288
1289         dsicm_disable(dssdev);
1290         dsicm_disconnect(dssdev);
1291
1292         sysfs_remove_group(&pdev->dev.kobj, &dsicm_attr_group);
1293
1294         bldev = ddata->bldev;
1295         if (bldev != NULL) {
1296                 bldev->props.power = FB_BLANK_POWERDOWN;
1297                 dsicm_bl_update_status(bldev);
1298                 backlight_device_unregister(bldev);
1299         }
1300
1301         omap_dss_put_device(ddata->in);
1302
1303         dsicm_cancel_ulps_work(ddata);
1304
1305         /* reset, to be sure that the panel is in a valid state */
1306         dsicm_hw_reset(ddata);
1307
1308         return 0;
1309 }
1310
1311 static const struct of_device_id dsicm_of_match[] = {
1312         { .compatible = "omapdss,panel-dsi-cm", },
1313         {},
1314 };
1315
1316 MODULE_DEVICE_TABLE(of, dsicm_of_match);
1317
1318 static struct platform_driver dsicm_driver = {
1319         .probe = dsicm_probe,
1320         .remove = __exit_p(dsicm_remove),
1321         .driver = {
1322                 .name = "panel-dsi-cm",
1323                 .of_match_table = dsicm_of_match,
1324                 .suppress_bind_attrs = true,
1325         },
1326 };
1327
1328 module_platform_driver(dsicm_driver);
1329
1330 MODULE_AUTHOR("Tomi Valkeinen <tomi.valkeinen@ti.com>");
1331 MODULE_DESCRIPTION("Generic DSI Command Mode Panel Driver");
1332 MODULE_LICENSE("GPL");