OMAPDSS: SDI: Create a function to set timings
[linux-3.10.git] / drivers / video / omap2 / dss / sdi.c
1 /*
2  * linux/drivers/video/omap2/dss/sdi.c
3  *
4  * Copyright (C) 2009 Nokia Corporation
5  * Author: Tomi Valkeinen <tomi.valkeinen@nokia.com>
6  *
7  * This program is free software; you can redistribute it and/or modify it
8  * under the terms of the GNU General Public License version 2 as published by
9  * the Free Software Foundation.
10  *
11  * 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 #define DSS_SUBSYS_NAME "SDI"
21
22 #include <linux/kernel.h>
23 #include <linux/delay.h>
24 #include <linux/err.h>
25 #include <linux/regulator/consumer.h>
26 #include <linux/export.h>
27 #include <linux/platform_device.h>
28
29 #include <video/omapdss.h>
30 #include "dss.h"
31
32 static struct {
33         bool update_enabled;
34         struct regulator *vdds_sdi_reg;
35
36         struct dss_lcd_mgr_config mgr_config;
37 } sdi;
38
39 static void sdi_config_lcd_manager(struct omap_dss_device *dssdev)
40 {
41         sdi.mgr_config.io_pad_mode = DSS_IO_PAD_MODE_BYPASS;
42
43         sdi.mgr_config.stallmode = false;
44         sdi.mgr_config.fifohandcheck = false;
45
46         sdi.mgr_config.video_port_width = 24;
47         sdi.mgr_config.lcden_sig_polarity = 1;
48
49         dss_mgr_set_lcd_config(dssdev->manager, &sdi.mgr_config);
50 }
51
52 int omapdss_sdi_display_enable(struct omap_dss_device *dssdev)
53 {
54         struct omap_video_timings *t = &dssdev->panel.timings;
55         struct dss_clock_info dss_cinfo;
56         struct dispc_clock_info dispc_cinfo;
57         unsigned long pck;
58         int r;
59
60         if (dssdev->manager == NULL) {
61                 DSSERR("failed to enable display: no manager\n");
62                 return -ENODEV;
63         }
64
65         r = omap_dss_start_device(dssdev);
66         if (r) {
67                 DSSERR("failed to start device\n");
68                 goto err_start_dev;
69         }
70
71         r = regulator_enable(sdi.vdds_sdi_reg);
72         if (r)
73                 goto err_reg_enable;
74
75         r = dispc_runtime_get();
76         if (r)
77                 goto err_get_dispc;
78
79         /* 15.5.9.1.2 */
80         dssdev->panel.timings.data_pclk_edge = OMAPDSS_DRIVE_SIG_RISING_EDGE;
81         dssdev->panel.timings.sync_pclk_edge = OMAPDSS_DRIVE_SIG_RISING_EDGE;
82
83         r = dss_calc_clock_div(t->pixel_clock * 1000, &dss_cinfo, &dispc_cinfo);
84         if (r)
85                 goto err_calc_clock_div;
86
87         sdi.mgr_config.clock_info = dispc_cinfo;
88
89         pck = dss_cinfo.fck / dispc_cinfo.lck_div / dispc_cinfo.pck_div / 1000;
90
91         if (pck != t->pixel_clock) {
92                 DSSWARN("Could not find exact pixel clock. Requested %d kHz, "
93                                 "got %lu kHz\n",
94                                 t->pixel_clock, pck);
95
96                 t->pixel_clock = pck;
97         }
98
99
100         dss_mgr_set_timings(dssdev->manager, t);
101
102         r = dss_set_clock_div(&dss_cinfo);
103         if (r)
104                 goto err_set_dss_clock_div;
105
106         sdi_config_lcd_manager(dssdev);
107
108         dss_sdi_init(dssdev->phy.sdi.datapairs);
109         r = dss_sdi_enable();
110         if (r)
111                 goto err_sdi_enable;
112         mdelay(2);
113
114         r = dss_mgr_enable(dssdev->manager);
115         if (r)
116                 goto err_mgr_enable;
117
118         return 0;
119
120 err_mgr_enable:
121         dss_sdi_disable();
122 err_sdi_enable:
123 err_set_dss_clock_div:
124 err_calc_clock_div:
125         dispc_runtime_put();
126 err_get_dispc:
127         regulator_disable(sdi.vdds_sdi_reg);
128 err_reg_enable:
129         omap_dss_stop_device(dssdev);
130 err_start_dev:
131         return r;
132 }
133 EXPORT_SYMBOL(omapdss_sdi_display_enable);
134
135 void omapdss_sdi_display_disable(struct omap_dss_device *dssdev)
136 {
137         dss_mgr_disable(dssdev->manager);
138
139         dss_sdi_disable();
140
141         dispc_runtime_put();
142
143         regulator_disable(sdi.vdds_sdi_reg);
144
145         omap_dss_stop_device(dssdev);
146 }
147 EXPORT_SYMBOL(omapdss_sdi_display_disable);
148
149 void omapdss_sdi_set_timings(struct omap_dss_device *dssdev,
150                 struct omap_video_timings *timings)
151 {
152         int r;
153
154         dssdev->panel.timings = *timings;
155
156         if (dssdev->state == OMAP_DSS_DISPLAY_ACTIVE) {
157                 omapdss_sdi_display_disable(dssdev);
158
159                 r = omapdss_sdi_display_enable(dssdev);
160                 if (r)
161                         DSSERR("failed to set new timings\n");
162         }
163 }
164 EXPORT_SYMBOL(omapdss_sdi_set_timings);
165
166 static int __init sdi_init_display(struct omap_dss_device *dssdev)
167 {
168         DSSDBG("SDI init\n");
169
170         if (sdi.vdds_sdi_reg == NULL) {
171                 struct regulator *vdds_sdi;
172
173                 vdds_sdi = dss_get_vdds_sdi();
174
175                 if (IS_ERR(vdds_sdi)) {
176                         DSSERR("can't get VDDS_SDI regulator\n");
177                         return PTR_ERR(vdds_sdi);
178                 }
179
180                 sdi.vdds_sdi_reg = vdds_sdi;
181         }
182
183         return 0;
184 }
185
186 static void __init sdi_probe_pdata(struct platform_device *pdev)
187 {
188         struct omap_dss_board_info *pdata = pdev->dev.platform_data;
189         int i, r;
190
191         for (i = 0; i < pdata->num_devices; ++i) {
192                 struct omap_dss_device *dssdev = pdata->devices[i];
193
194                 if (dssdev->type != OMAP_DISPLAY_TYPE_SDI)
195                         continue;
196
197                 r = sdi_init_display(dssdev);
198                 if (r) {
199                         DSSERR("device %s init failed: %d\n", dssdev->name, r);
200                         continue;
201                 }
202
203                 r = omap_dss_register_device(dssdev, &pdev->dev, i);
204                 if (r)
205                         DSSERR("device %s register failed: %d\n",
206                                         dssdev->name, r);
207         }
208 }
209
210 static int __init omap_sdi_probe(struct platform_device *pdev)
211 {
212         sdi_probe_pdata(pdev);
213
214         return 0;
215 }
216
217 static int __exit omap_sdi_remove(struct platform_device *pdev)
218 {
219         omap_dss_unregister_child_devices(&pdev->dev);
220
221         return 0;
222 }
223
224 static struct platform_driver omap_sdi_driver = {
225         .remove         = __exit_p(omap_sdi_remove),
226         .driver         = {
227                 .name   = "omapdss_sdi",
228                 .owner  = THIS_MODULE,
229         },
230 };
231
232 int __init sdi_init_platform_driver(void)
233 {
234         return platform_driver_probe(&omap_sdi_driver, omap_sdi_probe);
235 }
236
237 void __exit sdi_uninit_platform_driver(void)
238 {
239         platform_driver_unregister(&omap_sdi_driver);
240 }