2 * Taal DSI command mode panel
4 * Copyright (C) 2009 Nokia Corporation
5 * Author: Tomi Valkeinen <tomi.valkeinen@nokia.com>
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.
11 * This program is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
16 * You should have received a copy of the GNU General Public License along with
17 * this program. If not, see <http://www.gnu.org/licenses/>.
22 #include <linux/module.h>
23 #include <linux/delay.h>
24 #include <linux/err.h>
25 #include <linux/jiffies.h>
26 #include <linux/sched.h>
27 #include <linux/backlight.h>
29 #include <linux/interrupt.h>
30 #include <linux/gpio.h>
31 #include <linux/workqueue.h>
32 #include <linux/slab.h>
33 #include <linux/regulator/consumer.h>
34 #include <linux/mutex.h>
36 #include <video/omapdss.h>
37 #include <video/omap-panel-nokia-dsi.h>
39 /* DSI Virtual channel. Hardcoded for now. */
42 #define DCS_READ_NUM_ERRORS 0x05
43 #define DCS_READ_POWER_MODE 0x0a
44 #define DCS_READ_MADCTL 0x0b
45 #define DCS_READ_PIXEL_FORMAT 0x0c
46 #define DCS_RDDSDR 0x0f
47 #define DCS_SLEEP_IN 0x10
48 #define DCS_SLEEP_OUT 0x11
49 #define DCS_DISPLAY_OFF 0x28
50 #define DCS_DISPLAY_ON 0x29
51 #define DCS_COLUMN_ADDR 0x2a
52 #define DCS_PAGE_ADDR 0x2b
53 #define DCS_MEMORY_WRITE 0x2c
54 #define DCS_TEAR_OFF 0x34
55 #define DCS_TEAR_ON 0x35
56 #define DCS_MEM_ACC_CTRL 0x36
57 #define DCS_PIXEL_FORMAT 0x3a
58 #define DCS_BRIGHTNESS 0x51
59 #define DCS_CTRL_DISPLAY 0x53
60 #define DCS_WRITE_CABC 0x55
61 #define DCS_READ_CABC 0x56
62 #define DCS_GET_ID1 0xda
63 #define DCS_GET_ID2 0xdb
64 #define DCS_GET_ID3 0xdc
66 static irqreturn_t taal_te_isr(int irq, void *data);
67 static void taal_te_timeout_work_callback(struct work_struct *work);
68 static int _taal_enable_te(struct omap_dss_device *dssdev, bool enable);
70 struct panel_regulator {
71 struct regulator *regulator;
77 static void free_regulators(struct panel_regulator *regulators, int n)
81 for (i = 0; i < n; i++) {
82 /* disable/put in reverse order */
83 regulator_disable(regulators[n - i - 1].regulator);
84 regulator_put(regulators[n - i - 1].regulator);
88 static int init_regulators(struct omap_dss_device *dssdev,
89 struct panel_regulator *regulators, int n)
93 for (i = 0; i < n; i++) {
94 struct regulator *reg;
96 reg = regulator_get(&dssdev->dev, regulators[i].name);
98 dev_err(&dssdev->dev, "failed to get regulator %s\n",
104 /* FIXME: better handling of fixed vs. variable regulators */
105 v = regulator_get_voltage(reg);
106 if (v < regulators[i].min_uV || v > regulators[i].max_uV) {
107 r = regulator_set_voltage(reg, regulators[i].min_uV,
108 regulators[i].max_uV);
110 dev_err(&dssdev->dev,
111 "failed to set regulator %s voltage\n",
118 r = regulator_enable(reg);
120 dev_err(&dssdev->dev, "failed to enable regulator %s\n",
126 regulators[i].regulator = reg;
132 free_regulators(regulators, i);
138 * struct panel_config - panel configuration
141 * @timings: panel resolution
142 * @sleep: various panel specific delays, passed to msleep() if non-zero
143 * @reset_sequence: reset sequence timings, passed to udelay() if non-zero
144 * @regulators: array of panel regulators
145 * @num_regulators: number of regulators in the array
147 struct panel_config {
151 struct omap_video_timings timings;
154 unsigned int sleep_in;
155 unsigned int sleep_out;
156 unsigned int hw_reset;
157 unsigned int enable_te;
165 struct panel_regulator *regulators;
173 static struct panel_config panel_configs[] = {
185 .enable_te = 100, /* possible panel bug */
197 struct backlight_device *bldev;
199 unsigned long hw_guard_end; /* next value of jiffies when we can
200 * issue the next sleep in/out command
202 unsigned long hw_guard_wait; /* max guard time in jiffies */
204 struct omap_dss_device *dssdev;
221 struct delayed_work te_timeout_work;
230 struct workqueue_struct *esd_wq;
231 struct delayed_work esd_work;
232 unsigned esd_interval;
234 struct panel_config *panel_config;
237 static inline struct nokia_dsi_panel_data
238 *get_panel_data(const struct omap_dss_device *dssdev)
240 return (struct nokia_dsi_panel_data *) dssdev->data;
243 static void taal_esd_work(struct work_struct *work);
245 static void hw_guard_start(struct taal_data *td, int guard_msec)
247 td->hw_guard_wait = msecs_to_jiffies(guard_msec);
248 td->hw_guard_end = jiffies + td->hw_guard_wait;
251 static void hw_guard_wait(struct taal_data *td)
253 unsigned long wait = td->hw_guard_end - jiffies;
255 if ((long)wait > 0 && wait <= td->hw_guard_wait) {
256 set_current_state(TASK_UNINTERRUPTIBLE);
257 schedule_timeout(wait);
261 static int taal_dcs_read_1(struct taal_data *td, u8 dcs_cmd, u8 *data)
266 r = dsi_vc_dcs_read(td->channel, dcs_cmd, buf, 1);
276 static int taal_dcs_write_0(struct taal_data *td, u8 dcs_cmd)
278 return dsi_vc_dcs_write(td->channel, &dcs_cmd, 1);
281 static int taal_dcs_write_1(struct taal_data *td, u8 dcs_cmd, u8 param)
286 return dsi_vc_dcs_write(td->channel, buf, 2);
289 static int taal_sleep_in(struct taal_data *td)
298 r = dsi_vc_dcs_write_nosync(td->channel, &cmd, 1);
302 hw_guard_start(td, 120);
304 if (td->panel_config->sleep.sleep_in)
305 msleep(td->panel_config->sleep.sleep_in);
310 static int taal_sleep_out(struct taal_data *td)
316 r = taal_dcs_write_0(td, DCS_SLEEP_OUT);
320 hw_guard_start(td, 120);
322 if (td->panel_config->sleep.sleep_out)
323 msleep(td->panel_config->sleep.sleep_out);
328 static int taal_get_id(struct taal_data *td, u8 *id1, u8 *id2, u8 *id3)
332 r = taal_dcs_read_1(td, DCS_GET_ID1, id1);
335 r = taal_dcs_read_1(td, DCS_GET_ID2, id2);
338 r = taal_dcs_read_1(td, DCS_GET_ID3, id3);
345 static int taal_set_addr_mode(struct taal_data *td, u8 rotate, bool mirror)
351 r = taal_dcs_read_1(td, DCS_READ_MADCTL, &mode);
382 mode &= ~((1<<7) | (1<<6) | (1<<5));
383 mode |= (b7 << 7) | (b6 << 6) | (b5 << 5);
385 return taal_dcs_write_1(td, DCS_MEM_ACC_CTRL, mode);
388 static int taal_set_update_window(struct taal_data *td,
389 u16 x, u16 y, u16 w, u16 h)
398 buf[0] = DCS_COLUMN_ADDR;
399 buf[1] = (x1 >> 8) & 0xff;
400 buf[2] = (x1 >> 0) & 0xff;
401 buf[3] = (x2 >> 8) & 0xff;
402 buf[4] = (x2 >> 0) & 0xff;
404 r = dsi_vc_dcs_write_nosync(td->channel, buf, sizeof(buf));
408 buf[0] = DCS_PAGE_ADDR;
409 buf[1] = (y1 >> 8) & 0xff;
410 buf[2] = (y1 >> 0) & 0xff;
411 buf[3] = (y2 >> 8) & 0xff;
412 buf[4] = (y2 >> 0) & 0xff;
414 r = dsi_vc_dcs_write_nosync(td->channel, buf, sizeof(buf));
418 dsi_vc_send_bta_sync(td->channel);
423 static void taal_queue_esd_work(struct omap_dss_device *dssdev)
425 struct taal_data *td = dev_get_drvdata(&dssdev->dev);
427 if (td->esd_interval > 0)
428 queue_delayed_work(td->esd_wq, &td->esd_work,
429 msecs_to_jiffies(td->esd_interval));
432 static void taal_cancel_esd_work(struct omap_dss_device *dssdev)
434 struct taal_data *td = dev_get_drvdata(&dssdev->dev);
436 cancel_delayed_work(&td->esd_work);
439 static int taal_bl_update_status(struct backlight_device *dev)
441 struct omap_dss_device *dssdev = dev_get_drvdata(&dev->dev);
442 struct taal_data *td = dev_get_drvdata(&dssdev->dev);
443 struct nokia_dsi_panel_data *panel_data = get_panel_data(dssdev);
447 if (dev->props.fb_blank == FB_BLANK_UNBLANK &&
448 dev->props.power == FB_BLANK_UNBLANK)
449 level = dev->props.brightness;
453 dev_dbg(&dssdev->dev, "update brightness to %d\n", level);
455 mutex_lock(&td->lock);
457 if (td->use_dsi_bl) {
460 r = taal_dcs_write_1(td, DCS_BRIGHTNESS, level);
466 if (!panel_data->set_backlight)
469 r = panel_data->set_backlight(dssdev, level);
472 mutex_unlock(&td->lock);
477 static int taal_bl_get_intensity(struct backlight_device *dev)
479 if (dev->props.fb_blank == FB_BLANK_UNBLANK &&
480 dev->props.power == FB_BLANK_UNBLANK)
481 return dev->props.brightness;
486 static const struct backlight_ops taal_bl_ops = {
487 .get_brightness = taal_bl_get_intensity,
488 .update_status = taal_bl_update_status,
491 static void taal_get_timings(struct omap_dss_device *dssdev,
492 struct omap_video_timings *timings)
494 *timings = dssdev->panel.timings;
497 static void taal_get_resolution(struct omap_dss_device *dssdev,
498 u16 *xres, u16 *yres)
500 struct taal_data *td = dev_get_drvdata(&dssdev->dev);
502 if (td->rotate == 0 || td->rotate == 2) {
503 *xres = dssdev->panel.timings.x_res;
504 *yres = dssdev->panel.timings.y_res;
506 *yres = dssdev->panel.timings.x_res;
507 *xres = dssdev->panel.timings.y_res;
511 static ssize_t taal_num_errors_show(struct device *dev,
512 struct device_attribute *attr, char *buf)
514 struct omap_dss_device *dssdev = to_dss_device(dev);
515 struct taal_data *td = dev_get_drvdata(&dssdev->dev);
519 mutex_lock(&td->lock);
523 r = taal_dcs_read_1(td, DCS_READ_NUM_ERRORS, &errors);
529 mutex_unlock(&td->lock);
534 return snprintf(buf, PAGE_SIZE, "%d\n", errors);
537 static ssize_t taal_hw_revision_show(struct device *dev,
538 struct device_attribute *attr, char *buf)
540 struct omap_dss_device *dssdev = to_dss_device(dev);
541 struct taal_data *td = dev_get_drvdata(&dssdev->dev);
545 mutex_lock(&td->lock);
549 r = taal_get_id(td, &id1, &id2, &id3);
555 mutex_unlock(&td->lock);
560 return snprintf(buf, PAGE_SIZE, "%02x.%02x.%02x\n", id1, id2, id3);
563 static const char *cabc_modes[] = {
564 "off", /* used also always when CABC is not supported */
570 static ssize_t show_cabc_mode(struct device *dev,
571 struct device_attribute *attr,
574 struct omap_dss_device *dssdev = to_dss_device(dev);
575 struct taal_data *td = dev_get_drvdata(&dssdev->dev);
576 const char *mode_str;
580 mode = td->cabc_mode;
582 mode_str = "unknown";
583 if (mode >= 0 && mode < ARRAY_SIZE(cabc_modes))
584 mode_str = cabc_modes[mode];
585 len = snprintf(buf, PAGE_SIZE, "%s\n", mode_str);
587 return len < PAGE_SIZE - 1 ? len : PAGE_SIZE - 1;
590 static ssize_t store_cabc_mode(struct device *dev,
591 struct device_attribute *attr,
592 const char *buf, size_t count)
594 struct omap_dss_device *dssdev = to_dss_device(dev);
595 struct taal_data *td = dev_get_drvdata(&dssdev->dev);
598 for (i = 0; i < ARRAY_SIZE(cabc_modes); i++) {
599 if (sysfs_streq(cabc_modes[i], buf))
603 if (i == ARRAY_SIZE(cabc_modes))
606 mutex_lock(&td->lock);
610 if (!td->cabc_broken)
611 taal_dcs_write_1(td, DCS_WRITE_CABC, i);
617 mutex_unlock(&td->lock);
622 static ssize_t show_cabc_available_modes(struct device *dev,
623 struct device_attribute *attr,
630 len < PAGE_SIZE && i < ARRAY_SIZE(cabc_modes); i++)
631 len += snprintf(&buf[len], PAGE_SIZE - len, "%s%s%s",
632 i ? " " : "", cabc_modes[i],
633 i == ARRAY_SIZE(cabc_modes) - 1 ? "\n" : "");
635 return len < PAGE_SIZE ? len : PAGE_SIZE - 1;
638 static ssize_t taal_store_esd_interval(struct device *dev,
639 struct device_attribute *attr,
640 const char *buf, size_t count)
642 struct omap_dss_device *dssdev = to_dss_device(dev);
643 struct taal_data *td = dev_get_drvdata(&dssdev->dev);
648 r = strict_strtoul(buf, 10, &t);
652 mutex_lock(&td->lock);
653 taal_cancel_esd_work(dssdev);
654 td->esd_interval = t;
656 taal_queue_esd_work(dssdev);
657 mutex_unlock(&td->lock);
662 static ssize_t taal_show_esd_interval(struct device *dev,
663 struct device_attribute *attr,
666 struct omap_dss_device *dssdev = to_dss_device(dev);
667 struct taal_data *td = dev_get_drvdata(&dssdev->dev);
670 mutex_lock(&td->lock);
671 t = td->esd_interval;
672 mutex_unlock(&td->lock);
674 return snprintf(buf, PAGE_SIZE, "%u\n", t);
677 static DEVICE_ATTR(num_dsi_errors, S_IRUGO, taal_num_errors_show, NULL);
678 static DEVICE_ATTR(hw_revision, S_IRUGO, taal_hw_revision_show, NULL);
679 static DEVICE_ATTR(cabc_mode, S_IRUGO | S_IWUSR,
680 show_cabc_mode, store_cabc_mode);
681 static DEVICE_ATTR(cabc_available_modes, S_IRUGO,
682 show_cabc_available_modes, NULL);
683 static DEVICE_ATTR(esd_interval, S_IRUGO | S_IWUSR,
684 taal_show_esd_interval, taal_store_esd_interval);
686 static struct attribute *taal_attrs[] = {
687 &dev_attr_num_dsi_errors.attr,
688 &dev_attr_hw_revision.attr,
689 &dev_attr_cabc_mode.attr,
690 &dev_attr_cabc_available_modes.attr,
691 &dev_attr_esd_interval.attr,
695 static struct attribute_group taal_attr_group = {
699 static void taal_hw_reset(struct omap_dss_device *dssdev)
701 struct taal_data *td = dev_get_drvdata(&dssdev->dev);
702 struct nokia_dsi_panel_data *panel_data = get_panel_data(dssdev);
704 if (panel_data->reset_gpio == -1)
707 gpio_set_value(panel_data->reset_gpio, 1);
708 if (td->panel_config->reset_sequence.high)
709 udelay(td->panel_config->reset_sequence.high);
710 /* reset the panel */
711 gpio_set_value(panel_data->reset_gpio, 0);
713 if (td->panel_config->reset_sequence.low)
714 udelay(td->panel_config->reset_sequence.low);
715 gpio_set_value(panel_data->reset_gpio, 1);
716 /* wait after releasing reset */
717 if (td->panel_config->sleep.hw_reset)
718 msleep(td->panel_config->sleep.hw_reset);
721 static int taal_probe(struct omap_dss_device *dssdev)
723 struct backlight_properties props;
724 struct taal_data *td;
725 struct backlight_device *bldev;
726 struct nokia_dsi_panel_data *panel_data = get_panel_data(dssdev);
727 struct panel_config *panel_config = NULL;
730 dev_dbg(&dssdev->dev, "probe\n");
732 if (!panel_data || !panel_data->name) {
737 for (i = 0; i < ARRAY_SIZE(panel_configs); i++) {
738 if (strcmp(panel_data->name, panel_configs[i].name) == 0) {
739 panel_config = &panel_configs[i];
749 dssdev->panel.config = OMAP_DSS_LCD_TFT;
750 dssdev->panel.timings = panel_config->timings;
751 dssdev->ctrl.pixel_size = 24;
753 td = kzalloc(sizeof(*td), GFP_KERNEL);
759 td->panel_config = panel_config;
760 td->esd_interval = panel_data->esd_interval;
762 mutex_init(&td->lock);
764 atomic_set(&td->do_update, 0);
766 r = init_regulators(dssdev, panel_config->regulators,
767 panel_config->num_regulators);
771 td->esd_wq = create_singlethread_workqueue("taal_esd");
772 if (td->esd_wq == NULL) {
773 dev_err(&dssdev->dev, "can't create ESD workqueue\n");
777 INIT_DELAYED_WORK_DEFERRABLE(&td->esd_work, taal_esd_work);
779 dev_set_drvdata(&dssdev->dev, td);
781 taal_hw_reset(dssdev);
783 /* if no platform set_backlight() defined, presume DSI backlight
785 memset(&props, 0, sizeof(struct backlight_properties));
786 if (!panel_data->set_backlight)
787 td->use_dsi_bl = true;
790 props.max_brightness = 255;
792 props.max_brightness = 127;
794 props.type = BACKLIGHT_RAW;
795 bldev = backlight_device_register("taal", &dssdev->dev, dssdev,
796 &taal_bl_ops, &props);
804 bldev->props.fb_blank = FB_BLANK_UNBLANK;
805 bldev->props.power = FB_BLANK_UNBLANK;
807 bldev->props.brightness = 255;
809 bldev->props.brightness = 127;
811 taal_bl_update_status(bldev);
813 if (panel_data->use_ext_te) {
814 int gpio = panel_data->ext_te_gpio;
816 r = gpio_request(gpio, "taal irq");
818 dev_err(&dssdev->dev, "GPIO request failed\n");
822 gpio_direction_input(gpio);
824 r = request_irq(gpio_to_irq(gpio), taal_te_isr,
825 IRQF_DISABLED | IRQF_TRIGGER_RISING,
826 "taal vsync", dssdev);
829 dev_err(&dssdev->dev, "IRQ request failed\n");
834 INIT_DELAYED_WORK_DEFERRABLE(&td->te_timeout_work,
835 taal_te_timeout_work_callback);
837 dev_dbg(&dssdev->dev, "Using GPIO TE\n");
840 r = omap_dsi_request_vc(dssdev, &td->channel);
842 dev_err(&dssdev->dev, "failed to get virtual channel\n");
846 r = omap_dsi_set_vc_id(dssdev, td->channel, TCH);
848 dev_err(&dssdev->dev, "failed to set VC_ID\n");
852 r = sysfs_create_group(&dssdev->dev.kobj, &taal_attr_group);
854 dev_err(&dssdev->dev, "failed to create sysfs files\n");
861 omap_dsi_release_vc(dssdev, td->channel);
863 if (panel_data->use_ext_te)
864 free_irq(gpio_to_irq(panel_data->ext_te_gpio), dssdev);
866 if (panel_data->use_ext_te)
867 gpio_free(panel_data->ext_te_gpio);
869 backlight_device_unregister(bldev);
871 destroy_workqueue(td->esd_wq);
873 free_regulators(panel_config->regulators, panel_config->num_regulators);
880 static void __exit taal_remove(struct omap_dss_device *dssdev)
882 struct taal_data *td = dev_get_drvdata(&dssdev->dev);
883 struct nokia_dsi_panel_data *panel_data = get_panel_data(dssdev);
884 struct backlight_device *bldev;
886 dev_dbg(&dssdev->dev, "remove\n");
888 sysfs_remove_group(&dssdev->dev.kobj, &taal_attr_group);
889 omap_dsi_release_vc(dssdev, td->channel);
891 if (panel_data->use_ext_te) {
892 int gpio = panel_data->ext_te_gpio;
893 free_irq(gpio_to_irq(gpio), dssdev);
898 bldev->props.power = FB_BLANK_POWERDOWN;
899 taal_bl_update_status(bldev);
900 backlight_device_unregister(bldev);
902 taal_cancel_esd_work(dssdev);
903 destroy_workqueue(td->esd_wq);
905 /* reset, to be sure that the panel is in a valid state */
906 taal_hw_reset(dssdev);
908 free_regulators(td->panel_config->regulators,
909 td->panel_config->num_regulators);
914 static int taal_power_on(struct omap_dss_device *dssdev)
916 struct taal_data *td = dev_get_drvdata(&dssdev->dev);
920 r = omapdss_dsi_display_enable(dssdev);
922 dev_err(&dssdev->dev, "failed to enable DSI\n");
926 taal_hw_reset(dssdev);
928 omapdss_dsi_vc_enable_hs(td->channel, false);
930 r = taal_sleep_out(td);
934 r = taal_get_id(td, &id1, &id2, &id3);
938 /* on early Taal revisions CABC is broken */
939 if (td->panel_config->type == PANEL_TAAL &&
940 (id2 == 0x00 || id2 == 0xff || id2 == 0x81))
941 td->cabc_broken = true;
943 r = taal_dcs_write_1(td, DCS_BRIGHTNESS, 0xff);
947 r = taal_dcs_write_1(td, DCS_CTRL_DISPLAY,
948 (1<<2) | (1<<5)); /* BL | BCTRL */
952 r = taal_dcs_write_1(td, DCS_PIXEL_FORMAT, 0x7); /* 24bit/pixel */
956 r = taal_set_addr_mode(td, td->rotate, td->mirror);
960 if (!td->cabc_broken) {
961 r = taal_dcs_write_1(td, DCS_WRITE_CABC, td->cabc_mode);
966 r = taal_dcs_write_0(td, DCS_DISPLAY_ON);
970 r = _taal_enable_te(dssdev, td->te_enabled);
976 if (!td->intro_printed) {
977 dev_info(&dssdev->dev, "%s panel revision %02x.%02x.%02x\n",
978 td->panel_config->name, id1, id2, id3);
980 dev_info(&dssdev->dev,
981 "old Taal version, CABC disabled\n");
982 td->intro_printed = true;
985 omapdss_dsi_vc_enable_hs(td->channel, true);
989 dev_err(&dssdev->dev, "error while enabling panel, issuing HW reset\n");
991 taal_hw_reset(dssdev);
993 omapdss_dsi_display_disable(dssdev, true, false);
998 static void taal_power_off(struct omap_dss_device *dssdev)
1000 struct taal_data *td = dev_get_drvdata(&dssdev->dev);
1003 r = taal_dcs_write_0(td, DCS_DISPLAY_OFF);
1005 r = taal_sleep_in(td);
1006 /* HACK: wait a bit so that the message goes through */
1011 dev_err(&dssdev->dev,
1012 "error disabling panel, issuing HW reset\n");
1013 taal_hw_reset(dssdev);
1016 omapdss_dsi_display_disable(dssdev, true, false);
1021 static int taal_panel_reset(struct omap_dss_device *dssdev)
1023 dev_err(&dssdev->dev, "performing LCD reset\n");
1025 taal_power_off(dssdev);
1026 taal_hw_reset(dssdev);
1027 return taal_power_on(dssdev);
1030 static int taal_enable(struct omap_dss_device *dssdev)
1032 struct taal_data *td = dev_get_drvdata(&dssdev->dev);
1035 dev_dbg(&dssdev->dev, "enable\n");
1037 mutex_lock(&td->lock);
1039 if (dssdev->state != OMAP_DSS_DISPLAY_DISABLED) {
1046 r = taal_power_on(dssdev);
1053 taal_queue_esd_work(dssdev);
1055 dssdev->state = OMAP_DSS_DISPLAY_ACTIVE;
1057 mutex_unlock(&td->lock);
1061 dev_dbg(&dssdev->dev, "enable failed\n");
1062 mutex_unlock(&td->lock);
1066 static void taal_disable(struct omap_dss_device *dssdev)
1068 struct taal_data *td = dev_get_drvdata(&dssdev->dev);
1070 dev_dbg(&dssdev->dev, "disable\n");
1072 mutex_lock(&td->lock);
1074 taal_cancel_esd_work(dssdev);
1078 if (dssdev->state == OMAP_DSS_DISPLAY_ACTIVE)
1079 taal_power_off(dssdev);
1083 dssdev->state = OMAP_DSS_DISPLAY_DISABLED;
1085 mutex_unlock(&td->lock);
1088 static int taal_suspend(struct omap_dss_device *dssdev)
1090 struct taal_data *td = dev_get_drvdata(&dssdev->dev);
1093 dev_dbg(&dssdev->dev, "suspend\n");
1095 mutex_lock(&td->lock);
1097 if (dssdev->state != OMAP_DSS_DISPLAY_ACTIVE) {
1102 taal_cancel_esd_work(dssdev);
1106 taal_power_off(dssdev);
1110 dssdev->state = OMAP_DSS_DISPLAY_SUSPENDED;
1112 mutex_unlock(&td->lock);
1116 mutex_unlock(&td->lock);
1120 static int taal_resume(struct omap_dss_device *dssdev)
1122 struct taal_data *td = dev_get_drvdata(&dssdev->dev);
1125 dev_dbg(&dssdev->dev, "resume\n");
1127 mutex_lock(&td->lock);
1129 if (dssdev->state != OMAP_DSS_DISPLAY_SUSPENDED) {
1136 r = taal_power_on(dssdev);
1141 dssdev->state = OMAP_DSS_DISPLAY_DISABLED;
1143 dssdev->state = OMAP_DSS_DISPLAY_ACTIVE;
1144 taal_queue_esd_work(dssdev);
1147 mutex_unlock(&td->lock);
1151 mutex_unlock(&td->lock);
1155 static void taal_framedone_cb(int err, void *data)
1157 struct omap_dss_device *dssdev = data;
1158 dev_dbg(&dssdev->dev, "framedone, err %d\n", err);
1162 static irqreturn_t taal_te_isr(int irq, void *data)
1164 struct omap_dss_device *dssdev = data;
1165 struct taal_data *td = dev_get_drvdata(&dssdev->dev);
1169 old = atomic_cmpxchg(&td->do_update, 1, 0);
1172 cancel_delayed_work(&td->te_timeout_work);
1174 r = omap_dsi_update(dssdev, td->channel,
1175 td->update_region.x,
1176 td->update_region.y,
1177 td->update_region.w,
1178 td->update_region.h,
1179 taal_framedone_cb, dssdev);
1186 dev_err(&dssdev->dev, "start update failed\n");
1191 static void taal_te_timeout_work_callback(struct work_struct *work)
1193 struct taal_data *td = container_of(work, struct taal_data,
1194 te_timeout_work.work);
1195 struct omap_dss_device *dssdev = td->dssdev;
1197 dev_err(&dssdev->dev, "TE not received for 250ms!\n");
1199 atomic_set(&td->do_update, 0);
1203 static int taal_update(struct omap_dss_device *dssdev,
1204 u16 x, u16 y, u16 w, u16 h)
1206 struct taal_data *td = dev_get_drvdata(&dssdev->dev);
1207 struct nokia_dsi_panel_data *panel_data = get_panel_data(dssdev);
1210 dev_dbg(&dssdev->dev, "update %d, %d, %d x %d\n", x, y, w, h);
1212 mutex_lock(&td->lock);
1220 r = omap_dsi_prepare_update(dssdev, &x, &y, &w, &h, true);
1224 r = taal_set_update_window(td, x, y, w, h);
1228 if (td->te_enabled && panel_data->use_ext_te) {
1229 td->update_region.x = x;
1230 td->update_region.y = y;
1231 td->update_region.w = w;
1232 td->update_region.h = h;
1234 schedule_delayed_work(&td->te_timeout_work,
1235 msecs_to_jiffies(250));
1236 atomic_set(&td->do_update, 1);
1238 r = omap_dsi_update(dssdev, td->channel, x, y, w, h,
1239 taal_framedone_cb, dssdev);
1244 /* note: no bus_unlock here. unlock is in framedone_cb */
1245 mutex_unlock(&td->lock);
1249 mutex_unlock(&td->lock);
1253 static int taal_sync(struct omap_dss_device *dssdev)
1255 struct taal_data *td = dev_get_drvdata(&dssdev->dev);
1257 dev_dbg(&dssdev->dev, "sync\n");
1259 mutex_lock(&td->lock);
1262 mutex_unlock(&td->lock);
1264 dev_dbg(&dssdev->dev, "sync done\n");
1269 static int _taal_enable_te(struct omap_dss_device *dssdev, bool enable)
1271 struct taal_data *td = dev_get_drvdata(&dssdev->dev);
1272 struct nokia_dsi_panel_data *panel_data = get_panel_data(dssdev);
1276 r = taal_dcs_write_1(td, DCS_TEAR_ON, 0);
1278 r = taal_dcs_write_0(td, DCS_TEAR_OFF);
1280 if (!panel_data->use_ext_te)
1281 omapdss_dsi_enable_te(dssdev, enable);
1283 if (td->panel_config->sleep.enable_te)
1284 msleep(td->panel_config->sleep.enable_te);
1289 static int taal_enable_te(struct omap_dss_device *dssdev, bool enable)
1291 struct taal_data *td = dev_get_drvdata(&dssdev->dev);
1294 mutex_lock(&td->lock);
1296 if (td->te_enabled == enable)
1302 r = _taal_enable_te(dssdev, enable);
1307 td->te_enabled = enable;
1311 mutex_unlock(&td->lock);
1316 mutex_unlock(&td->lock);
1321 static int taal_get_te(struct omap_dss_device *dssdev)
1323 struct taal_data *td = dev_get_drvdata(&dssdev->dev);
1326 mutex_lock(&td->lock);
1328 mutex_unlock(&td->lock);
1333 static int taal_rotate(struct omap_dss_device *dssdev, u8 rotate)
1335 struct taal_data *td = dev_get_drvdata(&dssdev->dev);
1338 dev_dbg(&dssdev->dev, "rotate %d\n", rotate);
1340 mutex_lock(&td->lock);
1342 if (td->rotate == rotate)
1348 r = taal_set_addr_mode(td, rotate, td->mirror);
1353 td->rotate = rotate;
1357 mutex_unlock(&td->lock);
1361 mutex_unlock(&td->lock);
1365 static u8 taal_get_rotate(struct omap_dss_device *dssdev)
1367 struct taal_data *td = dev_get_drvdata(&dssdev->dev);
1370 mutex_lock(&td->lock);
1372 mutex_unlock(&td->lock);
1377 static int taal_mirror(struct omap_dss_device *dssdev, bool enable)
1379 struct taal_data *td = dev_get_drvdata(&dssdev->dev);
1382 dev_dbg(&dssdev->dev, "mirror %d\n", enable);
1384 mutex_lock(&td->lock);
1386 if (td->mirror == enable)
1391 r = taal_set_addr_mode(td, td->rotate, enable);
1396 td->mirror = enable;
1400 mutex_unlock(&td->lock);
1404 mutex_unlock(&td->lock);
1408 static bool taal_get_mirror(struct omap_dss_device *dssdev)
1410 struct taal_data *td = dev_get_drvdata(&dssdev->dev);
1413 mutex_lock(&td->lock);
1415 mutex_unlock(&td->lock);
1420 static int taal_run_test(struct omap_dss_device *dssdev, int test_num)
1422 struct taal_data *td = dev_get_drvdata(&dssdev->dev);
1426 mutex_lock(&td->lock);
1435 r = taal_dcs_read_1(td, DCS_GET_ID1, &id1);
1438 r = taal_dcs_read_1(td, DCS_GET_ID2, &id2);
1441 r = taal_dcs_read_1(td, DCS_GET_ID3, &id3);
1446 mutex_unlock(&td->lock);
1451 mutex_unlock(&td->lock);
1455 static int taal_memory_read(struct omap_dss_device *dssdev,
1456 void *buf, size_t size,
1457 u16 x, u16 y, u16 w, u16 h)
1462 unsigned buf_used = 0;
1463 struct taal_data *td = dev_get_drvdata(&dssdev->dev);
1465 if (size < w * h * 3)
1468 mutex_lock(&td->lock);
1475 size = min(w * h * 3,
1476 dssdev->panel.timings.x_res *
1477 dssdev->panel.timings.y_res * 3);
1481 /* plen 1 or 2 goes into short packet. until checksum error is fixed,
1482 * use short packets. plen 32 works, but bigger packets seem to cause
1489 taal_set_update_window(td, x, y, w, h);
1491 r = dsi_vc_set_max_rx_packet_size(td->channel, plen);
1495 while (buf_used < size) {
1496 u8 dcs_cmd = first ? 0x2e : 0x3e;
1499 r = dsi_vc_dcs_read(td->channel, dcs_cmd,
1500 buf + buf_used, size - buf_used);
1503 dev_err(&dssdev->dev, "read error\n");
1510 dev_err(&dssdev->dev, "short read\n");
1514 if (signal_pending(current)) {
1515 dev_err(&dssdev->dev, "signal pending, "
1516 "aborting memory read\n");
1525 dsi_vc_set_max_rx_packet_size(td->channel, 1);
1529 mutex_unlock(&td->lock);
1533 static void taal_esd_work(struct work_struct *work)
1535 struct taal_data *td = container_of(work, struct taal_data,
1537 struct omap_dss_device *dssdev = td->dssdev;
1538 struct nokia_dsi_panel_data *panel_data = get_panel_data(dssdev);
1542 mutex_lock(&td->lock);
1545 mutex_unlock(&td->lock);
1551 r = taal_dcs_read_1(td, DCS_RDDSDR, &state1);
1553 dev_err(&dssdev->dev, "failed to read Taal status\n");
1557 /* Run self diagnostics */
1558 r = taal_sleep_out(td);
1560 dev_err(&dssdev->dev, "failed to run Taal self-diagnostics\n");
1564 r = taal_dcs_read_1(td, DCS_RDDSDR, &state2);
1566 dev_err(&dssdev->dev, "failed to read Taal status\n");
1570 /* Each sleep out command will trigger a self diagnostic and flip
1571 * Bit6 if the test passes.
1573 if (!((state1 ^ state2) & (1 << 6))) {
1574 dev_err(&dssdev->dev, "LCD self diagnostics failed\n");
1577 /* Self-diagnostics result is also shown on TE GPIO line. We need
1578 * to re-enable TE after self diagnostics */
1579 if (td->te_enabled && panel_data->use_ext_te) {
1580 r = taal_dcs_write_1(td, DCS_TEAR_ON, 0);
1587 taal_queue_esd_work(dssdev);
1589 mutex_unlock(&td->lock);
1592 dev_err(&dssdev->dev, "performing LCD reset\n");
1594 taal_panel_reset(dssdev);
1598 taal_queue_esd_work(dssdev);
1600 mutex_unlock(&td->lock);
1603 static int taal_set_update_mode(struct omap_dss_device *dssdev,
1604 enum omap_dss_update_mode mode)
1606 if (mode != OMAP_DSS_UPDATE_MANUAL)
1611 static enum omap_dss_update_mode taal_get_update_mode(
1612 struct omap_dss_device *dssdev)
1614 return OMAP_DSS_UPDATE_MANUAL;
1617 static struct omap_dss_driver taal_driver = {
1618 .probe = taal_probe,
1619 .remove = __exit_p(taal_remove),
1621 .enable = taal_enable,
1622 .disable = taal_disable,
1623 .suspend = taal_suspend,
1624 .resume = taal_resume,
1626 .set_update_mode = taal_set_update_mode,
1627 .get_update_mode = taal_get_update_mode,
1629 .update = taal_update,
1632 .get_resolution = taal_get_resolution,
1633 .get_recommended_bpp = omapdss_default_get_recommended_bpp,
1635 .enable_te = taal_enable_te,
1636 .get_te = taal_get_te,
1638 .set_rotate = taal_rotate,
1639 .get_rotate = taal_get_rotate,
1640 .set_mirror = taal_mirror,
1641 .get_mirror = taal_get_mirror,
1642 .run_test = taal_run_test,
1643 .memory_read = taal_memory_read,
1645 .get_timings = taal_get_timings,
1649 .owner = THIS_MODULE,
1653 static int __init taal_init(void)
1655 omap_dss_register_driver(&taal_driver);
1660 static void __exit taal_exit(void)
1662 omap_dss_unregister_driver(&taal_driver);
1665 module_init(taal_init);
1666 module_exit(taal_exit);
1668 MODULE_AUTHOR("Tomi Valkeinen <tomi.valkeinen@nokia.com>");
1669 MODULE_DESCRIPTION("Taal Driver");
1670 MODULE_LICENSE("GPL");