aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
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 2025-12-25 18:40:39 -0500