aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorTomi Valkeinen <tomi.valkeinen@ti.com>2012-08-17 08:16:45 -0400
committerTomi Valkeinen <tomi.valkeinen@ti.com>2012-08-17 08:16:45 -0400
commit60548a2b943674c8a4e9cf44d1ea1ccb239fa8ff (patch)
tree8f786f5c3510ca8a70725e5c914ec5ad2ae4171c
parenta2496dc9427a4f8d7db47a09ac9bb194b233fe88 (diff)
parent89e7195634e563b72288bf13ef4dbdf4709d2d08 (diff)
Merge output work from Archit
The series removes bunch of dssdev references from the omapdss output drivers. This is made to let us move to a common panel framework later, and also allows us to implement OMAP's writeback support, which has been proven difficult with the current output drivers. OMAPDSS: APPLY: Constify timings argument in dss_mgr_set_timings OMAPDSS: DPI: Add locking for DPI interface OMAPDSS: Displays: Add locking in generic DPI panel driver OMAPDSS: DPI: Maintain our own timings field in driver data OMAPDSS: DPI displays: Take care of panel timings in the driver itself OMAPDSS: DSI: Maintain own copy of timings in driver data OMAPDSS: DSI: Add function to set panel size for command mode panels OMAPDSS: DSI: Update manager timings on a manual update OMAPDSS: HDMI: Use our own omap_video_timings field when setting interface timings OMAPDSS: HDMI: Add locking for hdmi interface set timing functions OMAPDSS: SDI: Create a function to set timings OMAPDSS: SDI: Maintain our own timings field in driver data OMAPDSS: VENC: Split VENC into interface and panel driver OMAPDSS: VENC: Maintain our own timings field in driver data OMAPDSS: RFBI: Remove partial update support OMAPDSS: RFBI: Add function to set panel size OMAPDSS: DSI: Maintain copy of pixel format in driver data OMAPDSS: RFBI: Maintain copy of pixel size in driver data OMAPDSS: RFBI: Maintain copy of number of data lines in driver data OMAPDSS: DPI: Maintain copy of number of data lines in driver data OMAPDSS: SDI: Maintain copy of data pairs in driver data OMAPDSS: DSI: Maintain copy of operation mode in driver data OMAPDSS: DSI: Rename dsi_videomode_data to dsi_videomode_timings OMAPDSS: DSI: Maintain copy of video mode timings in driver data OMAPDSS: RFBI: Maitain copy of rfbi timings in driver data OMAPDSS: VENC: Maintain copy of venc type in driver data OMAPDSS: VENC: Maintian copy of video output polarity info in private data
Diffstat
-rw-r--r--drivers/video/omap2/displays/panel-acx565akm.c14
-rw-r--r--drivers/video/omap2/displays/panel-generic-dpi.c76
-rw-r--r--drivers/video/omap2/displays/panel-lgphilips-lb035q02.c3
-rw-r--r--drivers/video/omap2/displays/panel-n8x0.c30
-rw-r--r--drivers/video/omap2/displays/panel-nec-nl8048hl11-01b.c3
-rw-r--r--drivers/video/omap2/displays/panel-picodlp.c4
-rw-r--r--drivers/video/omap2/displays/panel-sharp-ls037v7dw01.c3
-rw-r--r--drivers/video/omap2/displays/panel-taal.c16
-rw-r--r--drivers/video/omap2/displays/panel-tfp410.c6
-rw-r--r--drivers/video/omap2/displays/panel-tpo-td043mtea1.c7
-rw-r--r--drivers/video/omap2/dss/Makefile2
-rw-r--r--drivers/video/omap2/dss/apply.c4
-rw-r--r--drivers/video/omap2/dss/dpi.c51
-rw-r--r--drivers/video/omap2/dss/dsi.c212
-rw-r--r--drivers/video/omap2/dss/dss.c2
-rw-r--r--drivers/video/omap2/dss/dss.h21
-rw-r--r--drivers/video/omap2/dss/hdmi.c39
-rw-r--r--drivers/video/omap2/dss/hdmi_panel.c29
-rw-r--r--drivers/video/omap2/dss/rfbi.c126
-rw-r--r--drivers/video/omap2/dss/sdi.c34
-rw-r--r--drivers/video/omap2/dss/venc.c236
-rw-r--r--drivers/video/omap2/dss/venc_panel.c251
-rw-r--r--include/video/omapdss.h36
23 files changed, 837 insertions, 368 deletions
diff --git a/drivers/video/omap2/displays/panel-acx565akm.c b/drivers/video/omap2/displays/panel-acx565akm.c
index eaeed4340e04..c835aa70f96f 100644
--- a/drivers/video/omap2/displays/panel-acx565akm.c
+++ b/drivers/video/omap2/displays/panel-acx565akm.c
@@ -600,6 +600,9 @@ static int acx_panel_power_on(struct omap_dss_device *dssdev)
600 600
601 mutex_lock(&md->mutex); 601 mutex_lock(&md->mutex);
602 602
603 omapdss_sdi_set_timings(dssdev, &dssdev->panel.timings);
604 omapdss_sdi_set_datapairs(dssdev, dssdev->phy.sdi.datapairs);
605
603 r = omapdss_sdi_display_enable(dssdev); 606 r = omapdss_sdi_display_enable(dssdev);
604 if (r) { 607 if (r) {
605 pr_err("%s sdi enable failed\n", __func__); 608 pr_err("%s sdi enable failed\n", __func__);
@@ -731,18 +734,9 @@ static int acx_panel_resume(struct omap_dss_device *dssdev)
731static void acx_panel_set_timings(struct omap_dss_device *dssdev, 734static void acx_panel_set_timings(struct omap_dss_device *dssdev,
732 struct omap_video_timings *timings) 735 struct omap_video_timings *timings)
733{ 736{
734 int r; 737 omapdss_sdi_set_timings(dssdev, timings);
735
736 if (dssdev->state == OMAP_DSS_DISPLAY_ACTIVE)
737 omapdss_sdi_display_disable(dssdev);
738 738
739 dssdev->panel.timings = *timings; 739 dssdev->panel.timings = *timings;
740
741 if (dssdev->state == OMAP_DSS_DISPLAY_ACTIVE) {
742 r = omapdss_sdi_display_enable(dssdev);
743 if (r)
744 dev_err(&dssdev->dev, "%s enable failed\n", __func__);
745 }
746} 740}
747 741
748static int acx_panel_check_timings(struct omap_dss_device *dssdev, 742static int acx_panel_check_timings(struct omap_dss_device *dssdev,
diff --git a/drivers/video/omap2/displays/panel-generic-dpi.c b/drivers/video/omap2/displays/panel-generic-dpi.c
index bc5af2500eb9..88295c526815 100644
--- a/drivers/video/omap2/displays/panel-generic-dpi.c
+++ b/drivers/video/omap2/displays/panel-generic-dpi.c
@@ -545,6 +545,8 @@ struct panel_drv_data {
545 struct omap_dss_device *dssdev; 545 struct omap_dss_device *dssdev;
546 546
547 struct panel_config *panel_config; 547 struct panel_config *panel_config;
548
549 struct mutex lock;
548}; 550};
549 551
550static inline struct panel_generic_dpi_data 552static inline struct panel_generic_dpi_data
@@ -563,6 +565,9 @@ static int generic_dpi_panel_power_on(struct omap_dss_device *dssdev)
563 if (dssdev->state == OMAP_DSS_DISPLAY_ACTIVE) 565 if (dssdev->state == OMAP_DSS_DISPLAY_ACTIVE)
564 return 0; 566 return 0;
565 567
568 omapdss_dpi_set_timings(dssdev, &dssdev->panel.timings);
569 omapdss_dpi_set_data_lines(dssdev, dssdev->phy.dpi.data_lines);
570
566 r = omapdss_dpi_display_enable(dssdev); 571 r = omapdss_dpi_display_enable(dssdev);
567 if (r) 572 if (r)
568 goto err0; 573 goto err0;
@@ -634,6 +639,8 @@ static int generic_dpi_panel_probe(struct omap_dss_device *dssdev)
634 drv_data->dssdev = dssdev; 639 drv_data->dssdev = dssdev;
635 drv_data->panel_config = panel_config; 640 drv_data->panel_config = panel_config;
636 641
642 mutex_init(&drv_data->lock);
643
637 dev_set_drvdata(&dssdev->dev, drv_data); 644 dev_set_drvdata(&dssdev->dev, drv_data);
638 645
639 return 0; 646 return 0;
@@ -652,56 +659,108 @@ static void __exit generic_dpi_panel_remove(struct omap_dss_device *dssdev)
652 659
653static int generic_dpi_panel_enable(struct omap_dss_device *dssdev) 660static int generic_dpi_panel_enable(struct omap_dss_device *dssdev)
654{ 661{
655 int r = 0; 662 struct panel_drv_data *drv_data = dev_get_drvdata(&dssdev->dev);
663 int r;
664
665 mutex_lock(&drv_data->lock);
656 666
657 r = generic_dpi_panel_power_on(dssdev); 667 r = generic_dpi_panel_power_on(dssdev);
658 if (r) 668 if (r)
659 return r; 669 goto err;
660 670
661 dssdev->state = OMAP_DSS_DISPLAY_ACTIVE; 671 dssdev->state = OMAP_DSS_DISPLAY_ACTIVE;
672err:
673 mutex_unlock(&drv_data->lock);
662 674
663 return 0; 675 return r;
664} 676}
665 677
666static void generic_dpi_panel_disable(struct omap_dss_device *dssdev) 678static void generic_dpi_panel_disable(struct omap_dss_device *dssdev)
667{ 679{
680 struct panel_drv_data *drv_data = dev_get_drvdata(&dssdev->dev);
681
682 mutex_lock(&drv_data->lock);
683
668 generic_dpi_panel_power_off(dssdev); 684 generic_dpi_panel_power_off(dssdev);
669 685
670 dssdev->state = OMAP_DSS_DISPLAY_DISABLED; 686 dssdev->state = OMAP_DSS_DISPLAY_DISABLED;
687
688 mutex_unlock(&drv_data->lock);
671} 689}
672 690
673static int generic_dpi_panel_suspend(struct omap_dss_device *dssdev) 691static int generic_dpi_panel_suspend(struct omap_dss_device *dssdev)
674{ 692{
693 struct panel_drv_data *drv_data = dev_get_drvdata(&dssdev->dev);
694
695 mutex_lock(&drv_data->lock);
696
675 generic_dpi_panel_power_off(dssdev); 697 generic_dpi_panel_power_off(dssdev);
676 698
677 dssdev->state = OMAP_DSS_DISPLAY_SUSPENDED; 699 dssdev->state = OMAP_DSS_DISPLAY_SUSPENDED;
678 700
701 mutex_unlock(&drv_data->lock);
702
679 return 0; 703 return 0;
680} 704}
681 705
682static int generic_dpi_panel_resume(struct omap_dss_device *dssdev) 706static int generic_dpi_panel_resume(struct omap_dss_device *dssdev)
683{ 707{
684 int r = 0; 708 struct panel_drv_data *drv_data = dev_get_drvdata(&dssdev->dev);
709 int r;
710
711 mutex_lock(&drv_data->lock);
685 712
686 r = generic_dpi_panel_power_on(dssdev); 713 r = generic_dpi_panel_power_on(dssdev);
687 if (r) 714 if (r)
688 return r; 715 goto err;
689 716
690 dssdev->state = OMAP_DSS_DISPLAY_ACTIVE; 717 dssdev->state = OMAP_DSS_DISPLAY_ACTIVE;
691 718
692 return 0; 719err:
720 mutex_unlock(&drv_data->lock);
721
722 return r;
693} 723}
694 724
695static void generic_dpi_panel_set_timings(struct omap_dss_device *dssdev, 725static void generic_dpi_panel_set_timings(struct omap_dss_device *dssdev,
696 struct omap_video_timings *timings) 726 struct omap_video_timings *timings)
697{ 727{
698 dpi_set_timings(dssdev, timings); 728 struct panel_drv_data *drv_data = dev_get_drvdata(&dssdev->dev);
729
730 mutex_lock(&drv_data->lock);
731
732 omapdss_dpi_set_timings(dssdev, timings);
733
734 dssdev->panel.timings = *timings;
735
736 mutex_unlock(&drv_data->lock);
737}
738
739static void generic_dpi_panel_get_timings(struct omap_dss_device *dssdev,
740 struct omap_video_timings *timings)
741{
742 struct panel_drv_data *drv_data = dev_get_drvdata(&dssdev->dev);
743
744 mutex_lock(&drv_data->lock);
745
746 *timings = dssdev->panel.timings;
747
748 mutex_unlock(&drv_data->lock);
699} 749}
700 750
701static int generic_dpi_panel_check_timings(struct omap_dss_device *dssdev, 751static int generic_dpi_panel_check_timings(struct omap_dss_device *dssdev,
702 struct omap_video_timings *timings) 752 struct omap_video_timings *timings)
703{ 753{
704 return dpi_check_timings(dssdev, timings); 754 struct panel_drv_data *drv_data = dev_get_drvdata(&dssdev->dev);
755 int r;
756
757 mutex_lock(&drv_data->lock);
758
759 r = dpi_check_timings(dssdev, timings);
760
761 mutex_unlock(&drv_data->lock);
762
763 return r;
705} 764}
706 765
707static struct omap_dss_driver dpi_driver = { 766static struct omap_dss_driver dpi_driver = {
@@ -714,6 +773,7 @@ static struct omap_dss_driver dpi_driver = {
714 .resume = generic_dpi_panel_resume, 773 .resume = generic_dpi_panel_resume,
715 774
716 .set_timings = generic_dpi_panel_set_timings, 775 .set_timings = generic_dpi_panel_set_timings,
776 .get_timings = generic_dpi_panel_get_timings,
717 .check_timings = generic_dpi_panel_check_timings, 777 .check_timings = generic_dpi_panel_check_timings,
718 778
719 .driver = { 779 .driver = {
diff --git a/drivers/video/omap2/displays/panel-lgphilips-lb035q02.c b/drivers/video/omap2/displays/panel-lgphilips-lb035q02.c
index 802807798846..90c1cabf244e 100644
--- a/drivers/video/omap2/displays/panel-lgphilips-lb035q02.c
+++ b/drivers/video/omap2/displays/panel-lgphilips-lb035q02.c
@@ -55,6 +55,9 @@ static int lb035q02_panel_power_on(struct omap_dss_device *dssdev)
55 if (dssdev->state == OMAP_DSS_DISPLAY_ACTIVE) 55 if (dssdev->state == OMAP_DSS_DISPLAY_ACTIVE)
56 return 0; 56 return 0;
57 57
58 omapdss_dpi_set_timings(dssdev, &dssdev->panel.timings);
59 omapdss_dpi_set_data_lines(dssdev, dssdev->phy.dpi.data_lines);
60
58 r = omapdss_dpi_display_enable(dssdev); 61 r = omapdss_dpi_display_enable(dssdev);
59 if (r) 62 if (r)
60 goto err0; 63 goto err0;
diff --git a/drivers/video/omap2/displays/panel-n8x0.c b/drivers/video/omap2/displays/panel-n8x0.c
index e6c115373c00..17ae85e0033f 100644
--- a/drivers/video/omap2/displays/panel-n8x0.c
+++ b/drivers/video/omap2/displays/panel-n8x0.c
@@ -150,11 +150,17 @@ static void blizzard_ctrl_setup_update(struct omap_dss_device *dssdev,
150 BLIZZARD_SRC_WRITE_LCD : 150 BLIZZARD_SRC_WRITE_LCD :
151 BLIZZARD_SRC_WRITE_LCD_DESTRUCTIVE; 151 BLIZZARD_SRC_WRITE_LCD_DESTRUCTIVE;
152 152
153 omap_rfbi_configure(dssdev, 16, 8); 153 omapdss_rfbi_set_pixel_size(dssdev, 16);
154 omapdss_rfbi_set_data_lines(dssdev, 8);
155
156 omap_rfbi_configure(dssdev);
154 157
155 blizzard_write(BLIZZARD_INPUT_WIN_X_START_0, tmp, 18); 158 blizzard_write(BLIZZARD_INPUT_WIN_X_START_0, tmp, 18);
156 159
157 omap_rfbi_configure(dssdev, 16, 16); 160 omapdss_rfbi_set_pixel_size(dssdev, 16);
161 omapdss_rfbi_set_data_lines(dssdev, 16);
162
163 omap_rfbi_configure(dssdev);
158} 164}
159 165
160static void mipid_transfer(struct spi_device *spi, int cmd, const u8 *wbuf, 166static void mipid_transfer(struct spi_device *spi, int cmd, const u8 *wbuf,
@@ -297,6 +303,12 @@ static int n8x0_panel_power_on(struct omap_dss_device *dssdev)
297 goto err_plat_en; 303 goto err_plat_en;
298 } 304 }
299 305
306 omapdss_rfbi_set_size(dssdev, dssdev->panel.timings.x_res,
307 dssdev->panel.timings.y_res);
308 omapdss_rfbi_set_pixel_size(dssdev, dssdev->ctrl.pixel_size);
309 omapdss_rfbi_set_data_lines(dssdev, dssdev->phy.rfbi.data_lines);
310 omapdss_rfbi_set_interface_timings(dssdev, &dssdev->ctrl.rfbi_timings);
311
300 r = omapdss_rfbi_display_enable(dssdev); 312 r = omapdss_rfbi_display_enable(dssdev);
301 if (r) 313 if (r)
302 goto err_rfbi_en; 314 goto err_rfbi_en;
@@ -625,17 +637,25 @@ static int n8x0_panel_update(struct omap_dss_device *dssdev,
625 u16 x, u16 y, u16 w, u16 h) 637 u16 x, u16 y, u16 w, u16 h)
626{ 638{
627 struct panel_drv_data *ddata = get_drv_data(dssdev); 639 struct panel_drv_data *ddata = get_drv_data(dssdev);
640 u16 dw, dh;
628 641
629 dev_dbg(&dssdev->dev, "update\n"); 642 dev_dbg(&dssdev->dev, "update\n");
630 643
644 dw = dssdev->panel.timings.x_res;
645 dh = dssdev->panel.timings.y_res;
646
647 if (x != 0 || y != 0 || w != dw || h != dh) {
648 dev_err(&dssdev->dev, "invaid update region %d, %d, %d, %d\n",
649 x, y, w, h);
650 return -EINVAL;
651 }
652
631 mutex_lock(&ddata->lock); 653 mutex_lock(&ddata->lock);
632 rfbi_bus_lock(); 654 rfbi_bus_lock();
633 655
634 omap_rfbi_prepare_update(dssdev, &x, &y, &w, &h);
635
636 blizzard_ctrl_setup_update(dssdev, x, y, w, h); 656 blizzard_ctrl_setup_update(dssdev, x, y, w, h);
637 657
638 omap_rfbi_update(dssdev, x, y, w, h, update_done, NULL); 658 omap_rfbi_update(dssdev, update_done, NULL);
639 659
640 mutex_unlock(&ddata->lock); 660 mutex_unlock(&ddata->lock);
641 661
diff --git a/drivers/video/omap2/displays/panel-nec-nl8048hl11-01b.c b/drivers/video/omap2/displays/panel-nec-nl8048hl11-01b.c
index b122b0f31c43..908fd268f3dc 100644
--- a/drivers/video/omap2/displays/panel-nec-nl8048hl11-01b.c
+++ b/drivers/video/omap2/displays/panel-nec-nl8048hl11-01b.c
@@ -175,6 +175,9 @@ static int nec_8048_panel_power_on(struct omap_dss_device *dssdev)
175 if (dssdev->state == OMAP_DSS_DISPLAY_ACTIVE) 175 if (dssdev->state == OMAP_DSS_DISPLAY_ACTIVE)
176 return 0; 176 return 0;
177 177
178 omapdss_dpi_set_timings(dssdev, &dssdev->panel.timings);
179 omapdss_dpi_set_data_lines(dssdev, dssdev->phy.dpi.data_lines);
180
178 r = omapdss_dpi_display_enable(dssdev); 181 r = omapdss_dpi_display_enable(dssdev);
179 if (r) 182 if (r)
180 goto err0; 183 goto err0;
diff --git a/drivers/video/omap2/displays/panel-picodlp.c b/drivers/video/omap2/displays/panel-picodlp.c
index 2d35bd388860..9df87640ddd2 100644
--- a/drivers/video/omap2/displays/panel-picodlp.c
+++ b/drivers/video/omap2/displays/panel-picodlp.c
@@ -377,6 +377,10 @@ static int picodlp_panel_power_on(struct omap_dss_device *dssdev)
377 * then only i2c commands can be successfully sent to dpp2600 377 * then only i2c commands can be successfully sent to dpp2600
378 */ 378 */
379 msleep(1000); 379 msleep(1000);
380
381 omapdss_dpi_set_timings(dssdev, &dssdev->panel.timings);
382 omapdss_dpi_set_data_lines(dssdev, dssdev->phy.dpi.data_lines);
383
380 r = omapdss_dpi_display_enable(dssdev); 384 r = omapdss_dpi_display_enable(dssdev);
381 if (r) { 385 if (r) {
382 dev_err(&dssdev->dev, "failed to enable DPI\n"); 386 dev_err(&dssdev->dev, "failed to enable DPI\n");
diff --git a/drivers/video/omap2/displays/panel-sharp-ls037v7dw01.c b/drivers/video/omap2/displays/panel-sharp-ls037v7dw01.c
index bd86ba9ccf76..1ec3b277ff15 100644
--- a/drivers/video/omap2/displays/panel-sharp-ls037v7dw01.c
+++ b/drivers/video/omap2/displays/panel-sharp-ls037v7dw01.c
@@ -142,6 +142,9 @@ static int sharp_ls_power_on(struct omap_dss_device *dssdev)
142 if (dssdev->state == OMAP_DSS_DISPLAY_ACTIVE) 142 if (dssdev->state == OMAP_DSS_DISPLAY_ACTIVE)
143 return 0; 143 return 0;
144 144
145 omapdss_dpi_set_timings(dssdev, &dssdev->panel.timings);
146 omapdss_dpi_set_data_lines(dssdev, dssdev->phy.dpi.data_lines);
147
145 r = omapdss_dpi_display_enable(dssdev); 148 r = omapdss_dpi_display_enable(dssdev);
146 if (r) 149 if (r)
147 goto err0; 150 goto err0;
diff --git a/drivers/video/omap2/displays/panel-taal.c b/drivers/video/omap2/displays/panel-taal.c
index 3f5acc7771da..77aed0e51f9b 100644
--- a/drivers/video/omap2/displays/panel-taal.c
+++ b/drivers/video/omap2/displays/panel-taal.c
@@ -1060,6 +1060,11 @@ static int taal_power_on(struct omap_dss_device *dssdev)
1060 goto err0; 1060 goto err0;
1061 }; 1061 };
1062 1062
1063 omapdss_dsi_set_size(dssdev, dssdev->panel.timings.x_res,
1064 dssdev->panel.timings.y_res);
1065 omapdss_dsi_set_pixel_format(dssdev, OMAP_DSS_DSI_FMT_RGB888);
1066 omapdss_dsi_set_operation_mode(dssdev, OMAP_DSS_DSI_CMD_MODE);
1067
1063 r = omapdss_dsi_display_enable(dssdev); 1068 r = omapdss_dsi_display_enable(dssdev);
1064 if (r) { 1069 if (r) {
1065 dev_err(&dssdev->dev, "failed to enable DSI\n"); 1070 dev_err(&dssdev->dev, "failed to enable DSI\n");
@@ -1487,6 +1492,7 @@ static int taal_get_te(struct omap_dss_device *dssdev)
1487static int taal_rotate(struct omap_dss_device *dssdev, u8 rotate) 1492static int taal_rotate(struct omap_dss_device *dssdev, u8 rotate)
1488{ 1493{
1489 struct taal_data *td = dev_get_drvdata(&dssdev->dev); 1494 struct taal_data *td = dev_get_drvdata(&dssdev->dev);
1495 u16 dw, dh;
1490 int r; 1496 int r;
1491 1497
1492 dev_dbg(&dssdev->dev, "rotate %d\n", rotate); 1498 dev_dbg(&dssdev->dev, "rotate %d\n", rotate);
@@ -1508,6 +1514,16 @@ static int taal_rotate(struct omap_dss_device *dssdev, u8 rotate)
1508 goto err; 1514 goto err;
1509 } 1515 }
1510 1516
1517 if (rotate == 0 || rotate == 2) {
1518 dw = dssdev->panel.timings.x_res;
1519 dh = dssdev->panel.timings.y_res;
1520 } else {
1521 dw = dssdev->panel.timings.y_res;
1522 dh = dssdev->panel.timings.x_res;
1523 }
1524
1525 omapdss_dsi_set_size(dssdev, dw, dh);
1526
1511 td->rotate = rotate; 1527 td->rotate = rotate;
1512 1528
1513 dsi_bus_unlock(dssdev); 1529 dsi_bus_unlock(dssdev);
diff --git a/drivers/video/omap2/displays/panel-tfp410.c b/drivers/video/omap2/displays/panel-tfp410.c
index 40cc0cfa5d17..4be9a59664d5 100644
--- a/drivers/video/omap2/displays/panel-tfp410.c
+++ b/drivers/video/omap2/displays/panel-tfp410.c
@@ -65,6 +65,9 @@ static int tfp410_power_on(struct omap_dss_device *dssdev)
65 if (dssdev->state == OMAP_DSS_DISPLAY_ACTIVE) 65 if (dssdev->state == OMAP_DSS_DISPLAY_ACTIVE)
66 return 0; 66 return 0;
67 67
68 omapdss_dpi_set_timings(dssdev, &dssdev->panel.timings);
69 omapdss_dpi_set_data_lines(dssdev, dssdev->phy.dpi.data_lines);
70
68 r = omapdss_dpi_display_enable(dssdev); 71 r = omapdss_dpi_display_enable(dssdev);
69 if (r) 72 if (r)
70 goto err0; 73 goto err0;
@@ -231,7 +234,8 @@ static void tfp410_set_timings(struct omap_dss_device *dssdev,
231 struct panel_drv_data *ddata = dev_get_drvdata(&dssdev->dev); 234 struct panel_drv_data *ddata = dev_get_drvdata(&dssdev->dev);
232 235
233 mutex_lock(&ddata->lock); 236 mutex_lock(&ddata->lock);
234 dpi_set_timings(dssdev, timings); 237 omapdss_dpi_set_timings(dssdev, timings);
238 dssdev->panel.timings = *timings;
235 mutex_unlock(&ddata->lock); 239 mutex_unlock(&ddata->lock);
236} 240}
237 241
diff --git a/drivers/video/omap2/displays/panel-tpo-td043mtea1.c b/drivers/video/omap2/displays/panel-tpo-td043mtea1.c
index fa7baa650ae0..b5e6dbc59f0a 100644
--- a/drivers/video/omap2/displays/panel-tpo-td043mtea1.c
+++ b/drivers/video/omap2/displays/panel-tpo-td043mtea1.c
@@ -337,6 +337,9 @@ static int tpo_td043_enable_dss(struct omap_dss_device *dssdev)
337 if (dssdev->state == OMAP_DSS_DISPLAY_ACTIVE) 337 if (dssdev->state == OMAP_DSS_DISPLAY_ACTIVE)
338 return 0; 338 return 0;
339 339
340 omapdss_dpi_set_timings(dssdev, &dssdev->panel.timings);
341 omapdss_dpi_set_data_lines(dssdev, dssdev->phy.dpi.data_lines);
342
340 r = omapdss_dpi_display_enable(dssdev); 343 r = omapdss_dpi_display_enable(dssdev);
341 if (r) 344 if (r)
342 goto err0; 345 goto err0;
@@ -480,7 +483,9 @@ static void tpo_td043_remove(struct omap_dss_device *dssdev)
480static void tpo_td043_set_timings(struct omap_dss_device *dssdev, 483static void tpo_td043_set_timings(struct omap_dss_device *dssdev,
481 struct omap_video_timings *timings) 484 struct omap_video_timings *timings)
482{ 485{
483 dpi_set_timings(dssdev, timings); 486 omapdss_dpi_set_timings(dssdev, timings);
487
488 dssdev->panel.timings = *timings;
484} 489}
485 490
486static int tpo_td043_check_timings(struct omap_dss_device *dssdev, 491static int tpo_td043_check_timings(struct omap_dss_device *dssdev,
diff --git a/drivers/video/omap2/dss/Makefile b/drivers/video/omap2/dss/Makefile
index 5c450b0f94d0..30a48fba75b0 100644
--- a/drivers/video/omap2/dss/Makefile
+++ b/drivers/video/omap2/dss/Makefile
@@ -3,7 +3,7 @@ omapdss-y := core.o dss.o dss_features.o dispc.o dispc_coefs.o display.o \
3 manager.o overlay.o apply.o 3 manager.o overlay.o apply.o
4omapdss-$(CONFIG_OMAP2_DSS_DPI) += dpi.o 4omapdss-$(CONFIG_OMAP2_DSS_DPI) += dpi.o
5omapdss-$(CONFIG_OMAP2_DSS_RFBI) += rfbi.o 5omapdss-$(CONFIG_OMAP2_DSS_RFBI) += rfbi.o
6omapdss-$(CONFIG_OMAP2_DSS_VENC) += venc.o 6omapdss-$(CONFIG_OMAP2_DSS_VENC) += venc.o venc_panel.o
7omapdss-$(CONFIG_OMAP2_DSS_SDI) += sdi.o 7omapdss-$(CONFIG_OMAP2_DSS_SDI) += sdi.o
8omapdss-$(CONFIG_OMAP2_DSS_DSI) += dsi.o 8omapdss-$(CONFIG_OMAP2_DSS_DSI) += dsi.o
9omapdss-$(CONFIG_OMAP4_DSS_HDMI) += hdmi.o \ 9omapdss-$(CONFIG_OMAP4_DSS_HDMI) += hdmi.o \
diff --git a/drivers/video/omap2/dss/apply.c b/drivers/video/omap2/dss/apply.c
index 0fefc68372b9..52a5940a3773 100644
--- a/drivers/video/omap2/dss/apply.c
+++ b/drivers/video/omap2/dss/apply.c
@@ -1302,7 +1302,7 @@ err:
1302} 1302}
1303 1303
1304static void dss_apply_mgr_timings(struct omap_overlay_manager *mgr, 1304static void dss_apply_mgr_timings(struct omap_overlay_manager *mgr,
1305 struct omap_video_timings *timings) 1305 const struct omap_video_timings *timings)
1306{ 1306{
1307 struct mgr_priv_data *mp = get_mgr_priv(mgr); 1307 struct mgr_priv_data *mp = get_mgr_priv(mgr);
1308 1308
@@ -1311,7 +1311,7 @@ static void dss_apply_mgr_timings(struct omap_overlay_manager *mgr,
1311} 1311}
1312 1312
1313void dss_mgr_set_timings(struct omap_overlay_manager *mgr, 1313void dss_mgr_set_timings(struct omap_overlay_manager *mgr,
1314 struct omap_video_timings *timings) 1314 const struct omap_video_timings *timings)
1315{ 1315{
1316 unsigned long flags; 1316 unsigned long flags;
1317 1317
diff --git a/drivers/video/omap2/dss/dpi.c b/drivers/video/omap2/dss/dpi.c
index 3266be23fc0d..f260343e2451 100644
--- a/drivers/video/omap2/dss/dpi.c
+++ b/drivers/video/omap2/dss/dpi.c
@@ -39,7 +39,11 @@ static struct {
39 struct regulator *vdds_dsi_reg; 39 struct regulator *vdds_dsi_reg;
40 struct platform_device *dsidev; 40 struct platform_device *dsidev;
41 41
42 struct mutex lock;
43
44 struct omap_video_timings timings;
42 struct dss_lcd_mgr_config mgr_config; 45 struct dss_lcd_mgr_config mgr_config;
46 int data_lines;
43} dpi; 47} dpi;
44 48
45static struct platform_device *dpi_get_dsidev(enum omap_dss_clk_source clk) 49static struct platform_device *dpi_get_dsidev(enum omap_dss_clk_source clk)
@@ -121,7 +125,7 @@ static int dpi_set_dispc_clk(struct omap_dss_device *dssdev,
121 125
122static int dpi_set_mode(struct omap_dss_device *dssdev) 126static int dpi_set_mode(struct omap_dss_device *dssdev)
123{ 127{
124 struct omap_video_timings *t = &dssdev->panel.timings; 128 struct omap_video_timings *t = &dpi.timings;
125 int lck_div = 0, pck_div = 0; 129 int lck_div = 0, pck_div = 0;
126 unsigned long fck = 0; 130 unsigned long fck = 0;
127 unsigned long pck; 131 unsigned long pck;
@@ -158,7 +162,7 @@ static void dpi_config_lcd_manager(struct omap_dss_device *dssdev)
158 dpi.mgr_config.stallmode = false; 162 dpi.mgr_config.stallmode = false;
159 dpi.mgr_config.fifohandcheck = false; 163 dpi.mgr_config.fifohandcheck = false;
160 164
161 dpi.mgr_config.video_port_width = dssdev->phy.dpi.data_lines; 165 dpi.mgr_config.video_port_width = dpi.data_lines;
162 166
163 dpi.mgr_config.lcden_sig_polarity = 0; 167 dpi.mgr_config.lcden_sig_polarity = 0;
164 168
@@ -169,14 +173,18 @@ int omapdss_dpi_display_enable(struct omap_dss_device *dssdev)
169{ 173{
170 int r; 174 int r;
171 175
176 mutex_lock(&dpi.lock);
177
172 if (cpu_is_omap34xx() && !dpi.vdds_dsi_reg) { 178 if (cpu_is_omap34xx() && !dpi.vdds_dsi_reg) {
173 DSSERR("no VDSS_DSI regulator\n"); 179 DSSERR("no VDSS_DSI regulator\n");
174 return -ENODEV; 180 r = -ENODEV;
181 goto err_no_reg;
175 } 182 }
176 183
177 if (dssdev->manager == NULL) { 184 if (dssdev->manager == NULL) {
178 DSSERR("failed to enable display: no manager\n"); 185 DSSERR("failed to enable display: no manager\n");
179 return -ENODEV; 186 r = -ENODEV;
187 goto err_no_mgr;
180 } 188 }
181 189
182 r = omap_dss_start_device(dssdev); 190 r = omap_dss_start_device(dssdev);
@@ -217,6 +225,8 @@ int omapdss_dpi_display_enable(struct omap_dss_device *dssdev)
217 if (r) 225 if (r)
218 goto err_mgr_enable; 226 goto err_mgr_enable;
219 227
228 mutex_unlock(&dpi.lock);
229
220 return 0; 230 return 0;
221 231
222err_mgr_enable: 232err_mgr_enable:
@@ -234,12 +244,17 @@ err_get_dispc:
234err_reg_enable: 244err_reg_enable:
235 omap_dss_stop_device(dssdev); 245 omap_dss_stop_device(dssdev);
236err_start_dev: 246err_start_dev:
247err_no_mgr:
248err_no_reg:
249 mutex_unlock(&dpi.lock);
237 return r; 250 return r;
238} 251}
239EXPORT_SYMBOL(omapdss_dpi_display_enable); 252EXPORT_SYMBOL(omapdss_dpi_display_enable);
240 253
241void omapdss_dpi_display_disable(struct omap_dss_device *dssdev) 254void omapdss_dpi_display_disable(struct omap_dss_device *dssdev)
242{ 255{
256 mutex_lock(&dpi.lock);
257
243 dss_mgr_disable(dssdev->manager); 258 dss_mgr_disable(dssdev->manager);
244 259
245 if (dpi_use_dsi_pll(dssdev)) { 260 if (dpi_use_dsi_pll(dssdev)) {
@@ -254,16 +269,22 @@ void omapdss_dpi_display_disable(struct omap_dss_device *dssdev)
254 regulator_disable(dpi.vdds_dsi_reg); 269 regulator_disable(dpi.vdds_dsi_reg);
255 270
256 omap_dss_stop_device(dssdev); 271 omap_dss_stop_device(dssdev);
272
273 mutex_unlock(&dpi.lock);
257} 274}
258EXPORT_SYMBOL(omapdss_dpi_display_disable); 275EXPORT_SYMBOL(omapdss_dpi_display_disable);
259 276
260void dpi_set_timings(struct omap_dss_device *dssdev, 277void omapdss_dpi_set_timings(struct omap_dss_device *dssdev,
261 struct omap_video_timings *timings) 278 struct omap_video_timings *timings)
262{ 279{
263 int r; 280 int r;
264 281
265 DSSDBG("dpi_set_timings\n"); 282 DSSDBG("dpi_set_timings\n");
266 dssdev->panel.timings = *timings; 283
284 mutex_lock(&dpi.lock);
285
286 dpi.timings = *timings;
287
267 if (dssdev->state == OMAP_DSS_DISPLAY_ACTIVE) { 288 if (dssdev->state == OMAP_DSS_DISPLAY_ACTIVE) {
268 r = dispc_runtime_get(); 289 r = dispc_runtime_get();
269 if (r) 290 if (r)
@@ -275,8 +296,10 @@ void dpi_set_timings(struct omap_dss_device *dssdev,
275 } else { 296 } else {
276 dss_mgr_set_timings(dssdev->manager, timings); 297 dss_mgr_set_timings(dssdev->manager, timings);
277 } 298 }
299
300 mutex_unlock(&dpi.lock);
278} 301}
279EXPORT_SYMBOL(dpi_set_timings); 302EXPORT_SYMBOL(omapdss_dpi_set_timings);
280 303
281int dpi_check_timings(struct omap_dss_device *dssdev, 304int dpi_check_timings(struct omap_dss_device *dssdev,
282 struct omap_video_timings *timings) 305 struct omap_video_timings *timings)
@@ -325,6 +348,16 @@ int dpi_check_timings(struct omap_dss_device *dssdev,
325} 348}
326EXPORT_SYMBOL(dpi_check_timings); 349EXPORT_SYMBOL(dpi_check_timings);
327 350
351void omapdss_dpi_set_data_lines(struct omap_dss_device *dssdev, int data_lines)
352{
353 mutex_lock(&dpi.lock);
354
355 dpi.data_lines = data_lines;
356
357 mutex_unlock(&dpi.lock);
358}
359EXPORT_SYMBOL(omapdss_dpi_set_data_lines);
360
328static int __init dpi_init_display(struct omap_dss_device *dssdev) 361static int __init dpi_init_display(struct omap_dss_device *dssdev)
329{ 362{
330 DSSDBG("init_display\n"); 363 DSSDBG("init_display\n");
@@ -377,6 +410,8 @@ static void __init dpi_probe_pdata(struct platform_device *pdev)
377 410
378static int __init omap_dpi_probe(struct platform_device *pdev) 411static int __init omap_dpi_probe(struct platform_device *pdev)
379{ 412{
413 mutex_init(&dpi.lock);
414
380 dpi_probe_pdata(pdev); 415 dpi_probe_pdata(pdev);
381 416
382 return 0; 417 return 0;
diff --git a/drivers/video/omap2/dss/dsi.c b/drivers/video/omap2/dss/dsi.c
index b07e8864f82f..96d0024ada40 100644
--- a/drivers/video/omap2/dss/dsi.c
+++ b/drivers/video/omap2/dss/dsi.c
@@ -333,6 +333,10 @@ struct dsi_data {
333 unsigned scp_clk_refcount; 333 unsigned scp_clk_refcount;
334 334
335 struct dss_lcd_mgr_config mgr_config; 335 struct dss_lcd_mgr_config mgr_config;
336 struct omap_video_timings timings;
337 enum omap_dss_dsi_pixel_format pix_fmt;
338 enum omap_dss_dsi_mode mode;
339 struct omap_dss_dsi_videomode_timings vm_timings;
336}; 340};
337 341
338struct dsi_packet_sent_handler_data { 342struct dsi_packet_sent_handler_data {
@@ -2360,10 +2364,10 @@ static int dsi_cio_init(struct omap_dss_device *dssdev)
2360 2364
2361 dsi_cio_timings(dsidev); 2365 dsi_cio_timings(dsidev);
2362 2366
2363 if (dssdev->panel.dsi_mode == OMAP_DSS_DSI_VIDEO_MODE) { 2367 if (dsi->mode == OMAP_DSS_DSI_VIDEO_MODE) {
2364 /* DDR_CLK_ALWAYS_ON */ 2368 /* DDR_CLK_ALWAYS_ON */
2365 REG_FLD_MOD(dsidev, DSI_CLK_CTRL, 2369 REG_FLD_MOD(dsidev, DSI_CLK_CTRL,
2366 dssdev->panel.dsi_vm_data.ddr_clk_always_on, 13, 13); 2370 dsi->vm_timings.ddr_clk_always_on, 13, 13);
2367 } 2371 }
2368 2372
2369 dsi->ulps_enabled = false; 2373 dsi->ulps_enabled = false;
@@ -2685,6 +2689,7 @@ void omapdss_dsi_vc_enable_hs(struct omap_dss_device *dssdev, int channel,
2685 bool enable) 2689 bool enable)
2686{ 2690{
2687 struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev); 2691 struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev);
2692 struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
2688 2693
2689 DSSDBG("dsi_vc_enable_hs(%d, %d)\n", channel, enable); 2694 DSSDBG("dsi_vc_enable_hs(%d, %d)\n", channel, enable);
2690 2695
@@ -2701,7 +2706,7 @@ void omapdss_dsi_vc_enable_hs(struct omap_dss_device *dssdev, int channel,
2701 dsi_force_tx_stop_mode_io(dsidev); 2706 dsi_force_tx_stop_mode_io(dsidev);
2702 2707
2703 /* start the DDR clock by sending a NULL packet */ 2708 /* start the DDR clock by sending a NULL packet */
2704 if (dssdev->panel.dsi_vm_data.ddr_clk_always_on && enable) 2709 if (dsi->vm_timings.ddr_clk_always_on && enable)
2705 dsi_vc_send_null(dssdev, channel); 2710 dsi_vc_send_null(dssdev, channel);
2706} 2711}
2707EXPORT_SYMBOL(omapdss_dsi_vc_enable_hs); 2712EXPORT_SYMBOL(omapdss_dsi_vc_enable_hs);
@@ -3607,12 +3612,14 @@ static void dsi_set_hs_tx_timeout(struct platform_device *dsidev,
3607static void dsi_config_vp_num_line_buffers(struct omap_dss_device *dssdev) 3612static void dsi_config_vp_num_line_buffers(struct omap_dss_device *dssdev)
3608{ 3613{
3609 struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev); 3614 struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev);
3615 struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
3610 int num_line_buffers; 3616 int num_line_buffers;
3611 3617
3612 if (dssdev->panel.dsi_mode == OMAP_DSS_DSI_VIDEO_MODE) { 3618 if (dsi->mode == OMAP_DSS_DSI_VIDEO_MODE) {
3613 int bpp = dsi_get_pixel_size(dssdev->panel.dsi_pix_fmt); 3619 struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
3620 int bpp = dsi_get_pixel_size(dsi->pix_fmt);
3614 unsigned line_buf_size = dsi_get_line_buf_size(dsidev); 3621 unsigned line_buf_size = dsi_get_line_buf_size(dsidev);
3615 struct omap_video_timings *timings = &dssdev->panel.timings; 3622 struct omap_video_timings *timings = &dsi->timings;
3616 /* 3623 /*
3617 * Don't use line buffers if width is greater than the video 3624 * Don't use line buffers if width is greater than the video
3618 * port's line buffer size 3625 * port's line buffer size
@@ -3633,8 +3640,9 @@ static void dsi_config_vp_num_line_buffers(struct omap_dss_device *dssdev)
3633static void dsi_config_vp_sync_events(struct omap_dss_device *dssdev) 3640static void dsi_config_vp_sync_events(struct omap_dss_device *dssdev)
3634{ 3641{
3635 struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev); 3642 struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev);
3636 bool vsync_end = dssdev->panel.dsi_vm_data.vp_vsync_end; 3643 struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
3637 bool hsync_end = dssdev->panel.dsi_vm_data.vp_hsync_end; 3644 bool vsync_end = dsi->vm_timings.vp_vsync_end;
3645 bool hsync_end = dsi->vm_timings.vp_hsync_end;
3638 u32 r; 3646 u32 r;
3639 3647
3640 r = dsi_read_reg(dsidev, DSI_CTRL); 3648 r = dsi_read_reg(dsidev, DSI_CTRL);
@@ -3651,10 +3659,11 @@ static void dsi_config_vp_sync_events(struct omap_dss_device *dssdev)
3651static void dsi_config_blanking_modes(struct omap_dss_device *dssdev) 3659static void dsi_config_blanking_modes(struct omap_dss_device *dssdev)
3652{ 3660{
3653 struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev); 3661 struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev);
3654 int blanking_mode = dssdev->panel.dsi_vm_data.blanking_mode; 3662 struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
3655 int hfp_blanking_mode = dssdev->panel.dsi_vm_data.hfp_blanking_mode; 3663 int blanking_mode = dsi->vm_timings.blanking_mode;
3656 int hbp_blanking_mode = dssdev->panel.dsi_vm_data.hbp_blanking_mode; 3664 int hfp_blanking_mode = dsi->vm_timings.hfp_blanking_mode;
3657 int hsa_blanking_mode = dssdev->panel.dsi_vm_data.hsa_blanking_mode; 3665 int hbp_blanking_mode = dsi->vm_timings.hbp_blanking_mode;
3666 int hsa_blanking_mode = dsi->vm_timings.hsa_blanking_mode;
3658 u32 r; 3667 u32 r;
3659 3668
3660 /* 3669 /*
@@ -3741,8 +3750,8 @@ static void dsi_config_cmd_mode_interleaving(struct omap_dss_device *dssdev)
3741 int ddr_clk_pre, ddr_clk_post, enter_hs_mode_lat, exit_hs_mode_lat; 3750 int ddr_clk_pre, ddr_clk_post, enter_hs_mode_lat, exit_hs_mode_lat;
3742 int tclk_trail, ths_exit, exiths_clk; 3751 int tclk_trail, ths_exit, exiths_clk;
3743 bool ddr_alwon; 3752 bool ddr_alwon;
3744 struct omap_video_timings *timings = &dssdev->panel.timings; 3753 struct omap_video_timings *timings = &dsi->timings;
3745 int bpp = dsi_get_pixel_size(dssdev->panel.dsi_pix_fmt); 3754 int bpp = dsi_get_pixel_size(dsi->pix_fmt);
3746 int ndl = dsi->num_lanes_used - 1; 3755 int ndl = dsi->num_lanes_used - 1;
3747 int dsi_fclk_hsdiv = dssdev->clocks.dsi.regm_dsi + 1; 3756 int dsi_fclk_hsdiv = dssdev->clocks.dsi.regm_dsi + 1;
3748 int hsa_interleave_hs = 0, hsa_interleave_lp = 0; 3757 int hsa_interleave_hs = 0, hsa_interleave_lp = 0;
@@ -3852,6 +3861,7 @@ static void dsi_config_cmd_mode_interleaving(struct omap_dss_device *dssdev)
3852static int dsi_proto_config(struct omap_dss_device *dssdev) 3861static int dsi_proto_config(struct omap_dss_device *dssdev)
3853{ 3862{
3854 struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev); 3863 struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev);
3864 struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
3855 u32 r; 3865 u32 r;
3856 int buswidth = 0; 3866 int buswidth = 0;
3857 3867
@@ -3871,7 +3881,7 @@ static int dsi_proto_config(struct omap_dss_device *dssdev)
3871 dsi_set_lp_rx_timeout(dsidev, 0x1fff, true, true); 3881 dsi_set_lp_rx_timeout(dsidev, 0x1fff, true, true);
3872 dsi_set_hs_tx_timeout(dsidev, 0x1fff, true, true); 3882 dsi_set_hs_tx_timeout(dsidev, 0x1fff, true, true);
3873 3883
3874 switch (dsi_get_pixel_size(dssdev->panel.dsi_pix_fmt)) { 3884 switch (dsi_get_pixel_size(dsi->pix_fmt)) {
3875 case 16: 3885 case 16:
3876 buswidth = 0; 3886 buswidth = 0;
3877 break; 3887 break;
@@ -3905,7 +3915,7 @@ static int dsi_proto_config(struct omap_dss_device *dssdev)
3905 3915
3906 dsi_config_vp_num_line_buffers(dssdev); 3916 dsi_config_vp_num_line_buffers(dssdev);
3907 3917
3908 if (dssdev->panel.dsi_mode == OMAP_DSS_DSI_VIDEO_MODE) { 3918 if (dsi->mode == OMAP_DSS_DSI_VIDEO_MODE) {
3909 dsi_config_vp_sync_events(dssdev); 3919 dsi_config_vp_sync_events(dssdev);
3910 dsi_config_blanking_modes(dssdev); 3920 dsi_config_blanking_modes(dssdev);
3911 dsi_config_cmd_mode_interleaving(dssdev); 3921 dsi_config_cmd_mode_interleaving(dssdev);
@@ -3984,18 +3994,18 @@ static void dsi_proto_timings(struct omap_dss_device *dssdev)
3984 DSSDBG("enter_hs_mode_lat %u, exit_hs_mode_lat %u\n", 3994 DSSDBG("enter_hs_mode_lat %u, exit_hs_mode_lat %u\n",
3985 enter_hs_mode_lat, exit_hs_mode_lat); 3995 enter_hs_mode_lat, exit_hs_mode_lat);
3986 3996
3987 if (dssdev->panel.dsi_mode == OMAP_DSS_DSI_VIDEO_MODE) { 3997 if (dsi->mode == OMAP_DSS_DSI_VIDEO_MODE) {
3988 /* TODO: Implement a video mode check_timings function */ 3998 /* TODO: Implement a video mode check_timings function */
3989 int hsa = dssdev->panel.dsi_vm_data.hsa; 3999 int hsa = dsi->vm_timings.hsa;
3990 int hfp = dssdev->panel.dsi_vm_data.hfp; 4000 int hfp = dsi->vm_timings.hfp;
3991 int hbp = dssdev->panel.dsi_vm_data.hbp; 4001 int hbp = dsi->vm_timings.hbp;
3992 int vsa = dssdev->panel.dsi_vm_data.vsa; 4002 int vsa = dsi->vm_timings.vsa;
3993 int vfp = dssdev->panel.dsi_vm_data.vfp; 4003 int vfp = dsi->vm_timings.vfp;
3994 int vbp = dssdev->panel.dsi_vm_data.vbp; 4004 int vbp = dsi->vm_timings.vbp;
3995 int window_sync = dssdev->panel.dsi_vm_data.window_sync; 4005 int window_sync = dsi->vm_timings.window_sync;
3996 bool hsync_end = dssdev->panel.dsi_vm_data.vp_hsync_end; 4006 bool hsync_end = dsi->vm_timings.vp_hsync_end;
3997 struct omap_video_timings *timings = &dssdev->panel.timings; 4007 struct omap_video_timings *timings = &dsi->timings;
3998 int bpp = dsi_get_pixel_size(dssdev->panel.dsi_pix_fmt); 4008 int bpp = dsi_get_pixel_size(dsi->pix_fmt);
3999 int tl, t_he, width_bytes; 4009 int tl, t_he, width_bytes;
4000 4010
4001 t_he = hsync_end ? 4011 t_he = hsync_end ?
@@ -4103,13 +4113,14 @@ EXPORT_SYMBOL(omapdss_dsi_configure_pins);
4103int dsi_enable_video_output(struct omap_dss_device *dssdev, int channel) 4113int dsi_enable_video_output(struct omap_dss_device *dssdev, int channel)
4104{ 4114{
4105 struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev); 4115 struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev);
4106 int bpp = dsi_get_pixel_size(dssdev->panel.dsi_pix_fmt); 4116 struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
4117 int bpp = dsi_get_pixel_size(dsi->pix_fmt);
4107 u8 data_type; 4118 u8 data_type;
4108 u16 word_count; 4119 u16 word_count;
4109 int r; 4120 int r;
4110 4121
4111 if (dssdev->panel.dsi_mode == OMAP_DSS_DSI_VIDEO_MODE) { 4122 if (dsi->mode == OMAP_DSS_DSI_VIDEO_MODE) {
4112 switch (dssdev->panel.dsi_pix_fmt) { 4123 switch (dsi->pix_fmt) {
4113 case OMAP_DSS_DSI_FMT_RGB888: 4124 case OMAP_DSS_DSI_FMT_RGB888:
4114 data_type = MIPI_DSI_PACKED_PIXEL_STREAM_24; 4125 data_type = MIPI_DSI_PACKED_PIXEL_STREAM_24;
4115 break; 4126 break;
@@ -4133,7 +4144,7 @@ int dsi_enable_video_output(struct omap_dss_device *dssdev, int channel)
4133 /* MODE, 1 = video mode */ 4144 /* MODE, 1 = video mode */
4134 REG_FLD_MOD(dsidev, DSI_VC_CTRL(channel), 1, 4, 4); 4145 REG_FLD_MOD(dsidev, DSI_VC_CTRL(channel), 1, 4, 4);
4135 4146
4136 word_count = DIV_ROUND_UP(dssdev->panel.timings.x_res * bpp, 8); 4147 word_count = DIV_ROUND_UP(dsi->timings.x_res * bpp, 8);
4137 4148
4138 dsi_vc_write_long_header(dsidev, channel, data_type, 4149 dsi_vc_write_long_header(dsidev, channel, data_type,
4139 word_count, 0); 4150 word_count, 0);
@@ -4144,7 +4155,7 @@ int dsi_enable_video_output(struct omap_dss_device *dssdev, int channel)
4144 4155
4145 r = dss_mgr_enable(dssdev->manager); 4156 r = dss_mgr_enable(dssdev->manager);
4146 if (r) { 4157 if (r) {
4147 if (dssdev->panel.dsi_mode == OMAP_DSS_DSI_VIDEO_MODE) { 4158 if (dsi->mode == OMAP_DSS_DSI_VIDEO_MODE) {
4148 dsi_if_enable(dsidev, false); 4159 dsi_if_enable(dsidev, false);
4149 dsi_vc_enable(dsidev, channel, false); 4160 dsi_vc_enable(dsidev, channel, false);
4150 } 4161 }
@@ -4159,8 +4170,9 @@ EXPORT_SYMBOL(dsi_enable_video_output);
4159void dsi_disable_video_output(struct omap_dss_device *dssdev, int channel) 4170void dsi_disable_video_output(struct omap_dss_device *dssdev, int channel)
4160{ 4171{
4161 struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev); 4172 struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev);
4173 struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
4162 4174
4163 if (dssdev->panel.dsi_mode == OMAP_DSS_DSI_VIDEO_MODE) { 4175 if (dsi->mode == OMAP_DSS_DSI_VIDEO_MODE) {
4164 dsi_if_enable(dsidev, false); 4176 dsi_if_enable(dsidev, false);
4165 dsi_vc_enable(dsidev, channel, false); 4177 dsi_vc_enable(dsidev, channel, false);
4166 4178
@@ -4175,8 +4187,7 @@ void dsi_disable_video_output(struct omap_dss_device *dssdev, int channel)
4175} 4187}
4176EXPORT_SYMBOL(dsi_disable_video_output); 4188EXPORT_SYMBOL(dsi_disable_video_output);
4177 4189
4178static void dsi_update_screen_dispc(struct omap_dss_device *dssdev, 4190static void dsi_update_screen_dispc(struct omap_dss_device *dssdev)
4179 u16 w, u16 h)
4180{ 4191{
4181 struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev); 4192 struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev);
4182 struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev); 4193 struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
@@ -4190,12 +4201,14 @@ static void dsi_update_screen_dispc(struct omap_dss_device *dssdev,
4190 int r; 4201 int r;
4191 const unsigned channel = dsi->update_channel; 4202 const unsigned channel = dsi->update_channel;
4192 const unsigned line_buf_size = dsi_get_line_buf_size(dsidev); 4203 const unsigned line_buf_size = dsi_get_line_buf_size(dsidev);
4204 u16 w = dsi->timings.x_res;
4205 u16 h = dsi->timings.y_res;
4193 4206
4194 DSSDBG("dsi_update_screen_dispc(%dx%d)\n", w, h); 4207 DSSDBG("dsi_update_screen_dispc(%dx%d)\n", w, h);
4195 4208
4196 dsi_vc_config_source(dsidev, channel, DSI_VC_SOURCE_VP); 4209 dsi_vc_config_source(dsidev, channel, DSI_VC_SOURCE_VP);
4197 4210
4198 bytespp = dsi_get_pixel_size(dssdev->panel.dsi_pix_fmt) / 8; 4211 bytespp = dsi_get_pixel_size(dsi->pix_fmt) / 8;
4199 bytespl = w * bytespp; 4212 bytespl = w * bytespp;
4200 bytespf = bytespl * h; 4213 bytespf = bytespl * h;
4201 4214
@@ -4239,6 +4252,8 @@ static void dsi_update_screen_dispc(struct omap_dss_device *dssdev,
4239 msecs_to_jiffies(250)); 4252 msecs_to_jiffies(250));
4240 BUG_ON(r == 0); 4253 BUG_ON(r == 0);
4241 4254
4255 dss_mgr_set_timings(dssdev->manager, &dsi->timings);
4256
4242 dss_mgr_start_update(dssdev->manager); 4257 dss_mgr_start_update(dssdev->manager);
4243 4258
4244 if (dsi->te_enabled) { 4259 if (dsi->te_enabled) {
@@ -4325,13 +4340,14 @@ int omap_dsi_update(struct omap_dss_device *dssdev, int channel,
4325 dsi->framedone_callback = callback; 4340 dsi->framedone_callback = callback;
4326 dsi->framedone_data = data; 4341 dsi->framedone_data = data;
4327 4342
4328 dssdev->driver->get_resolution(dssdev, &dw, &dh); 4343 dw = dsi->timings.x_res;
4344 dh = dsi->timings.y_res;
4329 4345
4330#ifdef DEBUG 4346#ifdef DEBUG
4331 dsi->update_bytes = dw * dh * 4347 dsi->update_bytes = dw * dh *
4332 dsi_get_pixel_size(dssdev->panel.dsi_pix_fmt) / 8; 4348 dsi_get_pixel_size(dsi->pix_fmt) / 8;
4333#endif 4349#endif
4334 dsi_update_screen_dispc(dssdev, dw, dh); 4350 dsi_update_screen_dispc(dssdev);
4335 4351
4336 return 0; 4352 return 0;
4337} 4353}
@@ -4367,23 +4383,16 @@ static int dsi_display_init_dispc(struct omap_dss_device *dssdev)
4367{ 4383{
4368 struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev); 4384 struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev);
4369 struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev); 4385 struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
4370 struct omap_video_timings timings;
4371 int r; 4386 int r;
4372 u32 irq = 0; 4387 u32 irq = 0;
4373 4388
4374 if (dssdev->panel.dsi_mode == OMAP_DSS_DSI_CMD_MODE) { 4389 if (dsi->mode == OMAP_DSS_DSI_CMD_MODE) {
4375 u16 dw, dh; 4390 dsi->timings.hsw = 1;
4376 4391 dsi->timings.hfp = 1;
4377 dssdev->driver->get_resolution(dssdev, &dw, &dh); 4392 dsi->timings.hbp = 1;
4378 4393 dsi->timings.vsw = 1;
4379 timings.x_res = dw; 4394 dsi->timings.vfp = 0;
4380 timings.y_res = dh; 4395 dsi->timings.vbp = 0;
4381 timings.hsw = 1;
4382 timings.hfp = 1;
4383 timings.hbp = 1;
4384 timings.vsw = 1;
4385 timings.vfp = 0;
4386 timings.vbp = 0;
4387 4396
4388 irq = dispc_mgr_get_framedone_irq(dssdev->manager->id); 4397 irq = dispc_mgr_get_framedone_irq(dssdev->manager->id);
4389 4398
@@ -4397,8 +4406,6 @@ static int dsi_display_init_dispc(struct omap_dss_device *dssdev)
4397 dsi->mgr_config.stallmode = true; 4406 dsi->mgr_config.stallmode = true;
4398 dsi->mgr_config.fifohandcheck = true; 4407 dsi->mgr_config.fifohandcheck = true;
4399 } else { 4408 } else {
4400 timings = dssdev->panel.timings;
4401
4402 dsi->mgr_config.stallmode = false; 4409 dsi->mgr_config.stallmode = false;
4403 dsi->mgr_config.fifohandcheck = false; 4410 dsi->mgr_config.fifohandcheck = false;
4404 } 4411 }
@@ -4407,14 +4414,14 @@ static int dsi_display_init_dispc(struct omap_dss_device *dssdev)
4407 * override interlace, logic level and edge related parameters in 4414 * override interlace, logic level and edge related parameters in
4408 * omap_video_timings with default values 4415 * omap_video_timings with default values
4409 */ 4416 */
4410 timings.interlace = false; 4417 dsi->timings.interlace = false;
4411 timings.hsync_level = OMAPDSS_SIG_ACTIVE_HIGH; 4418 dsi->timings.hsync_level = OMAPDSS_SIG_ACTIVE_HIGH;
4412 timings.vsync_level = OMAPDSS_SIG_ACTIVE_HIGH; 4419 dsi->timings.vsync_level = OMAPDSS_SIG_ACTIVE_HIGH;
4413 timings.data_pclk_edge = OMAPDSS_DRIVE_SIG_RISING_EDGE; 4420 dsi->timings.data_pclk_edge = OMAPDSS_DRIVE_SIG_RISING_EDGE;
4414 timings.de_level = OMAPDSS_SIG_ACTIVE_HIGH; 4421 dsi->timings.de_level = OMAPDSS_SIG_ACTIVE_HIGH;
4415 timings.sync_pclk_edge = OMAPDSS_DRIVE_SIG_OPPOSITE_EDGES; 4422 dsi->timings.sync_pclk_edge = OMAPDSS_DRIVE_SIG_OPPOSITE_EDGES;
4416 4423
4417 dss_mgr_set_timings(dssdev->manager, &timings); 4424 dss_mgr_set_timings(dssdev->manager, &dsi->timings);
4418 4425
4419 r = dsi_configure_dispc_clocks(dssdev); 4426 r = dsi_configure_dispc_clocks(dssdev);
4420 if (r) 4427 if (r)
@@ -4422,14 +4429,14 @@ static int dsi_display_init_dispc(struct omap_dss_device *dssdev)
4422 4429
4423 dsi->mgr_config.io_pad_mode = DSS_IO_PAD_MODE_BYPASS; 4430 dsi->mgr_config.io_pad_mode = DSS_IO_PAD_MODE_BYPASS;
4424 dsi->mgr_config.video_port_width = 4431 dsi->mgr_config.video_port_width =
4425 dsi_get_pixel_size(dssdev->panel.dsi_pix_fmt); 4432 dsi_get_pixel_size(dsi->pix_fmt);
4426 dsi->mgr_config.lcden_sig_polarity = 0; 4433 dsi->mgr_config.lcden_sig_polarity = 0;
4427 4434
4428 dss_mgr_set_lcd_config(dssdev->manager, &dsi->mgr_config); 4435 dss_mgr_set_lcd_config(dssdev->manager, &dsi->mgr_config);
4429 4436
4430 return 0; 4437 return 0;
4431err1: 4438err1:
4432 if (dssdev->panel.dsi_mode == OMAP_DSS_DSI_CMD_MODE) 4439 if (dsi->mode == OMAP_DSS_DSI_CMD_MODE)
4433 omap_dispc_unregister_isr(dsi_framedone_irq_callback, 4440 omap_dispc_unregister_isr(dsi_framedone_irq_callback,
4434 (void *) dssdev, irq); 4441 (void *) dssdev, irq);
4435err: 4442err:
@@ -4438,7 +4445,10 @@ err:
4438 4445
4439static void dsi_display_uninit_dispc(struct omap_dss_device *dssdev) 4446static void dsi_display_uninit_dispc(struct omap_dss_device *dssdev)
4440{ 4447{
4441 if (dssdev->panel.dsi_mode == OMAP_DSS_DSI_CMD_MODE) { 4448 struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev);
4449 struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
4450
4451 if (dsi->mode == OMAP_DSS_DSI_CMD_MODE) {
4442 u32 irq; 4452 u32 irq;
4443 4453
4444 irq = dispc_mgr_get_framedone_irq(dssdev->manager->id); 4454 irq = dispc_mgr_get_framedone_irq(dssdev->manager->id);
@@ -4653,6 +4663,76 @@ int omapdss_dsi_enable_te(struct omap_dss_device *dssdev, bool enable)
4653} 4663}
4654EXPORT_SYMBOL(omapdss_dsi_enable_te); 4664EXPORT_SYMBOL(omapdss_dsi_enable_te);
4655 4665
4666void omapdss_dsi_set_timings(struct omap_dss_device *dssdev,
4667 struct omap_video_timings *timings)
4668{
4669 struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev);
4670 struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
4671
4672 mutex_lock(&dsi->lock);
4673
4674 dsi->timings = *timings;
4675
4676 mutex_unlock(&dsi->lock);
4677}
4678EXPORT_SYMBOL(omapdss_dsi_set_timings);
4679
4680void omapdss_dsi_set_size(struct omap_dss_device *dssdev, u16 w, u16 h)
4681{
4682 struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev);
4683 struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
4684
4685 mutex_lock(&dsi->lock);
4686
4687 dsi->timings.x_res = w;
4688 dsi->timings.y_res = h;
4689
4690 mutex_unlock(&dsi->lock);
4691}
4692EXPORT_SYMBOL(omapdss_dsi_set_size);
4693
4694void omapdss_dsi_set_pixel_format(struct omap_dss_device *dssdev,
4695 enum omap_dss_dsi_pixel_format fmt)
4696{
4697 struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev);
4698 struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
4699
4700 mutex_lock(&dsi->lock);
4701
4702 dsi->pix_fmt = fmt;
4703
4704 mutex_unlock(&dsi->lock);
4705}
4706EXPORT_SYMBOL(omapdss_dsi_set_pixel_format);
4707
4708void omapdss_dsi_set_operation_mode(struct omap_dss_device *dssdev,
4709 enum omap_dss_dsi_mode mode)
4710{
4711 struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev);
4712 struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
4713
4714 mutex_lock(&dsi->lock);
4715
4716 dsi->mode = mode;
4717
4718 mutex_unlock(&dsi->lock);
4719}
4720EXPORT_SYMBOL(omapdss_dsi_set_operation_mode);
4721
4722void omapdss_dsi_set_videomode_timings(struct omap_dss_device *dssdev,
4723 struct omap_dss_dsi_videomode_timings *timings)
4724{
4725 struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev);
4726 struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
4727
4728 mutex_lock(&dsi->lock);
4729
4730 dsi->vm_timings = *timings;
4731
4732 mutex_unlock(&dsi->lock);
4733}
4734EXPORT_SYMBOL(omapdss_dsi_set_videomode_timings);
4735
4656static int __init dsi_init_display(struct omap_dss_device *dssdev) 4736static int __init dsi_init_display(struct omap_dss_device *dssdev)
4657{ 4737{
4658 struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev); 4738 struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev);
@@ -4660,7 +4740,7 @@ static int __init dsi_init_display(struct omap_dss_device *dssdev)
4660 4740
4661 DSSDBG("DSI init\n"); 4741 DSSDBG("DSI init\n");
4662 4742
4663 if (dssdev->panel.dsi_mode == OMAP_DSS_DSI_CMD_MODE) { 4743 if (dsi->mode == OMAP_DSS_DSI_CMD_MODE) {
4664 dssdev->caps = OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE | 4744 dssdev->caps = OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE |
4665 OMAP_DSS_DISPLAY_CAP_TEAR_ELIM; 4745 OMAP_DSS_DISPLAY_CAP_TEAR_ELIM;
4666 } 4746 }
diff --git a/drivers/video/omap2/dss/dss.c b/drivers/video/omap2/dss/dss.c
index 4491ab7ef800..92353be58036 100644
--- a/drivers/video/omap2/dss/dss.c
+++ b/drivers/video/omap2/dss/dss.c
@@ -144,7 +144,7 @@ static void dss_restore_context(void)
144#undef SR 144#undef SR
145#undef RR 145#undef RR
146 146
147void dss_sdi_init(u8 datapairs) 147void dss_sdi_init(int datapairs)
148{ 148{
149 u32 l; 149 u32 l;
150 150
diff --git a/drivers/video/omap2/dss/dss.h b/drivers/video/omap2/dss/dss.h
index f67afe76f217..41c00dc63cc5 100644
--- a/drivers/video/omap2/dss/dss.h
+++ b/drivers/video/omap2/dss/dss.h
@@ -206,7 +206,7 @@ int dss_mgr_set_device(struct omap_overlay_manager *mgr,
206 struct omap_dss_device *dssdev); 206 struct omap_dss_device *dssdev);
207int dss_mgr_unset_device(struct omap_overlay_manager *mgr); 207int dss_mgr_unset_device(struct omap_overlay_manager *mgr);
208void dss_mgr_set_timings(struct omap_overlay_manager *mgr, 208void dss_mgr_set_timings(struct omap_overlay_manager *mgr,
209 struct omap_video_timings *timings); 209 const struct omap_video_timings *timings);
210void dss_mgr_set_lcd_config(struct omap_overlay_manager *mgr, 210void dss_mgr_set_lcd_config(struct omap_overlay_manager *mgr,
211 const struct dss_lcd_mgr_config *config); 211 const struct dss_lcd_mgr_config *config);
212const struct omap_video_timings *dss_mgr_get_timings(struct omap_overlay_manager *mgr); 212const struct omap_video_timings *dss_mgr_get_timings(struct omap_overlay_manager *mgr);
@@ -279,7 +279,7 @@ void dss_dump_clocks(struct seq_file *s);
279void dss_debug_dump_clocks(struct seq_file *s); 279void dss_debug_dump_clocks(struct seq_file *s);
280#endif 280#endif
281 281
282void dss_sdi_init(u8 datapairs); 282void dss_sdi_init(int datapairs);
283int dss_sdi_enable(void); 283int dss_sdi_enable(void);
284void dss_sdi_disable(void); 284void dss_sdi_disable(void);
285 285
@@ -469,6 +469,20 @@ static inline unsigned long venc_get_pixel_clock(void)
469 return 0; 469 return 0;
470} 470}
471#endif 471#endif
472int omapdss_venc_display_enable(struct omap_dss_device *dssdev);
473void omapdss_venc_display_disable(struct omap_dss_device *dssdev);
474void omapdss_venc_set_timings(struct omap_dss_device *dssdev,
475 struct omap_video_timings *timings);
476int omapdss_venc_check_timings(struct omap_dss_device *dssdev,
477 struct omap_video_timings *timings);
478u32 omapdss_venc_get_wss(struct omap_dss_device *dssdev);
479int omapdss_venc_set_wss(struct omap_dss_device *dssdev, u32 wss);
480void omapdss_venc_set_type(struct omap_dss_device *dssdev,
481 enum omap_dss_venc_type type);
482void omapdss_venc_invert_vid_out_polarity(struct omap_dss_device *dssdev,
483 bool invert_polarity);
484int venc_panel_init(void);
485void venc_panel_exit(void);
472 486
473/* HDMI */ 487/* HDMI */
474#ifdef CONFIG_OMAP4_DSS_HDMI 488#ifdef CONFIG_OMAP4_DSS_HDMI
@@ -484,7 +498,8 @@ static inline unsigned long hdmi_get_pixel_clock(void)
484#endif 498#endif
485int omapdss_hdmi_display_enable(struct omap_dss_device *dssdev); 499int omapdss_hdmi_display_enable(struct omap_dss_device *dssdev);
486void omapdss_hdmi_display_disable(struct omap_dss_device *dssdev); 500void omapdss_hdmi_display_disable(struct omap_dss_device *dssdev);
487void omapdss_hdmi_display_set_timing(struct omap_dss_device *dssdev); 501void omapdss_hdmi_display_set_timing(struct omap_dss_device *dssdev,
502 struct omap_video_timings *timings);
488int omapdss_hdmi_display_check_timing(struct omap_dss_device *dssdev, 503int omapdss_hdmi_display_check_timing(struct omap_dss_device *dssdev,
489 struct omap_video_timings *timings); 504 struct omap_video_timings *timings);
490int omapdss_hdmi_read_edid(u8 *buf, int len); 505int omapdss_hdmi_read_edid(u8 *buf, int len);
diff --git a/drivers/video/omap2/dss/hdmi.c b/drivers/video/omap2/dss/hdmi.c
index a65dafaa0d72..0cdf24673d48 100644
--- a/drivers/video/omap2/dss/hdmi.c
+++ b/drivers/video/omap2/dss/hdmi.c
@@ -459,7 +459,6 @@ static void hdmi_compute_pll(struct omap_dss_device *dssdev, int phy,
459static int hdmi_power_on(struct omap_dss_device *dssdev) 459static int hdmi_power_on(struct omap_dss_device *dssdev)
460{ 460{
461 int r; 461 int r;
462 const struct hdmi_config *timing;
463 struct omap_video_timings *p; 462 struct omap_video_timings *p;
464 unsigned long phy; 463 unsigned long phy;
465 464
@@ -469,22 +468,10 @@ static int hdmi_power_on(struct omap_dss_device *dssdev)
469 468
470 dss_mgr_disable(dssdev->manager); 469 dss_mgr_disable(dssdev->manager);
471 470
472 p = &dssdev->panel.timings; 471 p = &hdmi.ip_data.cfg.timings;
473 472
474 DSSDBG("hdmi_power_on x_res= %d y_res = %d\n", 473 DSSDBG("hdmi_power_on x_res= %d y_res = %d\n", p->x_res, p->y_res);
475 dssdev->panel.timings.x_res,
476 dssdev->panel.timings.y_res);
477 474
478 timing = hdmi_get_timings();
479 if (timing == NULL) {
480 /* HDMI code 4 corresponds to 640 * 480 VGA */
481 hdmi.ip_data.cfg.cm.code = 4;
482 /* DVI mode 1 corresponds to HDMI 0 to DVI */
483 hdmi.ip_data.cfg.cm.mode = HDMI_DVI;
484 hdmi.ip_data.cfg = vesa_timings[0];
485 } else {
486 hdmi.ip_data.cfg = *timing;
487 }
488 phy = p->pixel_clock; 475 phy = p->pixel_clock;
489 476
490 hdmi_compute_pll(dssdev, phy, &hdmi.ip_data.pll_data); 477 hdmi_compute_pll(dssdev, phy, &hdmi.ip_data.pll_data);
@@ -521,7 +508,7 @@ static int hdmi_power_on(struct omap_dss_device *dssdev)
521 dispc_enable_gamma_table(0); 508 dispc_enable_gamma_table(0);
522 509
523 /* tv size */ 510 /* tv size */
524 dss_mgr_set_timings(dssdev->manager, &dssdev->panel.timings); 511 dss_mgr_set_timings(dssdev->manager, p);
525 512
526 r = hdmi.ip_data.ops->video_enable(&hdmi.ip_data); 513 r = hdmi.ip_data.ops->video_enable(&hdmi.ip_data);
527 if (r) 514 if (r)
@@ -568,13 +555,20 @@ int omapdss_hdmi_display_check_timing(struct omap_dss_device *dssdev,
568 555
569} 556}
570 557
571void omapdss_hdmi_display_set_timing(struct omap_dss_device *dssdev) 558void omapdss_hdmi_display_set_timing(struct omap_dss_device *dssdev,
559 struct omap_video_timings *timings)
572{ 560{
573 struct hdmi_cm cm; 561 struct hdmi_cm cm;
562 const struct hdmi_config *t;
574 563
575 cm = hdmi_get_code(&dssdev->panel.timings); 564 mutex_lock(&hdmi.lock);
576 hdmi.ip_data.cfg.cm.code = cm.code; 565
577 hdmi.ip_data.cfg.cm.mode = cm.mode; 566 cm = hdmi_get_code(timings);
567 hdmi.ip_data.cfg.cm = cm;
568
569 t = hdmi_get_timings();
570 if (t != NULL)
571 hdmi.ip_data.cfg = *t;
578 572
579 if (dssdev->state == OMAP_DSS_DISPLAY_ACTIVE) { 573 if (dssdev->state == OMAP_DSS_DISPLAY_ACTIVE) {
580 int r; 574 int r;
@@ -585,8 +579,10 @@ void omapdss_hdmi_display_set_timing(struct omap_dss_device *dssdev)
585 if (r) 579 if (r)
586 DSSERR("failed to power on device\n"); 580 DSSERR("failed to power on device\n");
587 } else { 581 } else {
588 dss_mgr_set_timings(dssdev->manager, &dssdev->panel.timings); 582 dss_mgr_set_timings(dssdev->manager, &t->timings);
589 } 583 }
584
585 mutex_unlock(&hdmi.lock);
590} 586}
591 587
592static void hdmi_dump_regs(struct seq_file *s) 588static void hdmi_dump_regs(struct seq_file *s)
@@ -930,6 +926,7 @@ static int __init omapdss_hdmihw_probe(struct platform_device *pdev)
930 hdmi.ip_data.core_av_offset = HDMI_CORE_AV; 926 hdmi.ip_data.core_av_offset = HDMI_CORE_AV;
931 hdmi.ip_data.pll_offset = HDMI_PLLCTRL; 927 hdmi.ip_data.pll_offset = HDMI_PLLCTRL;
932 hdmi.ip_data.phy_offset = HDMI_PHY; 928 hdmi.ip_data.phy_offset = HDMI_PHY;
929
933 mutex_init(&hdmi.ip_data.lock); 930 mutex_init(&hdmi.ip_data.lock);
934 931
935 hdmi_panel_init(); 932 hdmi_panel_init();
diff --git a/drivers/video/omap2/dss/hdmi_panel.c b/drivers/video/omap2/dss/hdmi_panel.c
index e10844faadf9..2feb2cdfb60f 100644
--- a/drivers/video/omap2/dss/hdmi_panel.c
+++ b/drivers/video/omap2/dss/hdmi_panel.c
@@ -41,17 +41,32 @@ static struct {
41 41
42static int hdmi_panel_probe(struct omap_dss_device *dssdev) 42static int hdmi_panel_probe(struct omap_dss_device *dssdev)
43{ 43{
44 /* Initialize default timings to VGA in DVI mode */
45 const struct omap_video_timings default_timings = {
46 .x_res = 640,
47 .y_res = 480,
48 .pixel_clock = 25175,
49 .hsw = 96,
50 .hfp = 16,
51 .hbp = 48,
52 .vsw = 2,
53 .vfp = 11,
54 .vbp = 31,
55
56 .vsync_level = OMAPDSS_SIG_ACTIVE_LOW,
57 .hsync_level = OMAPDSS_SIG_ACTIVE_LOW,
58
59 .interlace = false,
60 };
61
44 DSSDBG("ENTER hdmi_panel_probe\n"); 62 DSSDBG("ENTER hdmi_panel_probe\n");
45 63
46 dssdev->panel.timings = (struct omap_video_timings) 64 dssdev->panel.timings = default_timings;
47 { 640, 480, 25175, 96, 16, 48, 2, 11, 31,
48 OMAPDSS_SIG_ACTIVE_LOW, OMAPDSS_SIG_ACTIVE_LOW,
49 false,
50 };
51 65
52 DSSDBG("hdmi_panel_probe x_res= %d y_res = %d\n", 66 DSSDBG("hdmi_panel_probe x_res= %d y_res = %d\n",
53 dssdev->panel.timings.x_res, 67 dssdev->panel.timings.x_res,
54 dssdev->panel.timings.y_res); 68 dssdev->panel.timings.y_res);
69
55 return 0; 70 return 0;
56} 71}
57 72
@@ -228,6 +243,8 @@ static int hdmi_panel_enable(struct omap_dss_device *dssdev)
228 goto err; 243 goto err;
229 } 244 }
230 245
246 omapdss_hdmi_display_set_timing(dssdev, &dssdev->panel.timings);
247
231 r = omapdss_hdmi_display_enable(dssdev); 248 r = omapdss_hdmi_display_enable(dssdev);
232 if (r) { 249 if (r) {
233 DSSERR("failed to power on\n"); 250 DSSERR("failed to power on\n");
@@ -336,8 +353,8 @@ static void hdmi_set_timings(struct omap_dss_device *dssdev,
336 */ 353 */
337 hdmi_panel_audio_disable(dssdev); 354 hdmi_panel_audio_disable(dssdev);
338 355
356 omapdss_hdmi_display_set_timing(dssdev, timings);
339 dssdev->panel.timings = *timings; 357 dssdev->panel.timings = *timings;
340 omapdss_hdmi_display_set_timing(dssdev);
341 358
342 mutex_unlock(&hdmi.lock); 359 mutex_unlock(&hdmi.lock);
343} 360}
diff --git a/drivers/video/omap2/dss/rfbi.c b/drivers/video/omap2/dss/rfbi.c
index 7c087424b634..5a9c0e9d8710 100644
--- a/drivers/video/omap2/dss/rfbi.c
+++ b/drivers/video/omap2/dss/rfbi.c
@@ -111,6 +111,11 @@ static struct {
111 struct omap_dss_device *dssdev[2]; 111 struct omap_dss_device *dssdev[2];
112 112
113 struct semaphore bus_lock; 113 struct semaphore bus_lock;
114
115 struct omap_video_timings timings;
116 int pixel_size;
117 int data_lines;
118 struct rfbi_timings intf_timings;
114} rfbi; 119} rfbi;
115 120
116static inline void rfbi_write_reg(const struct rfbi_reg idx, u32 val) 121static inline void rfbi_write_reg(const struct rfbi_reg idx, u32 val)
@@ -300,28 +305,20 @@ void omap_rfbi_write_pixels(const void __iomem *buf, int scr_width,
300} 305}
301EXPORT_SYMBOL(omap_rfbi_write_pixels); 306EXPORT_SYMBOL(omap_rfbi_write_pixels);
302 307
303static int rfbi_transfer_area(struct omap_dss_device *dssdev, u16 width, 308static int rfbi_transfer_area(struct omap_dss_device *dssdev,
304 u16 height, void (*callback)(void *data), void *data) 309 void (*callback)(void *data), void *data)
305{ 310{
306 u32 l; 311 u32 l;
307 int r; 312 int r;
308 struct omap_video_timings timings = { 313 u16 width = rfbi.timings.x_res;
309 .hsw = 1, 314 u16 height = rfbi.timings.y_res;
310 .hfp = 1,
311 .hbp = 1,
312 .vsw = 1,
313 .vfp = 0,
314 .vbp = 0,
315 .x_res = width,
316 .y_res = height,
317 };
318 315
319 /*BUG_ON(callback == 0);*/ 316 /*BUG_ON(callback == 0);*/
320 BUG_ON(rfbi.framedone_callback != NULL); 317 BUG_ON(rfbi.framedone_callback != NULL);
321 318
322 DSSDBG("rfbi_transfer_area %dx%d\n", width, height); 319 DSSDBG("rfbi_transfer_area %dx%d\n", width, height);
323 320
324 dss_mgr_set_timings(dssdev->manager, &timings); 321 dss_mgr_set_timings(dssdev->manager, &rfbi.timings);
325 322
326 r = dss_mgr_enable(dssdev->manager); 323 r = dss_mgr_enable(dssdev->manager);
327 if (r) 324 if (r)
@@ -770,62 +767,45 @@ static int rfbi_configure(int rfbi_module, int bpp, int lines)
770 return 0; 767 return 0;
771} 768}
772 769
773int omap_rfbi_configure(struct omap_dss_device *dssdev, int pixel_size, 770int omap_rfbi_configure(struct omap_dss_device *dssdev)
774 int data_lines)
775{ 771{
776 return rfbi_configure(dssdev->phy.rfbi.channel, pixel_size, data_lines); 772 return rfbi_configure(dssdev->phy.rfbi.channel, rfbi.pixel_size,
773 rfbi.data_lines);
777} 774}
778EXPORT_SYMBOL(omap_rfbi_configure); 775EXPORT_SYMBOL(omap_rfbi_configure);
779 776
780int omap_rfbi_prepare_update(struct omap_dss_device *dssdev, 777int omap_rfbi_update(struct omap_dss_device *dssdev, void (*callback)(void *),
781 u16 *x, u16 *y, u16 *w, u16 *h) 778 void *data)
782{ 779{
783 u16 dw, dh; 780 return rfbi_transfer_area(dssdev, callback, data);
784 struct omap_video_timings timings = { 781}
785 .hsw = 1, 782EXPORT_SYMBOL(omap_rfbi_update);
786 .hfp = 1,
787 .hbp = 1,
788 .vsw = 1,
789 .vfp = 0,
790 .vbp = 0,
791 .x_res = *w,
792 .y_res = *h,
793 };
794
795 dssdev->driver->get_resolution(dssdev, &dw, &dh);
796
797 if (*x > dw || *y > dh)
798 return -EINVAL;
799
800 if (*x + *w > dw)
801 return -EINVAL;
802
803 if (*y + *h > dh)
804 return -EINVAL;
805
806 if (*w == 1)
807 return -EINVAL;
808
809 if (*w == 0 || *h == 0)
810 return -EINVAL;
811
812 dss_mgr_set_timings(dssdev->manager, &timings);
813 783
814 return 0; 784void omapdss_rfbi_set_size(struct omap_dss_device *dssdev, u16 w, u16 h)
785{
786 rfbi.timings.x_res = w;
787 rfbi.timings.y_res = h;
815} 788}
816EXPORT_SYMBOL(omap_rfbi_prepare_update); 789EXPORT_SYMBOL(omapdss_rfbi_set_size);
817 790
818int omap_rfbi_update(struct omap_dss_device *dssdev, 791void omapdss_rfbi_set_pixel_size(struct omap_dss_device *dssdev, int pixel_size)
819 u16 x, u16 y, u16 w, u16 h,
820 void (*callback)(void *), void *data)
821{ 792{
822 int r; 793 rfbi.pixel_size = pixel_size;
794}
795EXPORT_SYMBOL(omapdss_rfbi_set_pixel_size);
823 796
824 r = rfbi_transfer_area(dssdev, w, h, callback, data); 797void omapdss_rfbi_set_data_lines(struct omap_dss_device *dssdev, int data_lines)
798{
799 rfbi.data_lines = data_lines;
800}
801EXPORT_SYMBOL(omapdss_rfbi_set_data_lines);
825 802
826 return r; 803void omapdss_rfbi_set_interface_timings(struct omap_dss_device *dssdev,
804 struct rfbi_timings *timings)
805{
806 rfbi.intf_timings = *timings;
827} 807}
828EXPORT_SYMBOL(omap_rfbi_update); 808EXPORT_SYMBOL(omapdss_rfbi_set_interface_timings);
829 809
830static void rfbi_dump_regs(struct seq_file *s) 810static void rfbi_dump_regs(struct seq_file *s)
831{ 811{
@@ -877,10 +857,31 @@ static void rfbi_config_lcd_manager(struct omap_dss_device *dssdev)
877 /* Do we need fifohandcheck for RFBI? */ 857 /* Do we need fifohandcheck for RFBI? */
878 mgr_config.fifohandcheck = false; 858 mgr_config.fifohandcheck = false;
879 859
880 mgr_config.video_port_width = dssdev->ctrl.pixel_size; 860 mgr_config.video_port_width = rfbi.pixel_size;
881 mgr_config.lcden_sig_polarity = 0; 861 mgr_config.lcden_sig_polarity = 0;
882 862
883 dss_mgr_set_lcd_config(dssdev->manager, &mgr_config); 863 dss_mgr_set_lcd_config(dssdev->manager, &mgr_config);
864
865 /*
866 * Set rfbi.timings with default values, the x_res and y_res fields
867 * are expected to be already configured by the panel driver via
868 * omapdss_rfbi_set_size()
869 */
870 rfbi.timings.hsw = 1;
871 rfbi.timings.hfp = 1;
872 rfbi.timings.hbp = 1;
873 rfbi.timings.vsw = 1;
874 rfbi.timings.vfp = 0;
875 rfbi.timings.vbp = 0;
876
877 rfbi.timings.interlace = false;
878 rfbi.timings.hsync_level = OMAPDSS_SIG_ACTIVE_HIGH;
879 rfbi.timings.vsync_level = OMAPDSS_SIG_ACTIVE_HIGH;
880 rfbi.timings.data_pclk_edge = OMAPDSS_DRIVE_SIG_RISING_EDGE;
881 rfbi.timings.de_level = OMAPDSS_SIG_ACTIVE_HIGH;
882 rfbi.timings.sync_pclk_edge = OMAPDSS_DRIVE_SIG_OPPOSITE_EDGES;
883
884 dss_mgr_set_timings(dssdev->manager, &rfbi.timings);
884} 885}
885 886
886int omapdss_rfbi_display_enable(struct omap_dss_device *dssdev) 887int omapdss_rfbi_display_enable(struct omap_dss_device *dssdev)
@@ -911,13 +912,10 @@ int omapdss_rfbi_display_enable(struct omap_dss_device *dssdev)
911 912
912 rfbi_config_lcd_manager(dssdev); 913 rfbi_config_lcd_manager(dssdev);
913 914
914 rfbi_configure(dssdev->phy.rfbi.channel, 915 rfbi_configure(dssdev->phy.rfbi.channel, rfbi.pixel_size,
915 dssdev->ctrl.pixel_size, 916 rfbi.data_lines);
916 dssdev->phy.rfbi.data_lines);
917
918 rfbi_set_timings(dssdev->phy.rfbi.channel,
919 &dssdev->ctrl.rfbi_timings);
920 917
918 rfbi_set_timings(dssdev->phy.rfbi.channel, &rfbi.intf_timings);
921 919
922 return 0; 920 return 0;
923err1: 921err1:
diff --git a/drivers/video/omap2/dss/sdi.c b/drivers/video/omap2/dss/sdi.c
index 5d31699fbd3c..3bf1bfe29585 100644
--- a/drivers/video/omap2/dss/sdi.c
+++ b/drivers/video/omap2/dss/sdi.c
@@ -34,6 +34,8 @@ static struct {
34 struct regulator *vdds_sdi_reg; 34 struct regulator *vdds_sdi_reg;
35 35
36 struct dss_lcd_mgr_config mgr_config; 36 struct dss_lcd_mgr_config mgr_config;
37 struct omap_video_timings timings;
38 int datapairs;
37} sdi; 39} sdi;
38 40
39static void sdi_config_lcd_manager(struct omap_dss_device *dssdev) 41static void sdi_config_lcd_manager(struct omap_dss_device *dssdev)
@@ -51,7 +53,7 @@ static void sdi_config_lcd_manager(struct omap_dss_device *dssdev)
51 53
52int omapdss_sdi_display_enable(struct omap_dss_device *dssdev) 54int omapdss_sdi_display_enable(struct omap_dss_device *dssdev)
53{ 55{
54 struct omap_video_timings *t = &dssdev->panel.timings; 56 struct omap_video_timings *t = &sdi.timings;
55 struct dss_clock_info dss_cinfo; 57 struct dss_clock_info dss_cinfo;
56 struct dispc_clock_info dispc_cinfo; 58 struct dispc_clock_info dispc_cinfo;
57 unsigned long pck; 59 unsigned long pck;
@@ -77,8 +79,8 @@ int omapdss_sdi_display_enable(struct omap_dss_device *dssdev)
77 goto err_get_dispc; 79 goto err_get_dispc;
78 80
79 /* 15.5.9.1.2 */ 81 /* 15.5.9.1.2 */
80 dssdev->panel.timings.data_pclk_edge = OMAPDSS_DRIVE_SIG_RISING_EDGE; 82 t->data_pclk_edge = OMAPDSS_DRIVE_SIG_RISING_EDGE;
81 dssdev->panel.timings.sync_pclk_edge = OMAPDSS_DRIVE_SIG_RISING_EDGE; 83 t->sync_pclk_edge = OMAPDSS_DRIVE_SIG_RISING_EDGE;
82 84
83 r = dss_calc_clock_div(t->pixel_clock * 1000, &dss_cinfo, &dispc_cinfo); 85 r = dss_calc_clock_div(t->pixel_clock * 1000, &dss_cinfo, &dispc_cinfo);
84 if (r) 86 if (r)
@@ -105,7 +107,8 @@ int omapdss_sdi_display_enable(struct omap_dss_device *dssdev)
105 107
106 sdi_config_lcd_manager(dssdev); 108 sdi_config_lcd_manager(dssdev);
107 109
108 dss_sdi_init(dssdev->phy.sdi.datapairs); 110 dss_sdi_init(sdi.datapairs);
111
109 r = dss_sdi_enable(); 112 r = dss_sdi_enable();
110 if (r) 113 if (r)
111 goto err_sdi_enable; 114 goto err_sdi_enable;
@@ -146,6 +149,29 @@ void omapdss_sdi_display_disable(struct omap_dss_device *dssdev)
146} 149}
147EXPORT_SYMBOL(omapdss_sdi_display_disable); 150EXPORT_SYMBOL(omapdss_sdi_display_disable);
148 151
152void omapdss_sdi_set_timings(struct omap_dss_device *dssdev,
153 struct omap_video_timings *timings)
154{
155 int r;
156
157 sdi.timings = *timings;
158
159 if (dssdev->state == OMAP_DSS_DISPLAY_ACTIVE) {
160 omapdss_sdi_display_disable(dssdev);
161
162 r = omapdss_sdi_display_enable(dssdev);
163 if (r)
164 DSSERR("failed to set new timings\n");
165 }
166}
167EXPORT_SYMBOL(omapdss_sdi_set_timings);
168
169void omapdss_sdi_set_datapairs(struct omap_dss_device *dssdev, int datapairs)
170{
171 sdi.datapairs = datapairs;
172}
173EXPORT_SYMBOL(omapdss_sdi_set_datapairs);
174
149static int __init sdi_init_display(struct omap_dss_device *dssdev) 175static int __init sdi_init_display(struct omap_dss_device *dssdev)
150{ 176{
151 DSSDBG("SDI init\n"); 177 DSSDBG("SDI init\n");
diff --git a/drivers/video/omap2/dss/venc.c b/drivers/video/omap2/dss/venc.c
index 3a220877461a..7d3eef8a010f 100644
--- a/drivers/video/omap2/dss/venc.c
+++ b/drivers/video/omap2/dss/venc.c
@@ -300,6 +300,10 @@ static struct {
300 struct regulator *vdda_dac_reg; 300 struct regulator *vdda_dac_reg;
301 301
302 struct clk *tv_dac_clk; 302 struct clk *tv_dac_clk;
303
304 struct omap_video_timings timings;
305 enum omap_dss_venc_type type;
306 bool invert_polarity;
303} venc; 307} venc;
304 308
305static inline void venc_write_reg(int idx, u32 val) 309static inline void venc_write_reg(int idx, u32 val)
@@ -427,48 +431,48 @@ static int venc_power_on(struct omap_dss_device *dssdev)
427 u32 l; 431 u32 l;
428 int r; 432 int r;
429 433
434 r = venc_runtime_get();
435 if (r)
436 goto err0;
437
430 venc_reset(); 438 venc_reset();
431 venc_write_config(venc_timings_to_config(&dssdev->panel.timings)); 439 venc_write_config(venc_timings_to_config(&venc.timings));
432 440
433 dss_set_venc_output(dssdev->phy.venc.type); 441 dss_set_venc_output(venc.type);
434 dss_set_dac_pwrdn_bgz(1); 442 dss_set_dac_pwrdn_bgz(1);
435 443
436 l = 0; 444 l = 0;
437 445
438 if (dssdev->phy.venc.type == OMAP_DSS_VENC_TYPE_COMPOSITE) 446 if (venc.type == OMAP_DSS_VENC_TYPE_COMPOSITE)
439 l |= 1 << 1; 447 l |= 1 << 1;
440 else /* S-Video */ 448 else /* S-Video */
441 l |= (1 << 0) | (1 << 2); 449 l |= (1 << 0) | (1 << 2);
442 450
443 if (dssdev->phy.venc.invert_polarity == false) 451 if (venc.invert_polarity == false)
444 l |= 1 << 3; 452 l |= 1 << 3;
445 453
446 venc_write_reg(VENC_OUTPUT_CONTROL, l); 454 venc_write_reg(VENC_OUTPUT_CONTROL, l);
447 455
448 dss_mgr_set_timings(dssdev->manager, &dssdev->panel.timings); 456 dss_mgr_set_timings(dssdev->manager, &venc.timings);
449 457
450 r = regulator_enable(venc.vdda_dac_reg); 458 r = regulator_enable(venc.vdda_dac_reg);
451 if (r) 459 if (r)
452 goto err; 460 goto err1;
453
454 if (dssdev->platform_enable)
455 dssdev->platform_enable(dssdev);
456 461
457 r = dss_mgr_enable(dssdev->manager); 462 r = dss_mgr_enable(dssdev->manager);
458 if (r) 463 if (r)
459 goto err; 464 goto err2;
460 465
461 return 0; 466 return 0;
462 467
463err: 468err2:
469 regulator_disable(venc.vdda_dac_reg);
470err1:
464 venc_write_reg(VENC_OUTPUT_CONTROL, 0); 471 venc_write_reg(VENC_OUTPUT_CONTROL, 0);
465 dss_set_dac_pwrdn_bgz(0); 472 dss_set_dac_pwrdn_bgz(0);
466 473
467 if (dssdev->platform_disable) 474 venc_runtime_put();
468 dssdev->platform_disable(dssdev); 475err0:
469
470 regulator_disable(venc.vdda_dac_reg);
471
472 return r; 476 return r;
473} 477}
474 478
@@ -479,10 +483,9 @@ static void venc_power_off(struct omap_dss_device *dssdev)
479 483
480 dss_mgr_disable(dssdev->manager); 484 dss_mgr_disable(dssdev->manager);
481 485
482 if (dssdev->platform_disable)
483 dssdev->platform_disable(dssdev);
484
485 regulator_disable(venc.vdda_dac_reg); 486 regulator_disable(venc.vdda_dac_reg);
487
488 venc_runtime_put();
486} 489}
487 490
488unsigned long venc_get_pixel_clock(void) 491unsigned long venc_get_pixel_clock(void)
@@ -491,171 +494,95 @@ unsigned long venc_get_pixel_clock(void)
491 return 13500000; 494 return 13500000;
492} 495}
493 496
494static ssize_t display_output_type_show(struct device *dev, 497int omapdss_venc_display_enable(struct omap_dss_device *dssdev)
495 struct device_attribute *attr, char *buf)
496{ 498{
497 struct omap_dss_device *dssdev = to_dss_device(dev); 499 int r;
498 const char *ret;
499
500 switch (dssdev->phy.venc.type) {
501 case OMAP_DSS_VENC_TYPE_COMPOSITE:
502 ret = "composite";
503 break;
504 case OMAP_DSS_VENC_TYPE_SVIDEO:
505 ret = "svideo";
506 break;
507 default:
508 return -EINVAL;
509 }
510
511 return snprintf(buf, PAGE_SIZE, "%s\n", ret);
512}
513 500
514static ssize_t display_output_type_store(struct device *dev, 501 DSSDBG("venc_display_enable\n");
515 struct device_attribute *attr, const char *buf, size_t size)
516{
517 struct omap_dss_device *dssdev = to_dss_device(dev);
518 enum omap_dss_venc_type new_type;
519
520 if (sysfs_streq("composite", buf))
521 new_type = OMAP_DSS_VENC_TYPE_COMPOSITE;
522 else if (sysfs_streq("svideo", buf))
523 new_type = OMAP_DSS_VENC_TYPE_SVIDEO;
524 else
525 return -EINVAL;
526 502
527 mutex_lock(&venc.venc_lock); 503 mutex_lock(&venc.venc_lock);
528 504
529 if (dssdev->phy.venc.type != new_type) { 505 if (dssdev->manager == NULL) {
530 dssdev->phy.venc.type = new_type; 506 DSSERR("Failed to enable display: no manager\n");
531 if (dssdev->state == OMAP_DSS_DISPLAY_ACTIVE) { 507 r = -ENODEV;
532 venc_power_off(dssdev); 508 goto err0;
533 venc_power_on(dssdev);
534 }
535 } 509 }
536 510
537 mutex_unlock(&venc.venc_lock);
538
539 return size;
540}
541
542static DEVICE_ATTR(output_type, S_IRUGO | S_IWUSR,
543 display_output_type_show, display_output_type_store);
544
545/* driver */
546static int venc_panel_probe(struct omap_dss_device *dssdev)
547{
548 dssdev->panel.timings = omap_dss_pal_timings;
549
550 return device_create_file(&dssdev->dev, &dev_attr_output_type);
551}
552
553static void venc_panel_remove(struct omap_dss_device *dssdev)
554{
555 device_remove_file(&dssdev->dev, &dev_attr_output_type);
556}
557
558static int venc_panel_enable(struct omap_dss_device *dssdev)
559{
560 int r = 0;
561
562 DSSDBG("venc_enable_display\n");
563
564 mutex_lock(&venc.venc_lock);
565
566 r = omap_dss_start_device(dssdev); 511 r = omap_dss_start_device(dssdev);
567 if (r) { 512 if (r) {
568 DSSERR("failed to start device\n"); 513 DSSERR("failed to start device\n");
569 goto err0; 514 goto err0;
570 } 515 }
571 516
572 if (dssdev->state != OMAP_DSS_DISPLAY_DISABLED) { 517 if (dssdev->platform_enable)
573 r = -EINVAL; 518 dssdev->platform_enable(dssdev);
574 goto err1;
575 }
576 519
577 r = venc_runtime_get();
578 if (r)
579 goto err1;
580 520
581 r = venc_power_on(dssdev); 521 r = venc_power_on(dssdev);
582 if (r) 522 if (r)
583 goto err2; 523 goto err1;
584 524
585 venc.wss_data = 0; 525 venc.wss_data = 0;
586 526
587 dssdev->state = OMAP_DSS_DISPLAY_ACTIVE;
588
589 mutex_unlock(&venc.venc_lock); 527 mutex_unlock(&venc.venc_lock);
528
590 return 0; 529 return 0;
591err2:
592 venc_runtime_put();
593err1: 530err1:
531 if (dssdev->platform_disable)
532 dssdev->platform_disable(dssdev);
594 omap_dss_stop_device(dssdev); 533 omap_dss_stop_device(dssdev);
595err0: 534err0:
596 mutex_unlock(&venc.venc_lock); 535 mutex_unlock(&venc.venc_lock);
597
598 return r; 536 return r;
599} 537}
600 538
601static void venc_panel_disable(struct omap_dss_device *dssdev) 539void omapdss_venc_display_disable(struct omap_dss_device *dssdev)
602{ 540{
603 DSSDBG("venc_disable_display\n"); 541 DSSDBG("venc_display_disable\n");
604 542
605 mutex_lock(&venc.venc_lock); 543 mutex_lock(&venc.venc_lock);
606 544
607 if (dssdev->state == OMAP_DSS_DISPLAY_DISABLED)
608 goto end;
609
610 if (dssdev->state == OMAP_DSS_DISPLAY_SUSPENDED) {
611 /* suspended is the same as disabled with venc */
612 dssdev->state = OMAP_DSS_DISPLAY_DISABLED;
613 goto end;
614 }
615
616 venc_power_off(dssdev); 545 venc_power_off(dssdev);
617 546
618 venc_runtime_put();
619
620 dssdev->state = OMAP_DSS_DISPLAY_DISABLED;
621
622 omap_dss_stop_device(dssdev); 547 omap_dss_stop_device(dssdev);
623end:
624 mutex_unlock(&venc.venc_lock);
625}
626 548
627static int venc_panel_suspend(struct omap_dss_device *dssdev) 549 if (dssdev->platform_disable)
628{ 550 dssdev->platform_disable(dssdev);
629 venc_panel_disable(dssdev);
630 return 0;
631}
632 551
633static int venc_panel_resume(struct omap_dss_device *dssdev) 552 mutex_unlock(&venc.venc_lock);
634{
635 return venc_panel_enable(dssdev);
636} 553}
637 554
638static void venc_set_timings(struct omap_dss_device *dssdev, 555void omapdss_venc_set_timings(struct omap_dss_device *dssdev,
639 struct omap_video_timings *timings) 556 struct omap_video_timings *timings)
640{ 557{
641 DSSDBG("venc_set_timings\n"); 558 DSSDBG("venc_set_timings\n");
642 559
560 mutex_lock(&venc.venc_lock);
561
643 /* Reset WSS data when the TV standard changes. */ 562 /* Reset WSS data when the TV standard changes. */
644 if (memcmp(&dssdev->panel.timings, timings, sizeof(*timings))) 563 if (memcmp(&venc.timings, timings, sizeof(*timings)))
645 venc.wss_data = 0; 564 venc.wss_data = 0;
646 565
647 dssdev->panel.timings = *timings; 566 venc.timings = *timings;
567
648 if (dssdev->state == OMAP_DSS_DISPLAY_ACTIVE) { 568 if (dssdev->state == OMAP_DSS_DISPLAY_ACTIVE) {
569 int r;
570
649 /* turn the venc off and on to get new timings to use */ 571 /* turn the venc off and on to get new timings to use */
650 venc_panel_disable(dssdev); 572 venc_power_off(dssdev);
651 venc_panel_enable(dssdev); 573
574 r = venc_power_on(dssdev);
575 if (r)
576 DSSERR("failed to power on VENC\n");
652 } else { 577 } else {
653 dss_mgr_set_timings(dssdev->manager, timings); 578 dss_mgr_set_timings(dssdev->manager, timings);
654 } 579 }
580
581 mutex_unlock(&venc.venc_lock);
655} 582}
656 583
657static int venc_check_timings(struct omap_dss_device *dssdev, 584int omapdss_venc_check_timings(struct omap_dss_device *dssdev,
658 struct omap_video_timings *timings) 585 struct omap_video_timings *timings)
659{ 586{
660 DSSDBG("venc_check_timings\n"); 587 DSSDBG("venc_check_timings\n");
661 588
@@ -668,13 +595,13 @@ static int venc_check_timings(struct omap_dss_device *dssdev,
668 return -EINVAL; 595 return -EINVAL;
669} 596}
670 597
671static u32 venc_get_wss(struct omap_dss_device *dssdev) 598u32 omapdss_venc_get_wss(struct omap_dss_device *dssdev)
672{ 599{
673 /* Invert due to VENC_L21_WC_CTL:INV=1 */ 600 /* Invert due to VENC_L21_WC_CTL:INV=1 */
674 return (venc.wss_data >> 8) ^ 0xfffff; 601 return (venc.wss_data >> 8) ^ 0xfffff;
675} 602}
676 603
677static int venc_set_wss(struct omap_dss_device *dssdev, u32 wss) 604int omapdss_venc_set_wss(struct omap_dss_device *dssdev, u32 wss)
678{ 605{
679 const struct venc_config *config; 606 const struct venc_config *config;
680 int r; 607 int r;
@@ -683,7 +610,7 @@ static int venc_set_wss(struct omap_dss_device *dssdev, u32 wss)
683 610
684 mutex_lock(&venc.venc_lock); 611 mutex_lock(&venc.venc_lock);
685 612
686 config = venc_timings_to_config(&dssdev->panel.timings); 613 config = venc_timings_to_config(&venc.timings);
687 614
688 /* Invert due to VENC_L21_WC_CTL:INV=1 */ 615 /* Invert due to VENC_L21_WC_CTL:INV=1 */
689 venc.wss_data = (wss ^ 0xfffff) << 8; 616 venc.wss_data = (wss ^ 0xfffff) << 8;
@@ -703,30 +630,25 @@ err:
703 return r; 630 return r;
704} 631}
705 632
706static struct omap_dss_driver venc_driver = { 633void omapdss_venc_set_type(struct omap_dss_device *dssdev,
707 .probe = venc_panel_probe, 634 enum omap_dss_venc_type type)
708 .remove = venc_panel_remove, 635{
636 mutex_lock(&venc.venc_lock);
709 637
710 .enable = venc_panel_enable, 638 venc.type = type;
711 .disable = venc_panel_disable,
712 .suspend = venc_panel_suspend,
713 .resume = venc_panel_resume,
714 639
715 .get_resolution = omapdss_default_get_resolution, 640 mutex_unlock(&venc.venc_lock);
716 .get_recommended_bpp = omapdss_default_get_recommended_bpp, 641}
717 642
718 .set_timings = venc_set_timings, 643void omapdss_venc_invert_vid_out_polarity(struct omap_dss_device *dssdev,
719 .check_timings = venc_check_timings, 644 bool invert_polarity)
645{
646 mutex_lock(&venc.venc_lock);
720 647
721 .get_wss = venc_get_wss, 648 venc.invert_polarity = invert_polarity;
722 .set_wss = venc_set_wss,
723 649
724 .driver = { 650 mutex_unlock(&venc.venc_lock);
725 .name = "venc", 651}
726 .owner = THIS_MODULE,
727 },
728};
729/* driver end */
730 652
731static int __init venc_init_display(struct omap_dss_device *dssdev) 653static int __init venc_init_display(struct omap_dss_device *dssdev)
732{ 654{
@@ -897,9 +819,9 @@ static int __init omap_venchw_probe(struct platform_device *pdev)
897 819
898 venc_runtime_put(); 820 venc_runtime_put();
899 821
900 r = omap_dss_register_driver(&venc_driver); 822 r = venc_panel_init();
901 if (r) 823 if (r)
902 goto err_reg_panel_driver; 824 goto err_panel_init;
903 825
904 dss_debugfs_create_file("venc", venc_dump_regs); 826 dss_debugfs_create_file("venc", venc_dump_regs);
905 827
@@ -907,7 +829,7 @@ static int __init omap_venchw_probe(struct platform_device *pdev)
907 829
908 return 0; 830 return 0;
909 831
910err_reg_panel_driver: 832err_panel_init:
911err_runtime_get: 833err_runtime_get:
912 pm_runtime_disable(&pdev->dev); 834 pm_runtime_disable(&pdev->dev);
913 venc_put_clocks(); 835 venc_put_clocks();
@@ -923,7 +845,7 @@ static int __exit omap_venchw_remove(struct platform_device *pdev)
923 venc.vdda_dac_reg = NULL; 845 venc.vdda_dac_reg = NULL;
924 } 846 }
925 847
926 omap_dss_unregister_driver(&venc_driver); 848 venc_panel_exit();
927 849
928 pm_runtime_disable(&pdev->dev); 850 pm_runtime_disable(&pdev->dev);
929 venc_put_clocks(); 851 venc_put_clocks();
diff --git a/drivers/video/omap2/dss/venc_panel.c b/drivers/video/omap2/dss/venc_panel.c
new file mode 100644
index 000000000000..d55b8784ecfd
--- /dev/null
+++ b/drivers/video/omap2/dss/venc_panel.c
@@ -0,0 +1,251 @@
1/*
2 * Copyright (C) 2009 Nokia Corporation
3 * Author: Tomi Valkeinen <tomi.valkeinen@nokia.com>
4 *
5 * VENC panel driver
6 *
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License version 2 as published by
9 * the Free Software Foundation.
10 *
11 * This program is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14 * more details.
15 *
16 * You should have received a copy of the GNU General Public License along with
17 * this program. If not, see <http://www.gnu.org/licenses/>.
18 */
19
20#include <linux/kernel.h>
21#include <linux/err.h>
22#include <linux/io.h>
23#include <linux/mutex.h>
24#include <linux/module.h>
25
26#include <video/omapdss.h>
27
28#include "dss.h"
29
30static struct {
31 struct mutex lock;
32} venc_panel;
33
34static ssize_t display_output_type_show(struct device *dev,
35 struct device_attribute *attr, char *buf)
36{
37 struct omap_dss_device *dssdev = to_dss_device(dev);
38 const char *ret;
39
40 switch (dssdev->phy.venc.type) {
41 case OMAP_DSS_VENC_TYPE_COMPOSITE:
42 ret = "composite";
43 break;
44 case OMAP_DSS_VENC_TYPE_SVIDEO:
45 ret = "svideo";
46 break;
47 default:
48 return -EINVAL;
49 }
50
51 return snprintf(buf, PAGE_SIZE, "%s\n", ret);
52}
53
54static ssize_t display_output_type_store(struct device *dev,
55 struct device_attribute *attr, const char *buf, size_t size)
56{
57 struct omap_dss_device *dssdev = to_dss_device(dev);
58 enum omap_dss_venc_type new_type;
59
60 if (sysfs_streq("composite", buf))
61 new_type = OMAP_DSS_VENC_TYPE_COMPOSITE;
62 else if (sysfs_streq("svideo", buf))
63 new_type = OMAP_DSS_VENC_TYPE_SVIDEO;
64 else
65 return -EINVAL;
66
67 mutex_lock(&venc_panel.lock);
68
69 if (dssdev->phy.venc.type != new_type) {
70 dssdev->phy.venc.type = new_type;
71 omapdss_venc_set_type(dssdev, new_type);
72 if (dssdev->state == OMAP_DSS_DISPLAY_ACTIVE) {
73 omapdss_venc_display_disable(dssdev);
74 omapdss_venc_display_enable(dssdev);
75 }
76 }
77
78 mutex_unlock(&venc_panel.lock);
79
80 return size;
81}
82
83static DEVICE_ATTR(output_type, S_IRUGO | S_IWUSR,
84 display_output_type_show, display_output_type_store);
85
86static int venc_panel_probe(struct omap_dss_device *dssdev)
87{
88 /* set default timings to PAL */
89 const struct omap_video_timings default_timings = {
90 .x_res = 720,
91 .y_res = 574,
92 .pixel_clock = 13500,
93 .hsw = 64,
94 .hfp = 12,
95 .hbp = 68,
96 .vsw = 5,
97 .vfp = 5,
98 .vbp = 41,
99
100 .vsync_level = OMAPDSS_SIG_ACTIVE_HIGH,
101 .hsync_level = OMAPDSS_SIG_ACTIVE_HIGH,
102
103 .interlace = true,
104 };
105
106 mutex_init(&venc_panel.lock);
107
108 dssdev->panel.timings = default_timings;
109
110 return device_create_file(&dssdev->dev, &dev_attr_output_type);
111}
112
113static void venc_panel_remove(struct omap_dss_device *dssdev)
114{
115 device_remove_file(&dssdev->dev, &dev_attr_output_type);
116}
117
118static int venc_panel_enable(struct omap_dss_device *dssdev)
119{
120 int r;
121
122 dev_dbg(&dssdev->dev, "venc_panel_enable\n");
123
124 mutex_lock(&venc_panel.lock);
125
126 if (dssdev->state != OMAP_DSS_DISPLAY_DISABLED) {
127 r = -EINVAL;
128 goto err;
129 }
130
131 omapdss_venc_set_timings(dssdev, &dssdev->panel.timings);
132 omapdss_venc_set_type(dssdev, dssdev->phy.venc.type);
133 omapdss_venc_invert_vid_out_polarity(dssdev,
134 dssdev->phy.venc.invert_polarity);
135
136 r = omapdss_venc_display_enable(dssdev);
137 if (r)
138 goto err;
139
140 dssdev->state = OMAP_DSS_DISPLAY_ACTIVE;
141
142 mutex_unlock(&venc_panel.lock);
143
144 return 0;
145err:
146 mutex_unlock(&venc_panel.lock);
147
148 return r;
149}
150
151static void venc_panel_disable(struct omap_dss_device *dssdev)
152{
153 dev_dbg(&dssdev->dev, "venc_panel_disable\n");
154
155 mutex_lock(&venc_panel.lock);
156
157 if (dssdev->state == OMAP_DSS_DISPLAY_DISABLED)
158 goto end;
159
160 if (dssdev->state == OMAP_DSS_DISPLAY_SUSPENDED) {
161 /* suspended is the same as disabled with venc */
162 dssdev->state = OMAP_DSS_DISPLAY_DISABLED;
163 goto end;
164 }
165
166 omapdss_venc_display_disable(dssdev);
167
168 dssdev->state = OMAP_DSS_DISPLAY_DISABLED;
169end:
170 mutex_unlock(&venc_panel.lock);
171}
172
173static int venc_panel_suspend(struct omap_dss_device *dssdev)
174{
175 venc_panel_disable(dssdev);
176 return 0;
177}
178
179static int venc_panel_resume(struct omap_dss_device *dssdev)
180{
181 return venc_panel_enable(dssdev);
182}
183
184static void venc_panel_set_timings(struct omap_dss_device *dssdev,
185 struct omap_video_timings *timings)
186{
187 dev_dbg(&dssdev->dev, "venc_panel_set_timings\n");
188
189 mutex_lock(&venc_panel.lock);
190
191 omapdss_venc_set_timings(dssdev, timings);
192 dssdev->panel.timings = *timings;
193
194 mutex_unlock(&venc_panel.lock);
195}
196
197static int venc_panel_check_timings(struct omap_dss_device *dssdev,
198 struct omap_video_timings *timings)
199{
200 dev_dbg(&dssdev->dev, "venc_panel_check_timings\n");
201
202 return omapdss_venc_check_timings(dssdev, timings);
203}
204
205static u32 venc_panel_get_wss(struct omap_dss_device *dssdev)
206{
207 dev_dbg(&dssdev->dev, "venc_panel_get_wss\n");
208
209 return omapdss_venc_get_wss(dssdev);
210}
211
212static int venc_panel_set_wss(struct omap_dss_device *dssdev, u32 wss)
213{
214 dev_dbg(&dssdev->dev, "venc_panel_set_wss\n");
215
216 return omapdss_venc_set_wss(dssdev, wss);
217}
218
219static struct omap_dss_driver venc_driver = {
220 .probe = venc_panel_probe,
221 .remove = venc_panel_remove,
222
223 .enable = venc_panel_enable,
224 .disable = venc_panel_disable,
225 .suspend = venc_panel_suspend,
226 .resume = venc_panel_resume,
227
228 .get_resolution = omapdss_default_get_resolution,
229 .get_recommended_bpp = omapdss_default_get_recommended_bpp,
230
231 .set_timings = venc_panel_set_timings,
232 .check_timings = venc_panel_check_timings,
233
234 .get_wss = venc_panel_get_wss,
235 .set_wss = venc_panel_set_wss,
236
237 .driver = {
238 .name = "venc",
239 .owner = THIS_MODULE,
240 },
241};
242
243int venc_panel_init(void)
244{
245 return omap_dss_register_driver(&venc_driver);
246}
247
248void venc_panel_exit(void)
249{
250 omap_dss_unregister_driver(&venc_driver);
251}
diff --git a/include/video/omapdss.h b/include/video/omapdss.h
index a6267a2d292b..b868123e6cf1 100644
--- a/include/video/omapdss.h
+++ b/include/video/omapdss.h
@@ -243,7 +243,7 @@ void rfbi_bus_unlock(void);
243 243
244/* DSI */ 244/* DSI */
245 245
246struct omap_dss_dsi_videomode_data { 246struct omap_dss_dsi_videomode_timings {
247 /* DSI video mode blanking data */ 247 /* DSI video mode blanking data */
248 /* Unit: byte clock cycles */ 248 /* Unit: byte clock cycles */
249 u16 hsa; 249 u16 hsa;
@@ -564,7 +564,7 @@ struct omap_dss_device {
564 564
565 enum omap_dss_dsi_pixel_format dsi_pix_fmt; 565 enum omap_dss_dsi_pixel_format dsi_pix_fmt;
566 enum omap_dss_dsi_mode dsi_mode; 566 enum omap_dss_dsi_mode dsi_mode;
567 struct omap_dss_dsi_videomode_data dsi_vm_data; 567 struct omap_dss_dsi_videomode_timings dsi_vm_timings;
568 } panel; 568 } panel;
569 569
570 struct { 570 struct {
@@ -719,6 +719,15 @@ int omap_dispc_wait_for_irq_interruptible_timeout(u32 irqmask,
719void omapdss_dsi_vc_enable_hs(struct omap_dss_device *dssdev, int channel, 719void omapdss_dsi_vc_enable_hs(struct omap_dss_device *dssdev, int channel,
720 bool enable); 720 bool enable);
721int omapdss_dsi_enable_te(struct omap_dss_device *dssdev, bool enable); 721int omapdss_dsi_enable_te(struct omap_dss_device *dssdev, bool enable);
722void omapdss_dsi_set_timings(struct omap_dss_device *dssdev,
723 struct omap_video_timings *timings);
724void omapdss_dsi_set_size(struct omap_dss_device *dssdev, u16 w, u16 h);
725void omapdss_dsi_set_pixel_format(struct omap_dss_device *dssdev,
726 enum omap_dss_dsi_pixel_format fmt);
727void omapdss_dsi_set_operation_mode(struct omap_dss_device *dssdev,
728 enum omap_dss_dsi_mode mode);
729void omapdss_dsi_set_videomode_timings(struct omap_dss_device *dssdev,
730 struct omap_dss_dsi_videomode_timings *timings);
722 731
723int omap_dsi_update(struct omap_dss_device *dssdev, int channel, 732int omap_dsi_update(struct omap_dss_device *dssdev, int channel,
724 void (*callback)(int, void *), void *data); 733 void (*callback)(int, void *), void *data);
@@ -734,22 +743,29 @@ void omapdss_dsi_display_disable(struct omap_dss_device *dssdev,
734 743
735int omapdss_dpi_display_enable(struct omap_dss_device *dssdev); 744int omapdss_dpi_display_enable(struct omap_dss_device *dssdev);
736void omapdss_dpi_display_disable(struct omap_dss_device *dssdev); 745void omapdss_dpi_display_disable(struct omap_dss_device *dssdev);
737void dpi_set_timings(struct omap_dss_device *dssdev, 746void omapdss_dpi_set_timings(struct omap_dss_device *dssdev,
738 struct omap_video_timings *timings); 747 struct omap_video_timings *timings);
739int dpi_check_timings(struct omap_dss_device *dssdev, 748int dpi_check_timings(struct omap_dss_device *dssdev,
740 struct omap_video_timings *timings); 749 struct omap_video_timings *timings);
750void omapdss_dpi_set_data_lines(struct omap_dss_device *dssdev, int data_lines);
741 751
742int omapdss_sdi_display_enable(struct omap_dss_device *dssdev); 752int omapdss_sdi_display_enable(struct omap_dss_device *dssdev);
743void omapdss_sdi_display_disable(struct omap_dss_device *dssdev); 753void omapdss_sdi_display_disable(struct omap_dss_device *dssdev);
754void omapdss_sdi_set_timings(struct omap_dss_device *dssdev,
755 struct omap_video_timings *timings);
756void omapdss_sdi_set_datapairs(struct omap_dss_device *dssdev, int datapairs);
744 757
745int omapdss_rfbi_display_enable(struct omap_dss_device *dssdev); 758int omapdss_rfbi_display_enable(struct omap_dss_device *dssdev);
746void omapdss_rfbi_display_disable(struct omap_dss_device *dssdev); 759void omapdss_rfbi_display_disable(struct omap_dss_device *dssdev);
747int omap_rfbi_prepare_update(struct omap_dss_device *dssdev, 760int omap_rfbi_update(struct omap_dss_device *dssdev, void (*callback)(void *),
748 u16 *x, u16 *y, u16 *w, u16 *h); 761 void *data);
749int omap_rfbi_update(struct omap_dss_device *dssdev, 762int omap_rfbi_configure(struct omap_dss_device *dssdev);
750 u16 x, u16 y, u16 w, u16 h, 763void omapdss_rfbi_set_size(struct omap_dss_device *dssdev, u16 w, u16 h);
751 void (*callback)(void *), void *data); 764void omapdss_rfbi_set_pixel_size(struct omap_dss_device *dssdev,
752int omap_rfbi_configure(struct omap_dss_device *dssdev, int pixel_size, 765 int pixel_size);
766void omapdss_rfbi_set_data_lines(struct omap_dss_device *dssdev,
753 int data_lines); 767 int data_lines);
768void omapdss_rfbi_set_interface_timings(struct omap_dss_device *dssdev,
769 struct rfbi_timings *timings);
754 770
755#endif 771#endif
generated by cgit v1.2.2 (git 2.25.0) at 2026-01-20 16:31:42 -0500