Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
sdi.c
Go to the documentation of this file.
1 /*
2  * linux/drivers/video/omap2/dss/sdi.c
3  *
4  * Copyright (C) 2009 Nokia Corporation
5  * Author: Tomi Valkeinen <[email protected]>
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>
26 #include <linux/export.h>
27 #include <linux/platform_device.h>
28 #include <linux/string.h>
29 
30 #include <video/omapdss.h>
31 #include "dss.h"
32 
33 static struct {
36 
39  int datapairs;
40 
42 } sdi;
43 
44 static void sdi_config_lcd_manager(struct omap_dss_device *dssdev)
45 {
46  struct omap_overlay_manager *mgr = dssdev->output->manager;
47 
48  sdi.mgr_config.io_pad_mode = DSS_IO_PAD_MODE_BYPASS;
49 
50  sdi.mgr_config.stallmode = false;
51  sdi.mgr_config.fifohandcheck = false;
52 
53  sdi.mgr_config.video_port_width = 24;
54  sdi.mgr_config.lcden_sig_polarity = 1;
55 
56  dss_mgr_set_lcd_config(mgr, &sdi.mgr_config);
57 }
58 
60 {
61  struct omap_dss_output *out = dssdev->output;
62  struct omap_video_timings *t = &sdi.timings;
63  struct dss_clock_info dss_cinfo;
64  struct dispc_clock_info dispc_cinfo;
65  unsigned long pck;
66  int r;
67 
68  if (out == NULL || out->manager == NULL) {
69  DSSERR("failed to enable display: no output/manager\n");
70  return -ENODEV;
71  }
72 
73  r = omap_dss_start_device(dssdev);
74  if (r) {
75  DSSERR("failed to start device\n");
76  goto err_start_dev;
77  }
78 
79  r = regulator_enable(sdi.vdds_sdi_reg);
80  if (r)
81  goto err_reg_enable;
82 
83  r = dispc_runtime_get();
84  if (r)
85  goto err_get_dispc;
86 
87  /* 15.5.9.1.2 */
90 
91  r = dss_calc_clock_div(t->pixel_clock * 1000, &dss_cinfo, &dispc_cinfo);
92  if (r)
93  goto err_calc_clock_div;
94 
95  sdi.mgr_config.clock_info = dispc_cinfo;
96 
97  pck = dss_cinfo.fck / dispc_cinfo.lck_div / dispc_cinfo.pck_div / 1000;
98 
99  if (pck != t->pixel_clock) {
100  DSSWARN("Could not find exact pixel clock. Requested %d kHz, "
101  "got %lu kHz\n",
102  t->pixel_clock, pck);
103 
104  t->pixel_clock = pck;
105  }
106 
107 
108  dss_mgr_set_timings(out->manager, t);
109 
110  r = dss_set_clock_div(&dss_cinfo);
111  if (r)
112  goto err_set_dss_clock_div;
113 
114  sdi_config_lcd_manager(dssdev);
115 
116  /*
117  * LCLK and PCLK divisors are located in shadow registers, and we
118  * normally write them to DISPC registers when enabling the output.
119  * However, SDI uses pck-free as source clock for its PLL, and pck-free
120  * is affected by the divisors. And as we need the PLL before enabling
121  * the output, we need to write the divisors early.
122  *
123  * It seems just writing to the DISPC register is enough, and we don't
124  * need to care about the shadow register mechanism for pck-free. The
125  * exact reason for this is unknown.
126  */
127  dispc_mgr_set_clock_div(out->manager->id, &sdi.mgr_config.clock_info);
128 
129  dss_sdi_init(sdi.datapairs);
130  r = dss_sdi_enable();
131  if (r)
132  goto err_sdi_enable;
133  mdelay(2);
134 
135  r = dss_mgr_enable(out->manager);
136  if (r)
137  goto err_mgr_enable;
138 
139  return 0;
140 
141 err_mgr_enable:
142  dss_sdi_disable();
143 err_sdi_enable:
144 err_set_dss_clock_div:
145 err_calc_clock_div:
147 err_get_dispc:
148  regulator_disable(sdi.vdds_sdi_reg);
149 err_reg_enable:
150  omap_dss_stop_device(dssdev);
151 err_start_dev:
152  return r;
153 }
155 
157 {
158  struct omap_overlay_manager *mgr = dssdev->output->manager;
159 
160  dss_mgr_disable(mgr);
161 
162  dss_sdi_disable();
163 
165 
166  regulator_disable(sdi.vdds_sdi_reg);
167 
168  omap_dss_stop_device(dssdev);
169 }
171 
173  struct omap_video_timings *timings)
174 {
175  sdi.timings = *timings;
176 }
178 
180 {
181  sdi.datapairs = datapairs;
182 }
184 
185 static int __init sdi_init_display(struct omap_dss_device *dssdev)
186 {
187  DSSDBG("SDI init\n");
188 
189  if (sdi.vdds_sdi_reg == NULL) {
190  struct regulator *vdds_sdi;
191 
192  vdds_sdi = dss_get_vdds_sdi();
193 
194  if (IS_ERR(vdds_sdi)) {
195  DSSERR("can't get VDDS_SDI regulator\n");
196  return PTR_ERR(vdds_sdi);
197  }
198 
199  sdi.vdds_sdi_reg = vdds_sdi;
200  }
201 
202  return 0;
203 }
204 
205 static struct omap_dss_device * __init sdi_find_dssdev(struct platform_device *pdev)
206 {
207  struct omap_dss_board_info *pdata = pdev->dev.platform_data;
208  const char *def_disp_name = dss_get_default_display_name();
209  struct omap_dss_device *def_dssdev;
210  int i;
211 
212  def_dssdev = NULL;
213 
214  for (i = 0; i < pdata->num_devices; ++i) {
215  struct omap_dss_device *dssdev = pdata->devices[i];
216 
217  if (dssdev->type != OMAP_DISPLAY_TYPE_SDI)
218  continue;
219 
220  if (def_dssdev == NULL)
221  def_dssdev = dssdev;
222 
223  if (def_disp_name != NULL &&
224  strcmp(dssdev->name, def_disp_name) == 0) {
225  def_dssdev = dssdev;
226  break;
227  }
228  }
229 
230  return def_dssdev;
231 }
232 
233 static void __init sdi_probe_pdata(struct platform_device *sdidev)
234 {
235  struct omap_dss_device *plat_dssdev;
236  struct omap_dss_device *dssdev;
237  int r;
238 
239  plat_dssdev = sdi_find_dssdev(sdidev);
240 
241  if (!plat_dssdev)
242  return;
243 
244  dssdev = dss_alloc_and_init_device(&sdidev->dev);
245  if (!dssdev)
246  return;
247 
248  dss_copy_device_pdata(dssdev, plat_dssdev);
249 
250  r = sdi_init_display(dssdev);
251  if (r) {
252  DSSERR("device %s init failed: %d\n", dssdev->name, r);
253  dss_put_device(dssdev);
254  return;
255  }
256 
257  r = dss_add_device(dssdev);
258  if (r) {
259  DSSERR("device %s register failed: %d\n", dssdev->name, r);
260  dss_put_device(dssdev);
261  return;
262  }
263 }
264 
265 static void __init sdi_init_output(struct platform_device *pdev)
266 {
267  struct omap_dss_output *out = &sdi.output;
268 
269  out->pdev = pdev;
270  out->id = OMAP_DSS_OUTPUT_SDI;
272 
273  dss_register_output(out);
274 }
275 
276 static void __exit sdi_uninit_output(struct platform_device *pdev)
277 {
278  struct omap_dss_output *out = &sdi.output;
279 
281 }
282 
283 static int __init omap_sdi_probe(struct platform_device *pdev)
284 {
285  sdi_init_output(pdev);
286 
287  sdi_probe_pdata(pdev);
288 
289  return 0;
290 }
291 
292 static int __exit omap_sdi_remove(struct platform_device *pdev)
293 {
295 
296  sdi_uninit_output(pdev);
297 
298  return 0;
299 }
300 
301 static struct platform_driver omap_sdi_driver = {
302  .remove = __exit_p(omap_sdi_remove),
303  .driver = {
304  .name = "omapdss_sdi",
305  .owner = THIS_MODULE,
306  },
307 };
308 
310 {
311  return platform_driver_probe(&omap_sdi_driver, omap_sdi_probe);
312 }
313 
315 {
316  platform_driver_unregister(&omap_sdi_driver);
317 }