Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Generic DSI Command Mode panel driver
0004  *
0005  * Copyright (C) 2013 Texas Instruments
0006  * Author: Tomi Valkeinen <tomi.valkeinen@ti.com>
0007  */
0008 
0009 /* #define DEBUG */
0010 
0011 #include <linux/backlight.h>
0012 #include <linux/delay.h>
0013 #include <linux/fb.h>
0014 #include <linux/gpio.h>
0015 #include <linux/interrupt.h>
0016 #include <linux/jiffies.h>
0017 #include <linux/module.h>
0018 #include <linux/platform_device.h>
0019 #include <linux/sched/signal.h>
0020 #include <linux/slab.h>
0021 #include <linux/workqueue.h>
0022 #include <linux/of_device.h>
0023 #include <linux/of_gpio.h>
0024 
0025 #include <video/omapfb_dss.h>
0026 #include <video/mipi_display.h>
0027 
0028 /* DSI Virtual channel. Hardcoded for now. */
0029 #define TCH 0
0030 
0031 #define DCS_READ_NUM_ERRORS 0x05
0032 #define DCS_BRIGHTNESS      0x51
0033 #define DCS_CTRL_DISPLAY    0x53
0034 #define DCS_GET_ID1     0xda
0035 #define DCS_GET_ID2     0xdb
0036 #define DCS_GET_ID3     0xdc
0037 
0038 struct panel_drv_data {
0039     struct omap_dss_device dssdev;
0040     struct omap_dss_device *in;
0041 
0042     struct omap_video_timings timings;
0043 
0044     struct platform_device *pdev;
0045 
0046     struct mutex lock;
0047 
0048     struct backlight_device *bldev;
0049 
0050     unsigned long   hw_guard_end;   /* next value of jiffies when we can
0051                      * issue the next sleep in/out command
0052                      */
0053     unsigned long   hw_guard_wait;  /* max guard time in jiffies */
0054 
0055     /* panel HW configuration from DT or platform data */
0056     int reset_gpio;
0057     int ext_te_gpio;
0058 
0059     bool use_dsi_backlight;
0060 
0061     struct omap_dsi_pin_config pin_config;
0062 
0063     /* runtime variables */
0064     bool enabled;
0065 
0066     bool te_enabled;
0067 
0068     atomic_t do_update;
0069     int channel;
0070 
0071     struct delayed_work te_timeout_work;
0072 
0073     bool intro_printed;
0074 
0075     bool ulps_enabled;
0076     unsigned ulps_timeout;
0077     struct delayed_work ulps_work;
0078 };
0079 
0080 #define to_panel_data(p) container_of(p, struct panel_drv_data, dssdev)
0081 
0082 static irqreturn_t dsicm_te_isr(int irq, void *data);
0083 static void dsicm_te_timeout_work_callback(struct work_struct *work);
0084 static int _dsicm_enable_te(struct panel_drv_data *ddata, bool enable);
0085 
0086 static int dsicm_panel_reset(struct panel_drv_data *ddata);
0087 
0088 static void dsicm_ulps_work(struct work_struct *work);
0089 
0090 static void hw_guard_start(struct panel_drv_data *ddata, int guard_msec)
0091 {
0092     ddata->hw_guard_wait = msecs_to_jiffies(guard_msec);
0093     ddata->hw_guard_end = jiffies + ddata->hw_guard_wait;
0094 }
0095 
0096 static void hw_guard_wait(struct panel_drv_data *ddata)
0097 {
0098     unsigned long wait = ddata->hw_guard_end - jiffies;
0099 
0100     if ((long)wait > 0 && time_before_eq(wait, ddata->hw_guard_wait)) {
0101         set_current_state(TASK_UNINTERRUPTIBLE);
0102         schedule_timeout(wait);
0103     }
0104 }
0105 
0106 static int dsicm_dcs_read_1(struct panel_drv_data *ddata, u8 dcs_cmd, u8 *data)
0107 {
0108     struct omap_dss_device *in = ddata->in;
0109     int r;
0110     u8 buf[1];
0111 
0112     r = in->ops.dsi->dcs_read(in, ddata->channel, dcs_cmd, buf, 1);
0113 
0114     if (r < 0)
0115         return r;
0116 
0117     *data = buf[0];
0118 
0119     return 0;
0120 }
0121 
0122 static int dsicm_dcs_write_0(struct panel_drv_data *ddata, u8 dcs_cmd)
0123 {
0124     struct omap_dss_device *in = ddata->in;
0125     return in->ops.dsi->dcs_write(in, ddata->channel, &dcs_cmd, 1);
0126 }
0127 
0128 static int dsicm_dcs_write_1(struct panel_drv_data *ddata, u8 dcs_cmd, u8 param)
0129 {
0130     struct omap_dss_device *in = ddata->in;
0131     u8 buf[2] = { dcs_cmd, param };
0132 
0133     return in->ops.dsi->dcs_write(in, ddata->channel, buf, 2);
0134 }
0135 
0136 static int dsicm_sleep_in(struct panel_drv_data *ddata)
0137 
0138 {
0139     struct omap_dss_device *in = ddata->in;
0140     u8 cmd;
0141     int r;
0142 
0143     hw_guard_wait(ddata);
0144 
0145     cmd = MIPI_DCS_ENTER_SLEEP_MODE;
0146     r = in->ops.dsi->dcs_write_nosync(in, ddata->channel, &cmd, 1);
0147     if (r)
0148         return r;
0149 
0150     hw_guard_start(ddata, 120);
0151 
0152     usleep_range(5000, 10000);
0153 
0154     return 0;
0155 }
0156 
0157 static int dsicm_sleep_out(struct panel_drv_data *ddata)
0158 {
0159     int r;
0160 
0161     hw_guard_wait(ddata);
0162 
0163     r = dsicm_dcs_write_0(ddata, MIPI_DCS_EXIT_SLEEP_MODE);
0164     if (r)
0165         return r;
0166 
0167     hw_guard_start(ddata, 120);
0168 
0169     usleep_range(5000, 10000);
0170 
0171     return 0;
0172 }
0173 
0174 static int dsicm_get_id(struct panel_drv_data *ddata, u8 *id1, u8 *id2, u8 *id3)
0175 {
0176     int r;
0177 
0178     r = dsicm_dcs_read_1(ddata, DCS_GET_ID1, id1);
0179     if (r)
0180         return r;
0181     r = dsicm_dcs_read_1(ddata, DCS_GET_ID2, id2);
0182     if (r)
0183         return r;
0184     r = dsicm_dcs_read_1(ddata, DCS_GET_ID3, id3);
0185     if (r)
0186         return r;
0187 
0188     return 0;
0189 }
0190 
0191 static int dsicm_set_update_window(struct panel_drv_data *ddata,
0192         u16 x, u16 y, u16 w, u16 h)
0193 {
0194     struct omap_dss_device *in = ddata->in;
0195     int r;
0196     u16 x1 = x;
0197     u16 x2 = x + w - 1;
0198     u16 y1 = y;
0199     u16 y2 = y + h - 1;
0200 
0201     u8 buf[5];
0202     buf[0] = MIPI_DCS_SET_COLUMN_ADDRESS;
0203     buf[1] = (x1 >> 8) & 0xff;
0204     buf[2] = (x1 >> 0) & 0xff;
0205     buf[3] = (x2 >> 8) & 0xff;
0206     buf[4] = (x2 >> 0) & 0xff;
0207 
0208     r = in->ops.dsi->dcs_write_nosync(in, ddata->channel, buf, sizeof(buf));
0209     if (r)
0210         return r;
0211 
0212     buf[0] = MIPI_DCS_SET_PAGE_ADDRESS;
0213     buf[1] = (y1 >> 8) & 0xff;
0214     buf[2] = (y1 >> 0) & 0xff;
0215     buf[3] = (y2 >> 8) & 0xff;
0216     buf[4] = (y2 >> 0) & 0xff;
0217 
0218     r = in->ops.dsi->dcs_write_nosync(in, ddata->channel, buf, sizeof(buf));
0219     if (r)
0220         return r;
0221 
0222     in->ops.dsi->bta_sync(in, ddata->channel);
0223 
0224     return r;
0225 }
0226 
0227 static void dsicm_queue_ulps_work(struct panel_drv_data *ddata)
0228 {
0229     if (ddata->ulps_timeout > 0)
0230         schedule_delayed_work(&ddata->ulps_work,
0231                 msecs_to_jiffies(ddata->ulps_timeout));
0232 }
0233 
0234 static void dsicm_cancel_ulps_work(struct panel_drv_data *ddata)
0235 {
0236     cancel_delayed_work(&ddata->ulps_work);
0237 }
0238 
0239 static int dsicm_enter_ulps(struct panel_drv_data *ddata)
0240 {
0241     struct omap_dss_device *in = ddata->in;
0242     int r;
0243 
0244     if (ddata->ulps_enabled)
0245         return 0;
0246 
0247     dsicm_cancel_ulps_work(ddata);
0248 
0249     r = _dsicm_enable_te(ddata, false);
0250     if (r)
0251         goto err;
0252 
0253     if (gpio_is_valid(ddata->ext_te_gpio))
0254         disable_irq(gpio_to_irq(ddata->ext_te_gpio));
0255 
0256     in->ops.dsi->disable(in, false, true);
0257 
0258     ddata->ulps_enabled = true;
0259 
0260     return 0;
0261 
0262 err:
0263     dev_err(&ddata->pdev->dev, "enter ULPS failed");
0264     dsicm_panel_reset(ddata);
0265 
0266     ddata->ulps_enabled = false;
0267 
0268     dsicm_queue_ulps_work(ddata);
0269 
0270     return r;
0271 }
0272 
0273 static int dsicm_exit_ulps(struct panel_drv_data *ddata)
0274 {
0275     struct omap_dss_device *in = ddata->in;
0276     int r;
0277 
0278     if (!ddata->ulps_enabled)
0279         return 0;
0280 
0281     r = in->ops.dsi->enable(in);
0282     if (r) {
0283         dev_err(&ddata->pdev->dev, "failed to enable DSI\n");
0284         goto err1;
0285     }
0286 
0287     in->ops.dsi->enable_hs(in, ddata->channel, true);
0288 
0289     r = _dsicm_enable_te(ddata, true);
0290     if (r) {
0291         dev_err(&ddata->pdev->dev, "failed to re-enable TE");
0292         goto err2;
0293     }
0294 
0295     if (gpio_is_valid(ddata->ext_te_gpio))
0296         enable_irq(gpio_to_irq(ddata->ext_te_gpio));
0297 
0298     dsicm_queue_ulps_work(ddata);
0299 
0300     ddata->ulps_enabled = false;
0301 
0302     return 0;
0303 
0304 err2:
0305     dev_err(&ddata->pdev->dev, "failed to exit ULPS");
0306 
0307     r = dsicm_panel_reset(ddata);
0308     if (!r) {
0309         if (gpio_is_valid(ddata->ext_te_gpio))
0310             enable_irq(gpio_to_irq(ddata->ext_te_gpio));
0311         ddata->ulps_enabled = false;
0312     }
0313 err1:
0314     dsicm_queue_ulps_work(ddata);
0315 
0316     return r;
0317 }
0318 
0319 static int dsicm_wake_up(struct panel_drv_data *ddata)
0320 {
0321     if (ddata->ulps_enabled)
0322         return dsicm_exit_ulps(ddata);
0323 
0324     dsicm_cancel_ulps_work(ddata);
0325     dsicm_queue_ulps_work(ddata);
0326     return 0;
0327 }
0328 
0329 static int dsicm_bl_update_status(struct backlight_device *dev)
0330 {
0331     struct panel_drv_data *ddata = dev_get_drvdata(&dev->dev);
0332     struct omap_dss_device *in = ddata->in;
0333     int r;
0334     int level;
0335 
0336     if (dev->props.fb_blank == FB_BLANK_UNBLANK &&
0337             dev->props.power == FB_BLANK_UNBLANK)
0338         level = dev->props.brightness;
0339     else
0340         level = 0;
0341 
0342     dev_dbg(&ddata->pdev->dev, "update brightness to %d\n", level);
0343 
0344     mutex_lock(&ddata->lock);
0345 
0346     if (ddata->enabled) {
0347         in->ops.dsi->bus_lock(in);
0348 
0349         r = dsicm_wake_up(ddata);
0350         if (!r)
0351             r = dsicm_dcs_write_1(ddata, DCS_BRIGHTNESS, level);
0352 
0353         in->ops.dsi->bus_unlock(in);
0354     } else {
0355         r = 0;
0356     }
0357 
0358     mutex_unlock(&ddata->lock);
0359 
0360     return r;
0361 }
0362 
0363 static int dsicm_bl_get_intensity(struct backlight_device *dev)
0364 {
0365     if (dev->props.fb_blank == FB_BLANK_UNBLANK &&
0366             dev->props.power == FB_BLANK_UNBLANK)
0367         return dev->props.brightness;
0368 
0369     return 0;
0370 }
0371 
0372 static const struct backlight_ops dsicm_bl_ops = {
0373     .get_brightness = dsicm_bl_get_intensity,
0374     .update_status  = dsicm_bl_update_status,
0375 };
0376 
0377 static void dsicm_get_resolution(struct omap_dss_device *dssdev,
0378         u16 *xres, u16 *yres)
0379 {
0380     *xres = dssdev->panel.timings.x_res;
0381     *yres = dssdev->panel.timings.y_res;
0382 }
0383 
0384 static ssize_t dsicm_num_errors_show(struct device *dev,
0385         struct device_attribute *attr, char *buf)
0386 {
0387     struct panel_drv_data *ddata = dev_get_drvdata(dev);
0388     struct omap_dss_device *in = ddata->in;
0389     u8 errors = 0;
0390     int r;
0391 
0392     mutex_lock(&ddata->lock);
0393 
0394     if (ddata->enabled) {
0395         in->ops.dsi->bus_lock(in);
0396 
0397         r = dsicm_wake_up(ddata);
0398         if (!r)
0399             r = dsicm_dcs_read_1(ddata, DCS_READ_NUM_ERRORS,
0400                     &errors);
0401 
0402         in->ops.dsi->bus_unlock(in);
0403     } else {
0404         r = -ENODEV;
0405     }
0406 
0407     mutex_unlock(&ddata->lock);
0408 
0409     if (r)
0410         return r;
0411 
0412     return sysfs_emit(buf, "%d\n", errors);
0413 }
0414 
0415 static ssize_t dsicm_hw_revision_show(struct device *dev,
0416         struct device_attribute *attr, char *buf)
0417 {
0418     struct panel_drv_data *ddata = dev_get_drvdata(dev);
0419     struct omap_dss_device *in = ddata->in;
0420     u8 id1, id2, id3;
0421     int r;
0422 
0423     mutex_lock(&ddata->lock);
0424 
0425     if (ddata->enabled) {
0426         in->ops.dsi->bus_lock(in);
0427 
0428         r = dsicm_wake_up(ddata);
0429         if (!r)
0430             r = dsicm_get_id(ddata, &id1, &id2, &id3);
0431 
0432         in->ops.dsi->bus_unlock(in);
0433     } else {
0434         r = -ENODEV;
0435     }
0436 
0437     mutex_unlock(&ddata->lock);
0438 
0439     if (r)
0440         return r;
0441 
0442     return sysfs_emit(buf, "%02x.%02x.%02x\n", id1, id2, id3);
0443 }
0444 
0445 static ssize_t dsicm_store_ulps(struct device *dev,
0446         struct device_attribute *attr,
0447         const char *buf, size_t count)
0448 {
0449     struct panel_drv_data *ddata = dev_get_drvdata(dev);
0450     struct omap_dss_device *in = ddata->in;
0451     unsigned long t;
0452     int r;
0453 
0454     r = kstrtoul(buf, 0, &t);
0455     if (r)
0456         return r;
0457 
0458     mutex_lock(&ddata->lock);
0459 
0460     if (ddata->enabled) {
0461         in->ops.dsi->bus_lock(in);
0462 
0463         if (t)
0464             r = dsicm_enter_ulps(ddata);
0465         else
0466             r = dsicm_wake_up(ddata);
0467 
0468         in->ops.dsi->bus_unlock(in);
0469     }
0470 
0471     mutex_unlock(&ddata->lock);
0472 
0473     if (r)
0474         return r;
0475 
0476     return count;
0477 }
0478 
0479 static ssize_t dsicm_show_ulps(struct device *dev,
0480         struct device_attribute *attr,
0481         char *buf)
0482 {
0483     struct panel_drv_data *ddata = dev_get_drvdata(dev);
0484     unsigned t;
0485 
0486     mutex_lock(&ddata->lock);
0487     t = ddata->ulps_enabled;
0488     mutex_unlock(&ddata->lock);
0489 
0490     return sysfs_emit(buf, "%u\n", t);
0491 }
0492 
0493 static ssize_t dsicm_store_ulps_timeout(struct device *dev,
0494         struct device_attribute *attr,
0495         const char *buf, size_t count)
0496 {
0497     struct panel_drv_data *ddata = dev_get_drvdata(dev);
0498     struct omap_dss_device *in = ddata->in;
0499     unsigned long t;
0500     int r;
0501 
0502     r = kstrtoul(buf, 0, &t);
0503     if (r)
0504         return r;
0505 
0506     mutex_lock(&ddata->lock);
0507     ddata->ulps_timeout = t;
0508 
0509     if (ddata->enabled) {
0510         /* dsicm_wake_up will restart the timer */
0511         in->ops.dsi->bus_lock(in);
0512         r = dsicm_wake_up(ddata);
0513         in->ops.dsi->bus_unlock(in);
0514     }
0515 
0516     mutex_unlock(&ddata->lock);
0517 
0518     if (r)
0519         return r;
0520 
0521     return count;
0522 }
0523 
0524 static ssize_t dsicm_show_ulps_timeout(struct device *dev,
0525         struct device_attribute *attr,
0526         char *buf)
0527 {
0528     struct panel_drv_data *ddata = dev_get_drvdata(dev);
0529     unsigned t;
0530 
0531     mutex_lock(&ddata->lock);
0532     t = ddata->ulps_timeout;
0533     mutex_unlock(&ddata->lock);
0534 
0535     return sysfs_emit(buf, "%u\n", t);
0536 }
0537 
0538 static DEVICE_ATTR(num_dsi_errors, S_IRUGO, dsicm_num_errors_show, NULL);
0539 static DEVICE_ATTR(hw_revision, S_IRUGO, dsicm_hw_revision_show, NULL);
0540 static DEVICE_ATTR(ulps, S_IRUGO | S_IWUSR,
0541         dsicm_show_ulps, dsicm_store_ulps);
0542 static DEVICE_ATTR(ulps_timeout, S_IRUGO | S_IWUSR,
0543         dsicm_show_ulps_timeout, dsicm_store_ulps_timeout);
0544 
0545 static struct attribute *dsicm_attrs[] = {
0546     &dev_attr_num_dsi_errors.attr,
0547     &dev_attr_hw_revision.attr,
0548     &dev_attr_ulps.attr,
0549     &dev_attr_ulps_timeout.attr,
0550     NULL,
0551 };
0552 
0553 static const struct attribute_group dsicm_attr_group = {
0554     .attrs = dsicm_attrs,
0555 };
0556 
0557 static void dsicm_hw_reset(struct panel_drv_data *ddata)
0558 {
0559     if (!gpio_is_valid(ddata->reset_gpio))
0560         return;
0561 
0562     gpio_set_value(ddata->reset_gpio, 1);
0563     udelay(10);
0564     /* reset the panel */
0565     gpio_set_value(ddata->reset_gpio, 0);
0566     /* assert reset */
0567     udelay(10);
0568     gpio_set_value(ddata->reset_gpio, 1);
0569     /* wait after releasing reset */
0570     usleep_range(5000, 10000);
0571 }
0572 
0573 static int dsicm_power_on(struct panel_drv_data *ddata)
0574 {
0575     struct omap_dss_device *in = ddata->in;
0576     u8 id1, id2, id3;
0577     int r;
0578     struct omap_dss_dsi_config dsi_config = {
0579         .mode = OMAP_DSS_DSI_CMD_MODE,
0580         .pixel_format = OMAP_DSS_DSI_FMT_RGB888,
0581         .timings = &ddata->timings,
0582         .hs_clk_min = 150000000,
0583         .hs_clk_max = 300000000,
0584         .lp_clk_min = 7000000,
0585         .lp_clk_max = 10000000,
0586     };
0587 
0588     if (ddata->pin_config.num_pins > 0) {
0589         r = in->ops.dsi->configure_pins(in, &ddata->pin_config);
0590         if (r) {
0591             dev_err(&ddata->pdev->dev,
0592                 "failed to configure DSI pins\n");
0593             goto err0;
0594         }
0595     }
0596 
0597     r = in->ops.dsi->set_config(in, &dsi_config);
0598     if (r) {
0599         dev_err(&ddata->pdev->dev, "failed to configure DSI\n");
0600         goto err0;
0601     }
0602 
0603     r = in->ops.dsi->enable(in);
0604     if (r) {
0605         dev_err(&ddata->pdev->dev, "failed to enable DSI\n");
0606         goto err0;
0607     }
0608 
0609     dsicm_hw_reset(ddata);
0610 
0611     in->ops.dsi->enable_hs(in, ddata->channel, false);
0612 
0613     r = dsicm_sleep_out(ddata);
0614     if (r)
0615         goto err;
0616 
0617     r = dsicm_get_id(ddata, &id1, &id2, &id3);
0618     if (r)
0619         goto err;
0620 
0621     r = dsicm_dcs_write_1(ddata, DCS_BRIGHTNESS, 0xff);
0622     if (r)
0623         goto err;
0624 
0625     r = dsicm_dcs_write_1(ddata, DCS_CTRL_DISPLAY,
0626             (1<<2) | (1<<5));   /* BL | BCTRL */
0627     if (r)
0628         goto err;
0629 
0630     r = dsicm_dcs_write_1(ddata, MIPI_DCS_SET_PIXEL_FORMAT,
0631         MIPI_DCS_PIXEL_FMT_24BIT);
0632     if (r)
0633         goto err;
0634 
0635     r = dsicm_dcs_write_0(ddata, MIPI_DCS_SET_DISPLAY_ON);
0636     if (r)
0637         goto err;
0638 
0639     r = _dsicm_enable_te(ddata, ddata->te_enabled);
0640     if (r)
0641         goto err;
0642 
0643     r = in->ops.dsi->enable_video_output(in, ddata->channel);
0644     if (r)
0645         goto err;
0646 
0647     ddata->enabled = 1;
0648 
0649     if (!ddata->intro_printed) {
0650         dev_info(&ddata->pdev->dev, "panel revision %02x.%02x.%02x\n",
0651             id1, id2, id3);
0652         ddata->intro_printed = true;
0653     }
0654 
0655     in->ops.dsi->enable_hs(in, ddata->channel, true);
0656 
0657     return 0;
0658 err:
0659     dev_err(&ddata->pdev->dev, "error while enabling panel, issuing HW reset\n");
0660 
0661     dsicm_hw_reset(ddata);
0662 
0663     in->ops.dsi->disable(in, true, false);
0664 err0:
0665     return r;
0666 }
0667 
0668 static void dsicm_power_off(struct panel_drv_data *ddata)
0669 {
0670     struct omap_dss_device *in = ddata->in;
0671     int r;
0672 
0673     in->ops.dsi->disable_video_output(in, ddata->channel);
0674 
0675     r = dsicm_dcs_write_0(ddata, MIPI_DCS_SET_DISPLAY_OFF);
0676     if (!r)
0677         r = dsicm_sleep_in(ddata);
0678 
0679     if (r) {
0680         dev_err(&ddata->pdev->dev,
0681                 "error disabling panel, issuing HW reset\n");
0682         dsicm_hw_reset(ddata);
0683     }
0684 
0685     in->ops.dsi->disable(in, true, false);
0686 
0687     ddata->enabled = 0;
0688 }
0689 
0690 static int dsicm_panel_reset(struct panel_drv_data *ddata)
0691 {
0692     dev_err(&ddata->pdev->dev, "performing LCD reset\n");
0693 
0694     dsicm_power_off(ddata);
0695     dsicm_hw_reset(ddata);
0696     return dsicm_power_on(ddata);
0697 }
0698 
0699 static int dsicm_connect(struct omap_dss_device *dssdev)
0700 {
0701     struct panel_drv_data *ddata = to_panel_data(dssdev);
0702     struct omap_dss_device *in = ddata->in;
0703     struct device *dev = &ddata->pdev->dev;
0704     int r;
0705 
0706     if (omapdss_device_is_connected(dssdev))
0707         return 0;
0708 
0709     r = in->ops.dsi->connect(in, dssdev);
0710     if (r) {
0711         dev_err(dev, "Failed to connect to video source\n");
0712         return r;
0713     }
0714 
0715     r = in->ops.dsi->request_vc(ddata->in, &ddata->channel);
0716     if (r) {
0717         dev_err(dev, "failed to get virtual channel\n");
0718         goto err_req_vc;
0719     }
0720 
0721     r = in->ops.dsi->set_vc_id(ddata->in, ddata->channel, TCH);
0722     if (r) {
0723         dev_err(dev, "failed to set VC_ID\n");
0724         goto err_vc_id;
0725     }
0726 
0727     return 0;
0728 
0729 err_vc_id:
0730     in->ops.dsi->release_vc(ddata->in, ddata->channel);
0731 err_req_vc:
0732     in->ops.dsi->disconnect(in, dssdev);
0733     return r;
0734 }
0735 
0736 static void dsicm_disconnect(struct omap_dss_device *dssdev)
0737 {
0738     struct panel_drv_data *ddata = to_panel_data(dssdev);
0739     struct omap_dss_device *in = ddata->in;
0740 
0741     if (!omapdss_device_is_connected(dssdev))
0742         return;
0743 
0744     in->ops.dsi->release_vc(in, ddata->channel);
0745     in->ops.dsi->disconnect(in, dssdev);
0746 }
0747 
0748 static int dsicm_enable(struct omap_dss_device *dssdev)
0749 {
0750     struct panel_drv_data *ddata = to_panel_data(dssdev);
0751     struct omap_dss_device *in = ddata->in;
0752     int r;
0753 
0754     dev_dbg(&ddata->pdev->dev, "enable\n");
0755 
0756     mutex_lock(&ddata->lock);
0757 
0758     if (!omapdss_device_is_connected(dssdev)) {
0759         r = -ENODEV;
0760         goto err;
0761     }
0762 
0763     if (omapdss_device_is_enabled(dssdev)) {
0764         r = 0;
0765         goto err;
0766     }
0767 
0768     in->ops.dsi->bus_lock(in);
0769 
0770     r = dsicm_power_on(ddata);
0771 
0772     in->ops.dsi->bus_unlock(in);
0773 
0774     if (r)
0775         goto err;
0776 
0777     dssdev->state = OMAP_DSS_DISPLAY_ACTIVE;
0778 
0779     mutex_unlock(&ddata->lock);
0780 
0781     return 0;
0782 err:
0783     dev_dbg(&ddata->pdev->dev, "enable failed\n");
0784     mutex_unlock(&ddata->lock);
0785     return r;
0786 }
0787 
0788 static void dsicm_disable(struct omap_dss_device *dssdev)
0789 {
0790     struct panel_drv_data *ddata = to_panel_data(dssdev);
0791     struct omap_dss_device *in = ddata->in;
0792     int r;
0793 
0794     dev_dbg(&ddata->pdev->dev, "disable\n");
0795 
0796     mutex_lock(&ddata->lock);
0797 
0798     dsicm_cancel_ulps_work(ddata);
0799 
0800     in->ops.dsi->bus_lock(in);
0801 
0802     if (omapdss_device_is_enabled(dssdev)) {
0803         r = dsicm_wake_up(ddata);
0804         if (!r)
0805             dsicm_power_off(ddata);
0806     }
0807 
0808     in->ops.dsi->bus_unlock(in);
0809 
0810     dssdev->state = OMAP_DSS_DISPLAY_DISABLED;
0811 
0812     mutex_unlock(&ddata->lock);
0813 }
0814 
0815 static void dsicm_framedone_cb(int err, void *data)
0816 {
0817     struct panel_drv_data *ddata = data;
0818     struct omap_dss_device *in = ddata->in;
0819 
0820     dev_dbg(&ddata->pdev->dev, "framedone, err %d\n", err);
0821     in->ops.dsi->bus_unlock(ddata->in);
0822 }
0823 
0824 static irqreturn_t dsicm_te_isr(int irq, void *data)
0825 {
0826     struct panel_drv_data *ddata = data;
0827     struct omap_dss_device *in = ddata->in;
0828     int old;
0829     int r;
0830 
0831     old = atomic_cmpxchg(&ddata->do_update, 1, 0);
0832 
0833     if (old) {
0834         cancel_delayed_work(&ddata->te_timeout_work);
0835 
0836         r = in->ops.dsi->update(in, ddata->channel, dsicm_framedone_cb,
0837                 ddata);
0838         if (r)
0839             goto err;
0840     }
0841 
0842     return IRQ_HANDLED;
0843 err:
0844     dev_err(&ddata->pdev->dev, "start update failed\n");
0845     in->ops.dsi->bus_unlock(in);
0846     return IRQ_HANDLED;
0847 }
0848 
0849 static void dsicm_te_timeout_work_callback(struct work_struct *work)
0850 {
0851     struct panel_drv_data *ddata = container_of(work, struct panel_drv_data,
0852                     te_timeout_work.work);
0853     struct omap_dss_device *in = ddata->in;
0854 
0855     dev_err(&ddata->pdev->dev, "TE not received for 250ms!\n");
0856 
0857     atomic_set(&ddata->do_update, 0);
0858     in->ops.dsi->bus_unlock(in);
0859 }
0860 
0861 static int dsicm_update(struct omap_dss_device *dssdev,
0862                     u16 x, u16 y, u16 w, u16 h)
0863 {
0864     struct panel_drv_data *ddata = to_panel_data(dssdev);
0865     struct omap_dss_device *in = ddata->in;
0866     int r;
0867 
0868     dev_dbg(&ddata->pdev->dev, "update %d, %d, %d x %d\n", x, y, w, h);
0869 
0870     mutex_lock(&ddata->lock);
0871     in->ops.dsi->bus_lock(in);
0872 
0873     r = dsicm_wake_up(ddata);
0874     if (r)
0875         goto err;
0876 
0877     if (!ddata->enabled) {
0878         r = 0;
0879         goto err;
0880     }
0881 
0882     /* XXX no need to send this every frame, but dsi break if not done */
0883     r = dsicm_set_update_window(ddata, 0, 0,
0884             dssdev->panel.timings.x_res,
0885             dssdev->panel.timings.y_res);
0886     if (r)
0887         goto err;
0888 
0889     if (ddata->te_enabled && gpio_is_valid(ddata->ext_te_gpio)) {
0890         schedule_delayed_work(&ddata->te_timeout_work,
0891                 msecs_to_jiffies(250));
0892         atomic_set(&ddata->do_update, 1);
0893     } else {
0894         r = in->ops.dsi->update(in, ddata->channel, dsicm_framedone_cb,
0895                 ddata);
0896         if (r)
0897             goto err;
0898     }
0899 
0900     /* note: no bus_unlock here. unlock is in framedone_cb */
0901     mutex_unlock(&ddata->lock);
0902     return 0;
0903 err:
0904     in->ops.dsi->bus_unlock(in);
0905     mutex_unlock(&ddata->lock);
0906     return r;
0907 }
0908 
0909 static int dsicm_sync(struct omap_dss_device *dssdev)
0910 {
0911     struct panel_drv_data *ddata = to_panel_data(dssdev);
0912     struct omap_dss_device *in = ddata->in;
0913 
0914     dev_dbg(&ddata->pdev->dev, "sync\n");
0915 
0916     mutex_lock(&ddata->lock);
0917     in->ops.dsi->bus_lock(in);
0918     in->ops.dsi->bus_unlock(in);
0919     mutex_unlock(&ddata->lock);
0920 
0921     dev_dbg(&ddata->pdev->dev, "sync done\n");
0922 
0923     return 0;
0924 }
0925 
0926 static int _dsicm_enable_te(struct panel_drv_data *ddata, bool enable)
0927 {
0928     struct omap_dss_device *in = ddata->in;
0929     int r;
0930 
0931     if (enable)
0932         r = dsicm_dcs_write_1(ddata, MIPI_DCS_SET_TEAR_ON, 0);
0933     else
0934         r = dsicm_dcs_write_0(ddata, MIPI_DCS_SET_TEAR_OFF);
0935 
0936     if (!gpio_is_valid(ddata->ext_te_gpio))
0937         in->ops.dsi->enable_te(in, enable);
0938 
0939     /* possible panel bug */
0940     msleep(100);
0941 
0942     return r;
0943 }
0944 
0945 static int dsicm_enable_te(struct omap_dss_device *dssdev, bool enable)
0946 {
0947     struct panel_drv_data *ddata = to_panel_data(dssdev);
0948     struct omap_dss_device *in = ddata->in;
0949     int r;
0950 
0951     mutex_lock(&ddata->lock);
0952 
0953     if (ddata->te_enabled == enable)
0954         goto end;
0955 
0956     in->ops.dsi->bus_lock(in);
0957 
0958     if (ddata->enabled) {
0959         r = dsicm_wake_up(ddata);
0960         if (r)
0961             goto err;
0962 
0963         r = _dsicm_enable_te(ddata, enable);
0964         if (r)
0965             goto err;
0966     }
0967 
0968     ddata->te_enabled = enable;
0969 
0970     in->ops.dsi->bus_unlock(in);
0971 end:
0972     mutex_unlock(&ddata->lock);
0973 
0974     return 0;
0975 err:
0976     in->ops.dsi->bus_unlock(in);
0977     mutex_unlock(&ddata->lock);
0978 
0979     return r;
0980 }
0981 
0982 static int dsicm_get_te(struct omap_dss_device *dssdev)
0983 {
0984     struct panel_drv_data *ddata = to_panel_data(dssdev);
0985     int r;
0986 
0987     mutex_lock(&ddata->lock);
0988     r = ddata->te_enabled;
0989     mutex_unlock(&ddata->lock);
0990 
0991     return r;
0992 }
0993 
0994 static int dsicm_memory_read(struct omap_dss_device *dssdev,
0995         void *buf, size_t size,
0996         u16 x, u16 y, u16 w, u16 h)
0997 {
0998     struct panel_drv_data *ddata = to_panel_data(dssdev);
0999     struct omap_dss_device *in = ddata->in;
1000     int r;
1001     int first = 1;
1002     int plen;
1003     unsigned buf_used = 0;
1004 
1005     if (size < w * h * 3)
1006         return -ENOMEM;
1007 
1008     mutex_lock(&ddata->lock);
1009 
1010     if (!ddata->enabled) {
1011         r = -ENODEV;
1012         goto err1;
1013     }
1014 
1015     size = min(w * h * 3,
1016             dssdev->panel.timings.x_res *
1017             dssdev->panel.timings.y_res * 3);
1018 
1019     in->ops.dsi->bus_lock(in);
1020 
1021     r = dsicm_wake_up(ddata);
1022     if (r)
1023         goto err2;
1024 
1025     /* plen 1 or 2 goes into short packet. until checksum error is fixed,
1026      * use short packets. plen 32 works, but bigger packets seem to cause
1027      * an error. */
1028     if (size % 2)
1029         plen = 1;
1030     else
1031         plen = 2;
1032 
1033     dsicm_set_update_window(ddata, x, y, w, h);
1034 
1035     r = in->ops.dsi->set_max_rx_packet_size(in, ddata->channel, plen);
1036     if (r)
1037         goto err2;
1038 
1039     while (buf_used < size) {
1040         u8 dcs_cmd = first ? 0x2e : 0x3e;
1041         first = 0;
1042 
1043         r = in->ops.dsi->dcs_read(in, ddata->channel, dcs_cmd,
1044                 buf + buf_used, size - buf_used);
1045 
1046         if (r < 0) {
1047             dev_err(dssdev->dev, "read error\n");
1048             goto err3;
1049         }
1050 
1051         buf_used += r;
1052 
1053         if (r < plen) {
1054             dev_err(&ddata->pdev->dev, "short read\n");
1055             break;
1056         }
1057 
1058         if (signal_pending(current)) {
1059             dev_err(&ddata->pdev->dev, "signal pending, "
1060                     "aborting memory read\n");
1061             r = -ERESTARTSYS;
1062             goto err3;
1063         }
1064     }
1065 
1066     r = buf_used;
1067 
1068 err3:
1069     in->ops.dsi->set_max_rx_packet_size(in, ddata->channel, 1);
1070 err2:
1071     in->ops.dsi->bus_unlock(in);
1072 err1:
1073     mutex_unlock(&ddata->lock);
1074     return r;
1075 }
1076 
1077 static void dsicm_ulps_work(struct work_struct *work)
1078 {
1079     struct panel_drv_data *ddata = container_of(work, struct panel_drv_data,
1080             ulps_work.work);
1081     struct omap_dss_device *dssdev = &ddata->dssdev;
1082     struct omap_dss_device *in = ddata->in;
1083 
1084     mutex_lock(&ddata->lock);
1085 
1086     if (dssdev->state != OMAP_DSS_DISPLAY_ACTIVE || !ddata->enabled) {
1087         mutex_unlock(&ddata->lock);
1088         return;
1089     }
1090 
1091     in->ops.dsi->bus_lock(in);
1092 
1093     dsicm_enter_ulps(ddata);
1094 
1095     in->ops.dsi->bus_unlock(in);
1096     mutex_unlock(&ddata->lock);
1097 }
1098 
1099 static struct omap_dss_driver dsicm_ops = {
1100     .connect    = dsicm_connect,
1101     .disconnect = dsicm_disconnect,
1102 
1103     .enable     = dsicm_enable,
1104     .disable    = dsicm_disable,
1105 
1106     .update     = dsicm_update,
1107     .sync       = dsicm_sync,
1108 
1109     .get_resolution = dsicm_get_resolution,
1110     .get_recommended_bpp = omapdss_default_get_recommended_bpp,
1111 
1112     .enable_te  = dsicm_enable_te,
1113     .get_te     = dsicm_get_te,
1114 
1115     .memory_read    = dsicm_memory_read,
1116 };
1117 
1118 static int dsicm_probe_of(struct platform_device *pdev)
1119 {
1120     struct device_node *node = pdev->dev.of_node;
1121     struct panel_drv_data *ddata = platform_get_drvdata(pdev);
1122     struct omap_dss_device *in;
1123     int gpio;
1124 
1125     gpio = of_get_named_gpio(node, "reset-gpios", 0);
1126     if (!gpio_is_valid(gpio)) {
1127         dev_err(&pdev->dev, "failed to parse reset gpio\n");
1128         return gpio;
1129     }
1130     ddata->reset_gpio = gpio;
1131 
1132     gpio = of_get_named_gpio(node, "te-gpios", 0);
1133     if (gpio_is_valid(gpio) || gpio == -ENOENT) {
1134         ddata->ext_te_gpio = gpio;
1135     } else {
1136         dev_err(&pdev->dev, "failed to parse TE gpio\n");
1137         return gpio;
1138     }
1139 
1140     in = omapdss_of_find_source_for_first_ep(node);
1141     if (IS_ERR(in)) {
1142         dev_err(&pdev->dev, "failed to find video source\n");
1143         return PTR_ERR(in);
1144     }
1145 
1146     ddata->in = in;
1147 
1148     /* TODO: ulps, backlight */
1149 
1150     return 0;
1151 }
1152 
1153 static int dsicm_probe(struct platform_device *pdev)
1154 {
1155     struct backlight_properties props;
1156     struct panel_drv_data *ddata;
1157     struct backlight_device *bldev = NULL;
1158     struct device *dev = &pdev->dev;
1159     struct omap_dss_device *dssdev;
1160     int r;
1161 
1162     dev_dbg(dev, "probe\n");
1163 
1164     if (!pdev->dev.of_node)
1165         return -ENODEV;
1166 
1167     ddata = devm_kzalloc(dev, sizeof(*ddata), GFP_KERNEL);
1168     if (!ddata)
1169         return -ENOMEM;
1170 
1171     platform_set_drvdata(pdev, ddata);
1172     ddata->pdev = pdev;
1173 
1174     r = dsicm_probe_of(pdev);
1175     if (r)
1176         return r;
1177 
1178     ddata->timings.x_res = 864;
1179     ddata->timings.y_res = 480;
1180     ddata->timings.pixelclock = 864 * 480 * 60;
1181 
1182     dssdev = &ddata->dssdev;
1183     dssdev->dev = dev;
1184     dssdev->driver = &dsicm_ops;
1185     dssdev->panel.timings = ddata->timings;
1186     dssdev->type = OMAP_DISPLAY_TYPE_DSI;
1187     dssdev->owner = THIS_MODULE;
1188 
1189     dssdev->panel.dsi_pix_fmt = OMAP_DSS_DSI_FMT_RGB888;
1190     dssdev->caps = OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE |
1191         OMAP_DSS_DISPLAY_CAP_TEAR_ELIM;
1192 
1193     r = omapdss_register_display(dssdev);
1194     if (r) {
1195         dev_err(dev, "Failed to register panel\n");
1196         goto err_reg;
1197     }
1198 
1199     mutex_init(&ddata->lock);
1200 
1201     atomic_set(&ddata->do_update, 0);
1202 
1203     if (gpio_is_valid(ddata->reset_gpio)) {
1204         r = devm_gpio_request_one(dev, ddata->reset_gpio,
1205                 GPIOF_OUT_INIT_LOW, "taal rst");
1206         if (r) {
1207             dev_err(dev, "failed to request reset gpio\n");
1208             return r;
1209         }
1210     }
1211 
1212     if (gpio_is_valid(ddata->ext_te_gpio)) {
1213         r = devm_gpio_request_one(dev, ddata->ext_te_gpio,
1214                 GPIOF_IN, "taal irq");
1215         if (r) {
1216             dev_err(dev, "GPIO request failed\n");
1217             return r;
1218         }
1219 
1220         r = devm_request_irq(dev, gpio_to_irq(ddata->ext_te_gpio),
1221                 dsicm_te_isr,
1222                 IRQF_TRIGGER_RISING,
1223                 "taal vsync", ddata);
1224 
1225         if (r) {
1226             dev_err(dev, "IRQ request failed\n");
1227             return r;
1228         }
1229 
1230         INIT_DEFERRABLE_WORK(&ddata->te_timeout_work,
1231                     dsicm_te_timeout_work_callback);
1232 
1233         dev_dbg(dev, "Using GPIO TE\n");
1234     }
1235 
1236     INIT_DELAYED_WORK(&ddata->ulps_work, dsicm_ulps_work);
1237 
1238     dsicm_hw_reset(ddata);
1239 
1240     if (ddata->use_dsi_backlight) {
1241         memset(&props, 0, sizeof(struct backlight_properties));
1242         props.max_brightness = 255;
1243 
1244         props.type = BACKLIGHT_RAW;
1245         bldev = backlight_device_register(dev_name(dev),
1246                 dev, ddata, &dsicm_bl_ops, &props);
1247         if (IS_ERR(bldev)) {
1248             r = PTR_ERR(bldev);
1249             goto err_reg;
1250         }
1251 
1252         ddata->bldev = bldev;
1253 
1254         bldev->props.fb_blank = FB_BLANK_UNBLANK;
1255         bldev->props.power = FB_BLANK_UNBLANK;
1256         bldev->props.brightness = 255;
1257 
1258         dsicm_bl_update_status(bldev);
1259     }
1260 
1261     r = sysfs_create_group(&dev->kobj, &dsicm_attr_group);
1262     if (r) {
1263         dev_err(dev, "failed to create sysfs files\n");
1264         goto err_sysfs_create;
1265     }
1266 
1267     return 0;
1268 
1269 err_sysfs_create:
1270     if (bldev != NULL)
1271         backlight_device_unregister(bldev);
1272 err_reg:
1273     return r;
1274 }
1275 
1276 static int __exit dsicm_remove(struct platform_device *pdev)
1277 {
1278     struct panel_drv_data *ddata = platform_get_drvdata(pdev);
1279     struct omap_dss_device *dssdev = &ddata->dssdev;
1280     struct backlight_device *bldev;
1281 
1282     dev_dbg(&pdev->dev, "remove\n");
1283 
1284     omapdss_unregister_display(dssdev);
1285 
1286     dsicm_disable(dssdev);
1287     dsicm_disconnect(dssdev);
1288 
1289     sysfs_remove_group(&pdev->dev.kobj, &dsicm_attr_group);
1290 
1291     bldev = ddata->bldev;
1292     if (bldev != NULL) {
1293         bldev->props.power = FB_BLANK_POWERDOWN;
1294         dsicm_bl_update_status(bldev);
1295         backlight_device_unregister(bldev);
1296     }
1297 
1298     omap_dss_put_device(ddata->in);
1299 
1300     dsicm_cancel_ulps_work(ddata);
1301 
1302     /* reset, to be sure that the panel is in a valid state */
1303     dsicm_hw_reset(ddata);
1304 
1305     return 0;
1306 }
1307 
1308 static const struct of_device_id dsicm_of_match[] = {
1309     { .compatible = "omapdss,panel-dsi-cm", },
1310     {},
1311 };
1312 
1313 MODULE_DEVICE_TABLE(of, dsicm_of_match);
1314 
1315 static struct platform_driver dsicm_driver = {
1316     .probe = dsicm_probe,
1317     .remove = __exit_p(dsicm_remove),
1318     .driver = {
1319         .name = "panel-dsi-cm",
1320         .of_match_table = dsicm_of_match,
1321         .suppress_bind_attrs = true,
1322     },
1323 };
1324 
1325 module_platform_driver(dsicm_driver);
1326 
1327 MODULE_AUTHOR("Tomi Valkeinen <tomi.valkeinen@ti.com>");
1328 MODULE_DESCRIPTION("Generic DSI Command Mode Panel Driver");
1329 MODULE_LICENSE("GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!