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