Commit | Line | Data |
---|---|---|
66715cdc MH |
1 | /* |
2 | * Copyright (C) 2010 Texas Instruments Inc | |
3 | * | |
4 | * This program is free software; you can redistribute it and/or modify | |
5 | * it under the terms of the GNU General Public License as published by | |
6 | * the Free Software Foundation version 2. | |
7 | * | |
8 | * This program is distributed in the hope that it will be useful, | |
9 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
10 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
11 | * GNU General Public License for more details. | |
12 | * | |
13 | * You should have received a copy of the GNU General Public License | |
14 | * along with this program; if not, write to the Free Software | |
15 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
16 | */ | |
17 | #include <linux/kernel.h> | |
18 | #include <linux/init.h> | |
19 | #include <linux/module.h> | |
20 | #include <linux/errno.h> | |
21 | #include <linux/fs.h> | |
22 | #include <linux/string.h> | |
23 | #include <linux/wait.h> | |
24 | #include <linux/time.h> | |
25 | #include <linux/platform_device.h> | |
26 | #include <linux/io.h> | |
27 | #include <linux/slab.h> | |
28 | #include <linux/clk.h> | |
29 | #include <linux/err.h> | |
30 | ||
31 | #include <media/v4l2-device.h> | |
32 | #include <media/davinci/vpbe_types.h> | |
33 | #include <media/davinci/vpbe.h> | |
34 | #include <media/davinci/vpss.h> | |
35 | #include <media/davinci/vpbe_venc.h> | |
36 | ||
37 | #define VPBE_DEFAULT_OUTPUT "Composite" | |
38 | #define VPBE_DEFAULT_MODE "ntsc" | |
39 | ||
40 | static char *def_output = VPBE_DEFAULT_OUTPUT; | |
41 | static char *def_mode = VPBE_DEFAULT_MODE; | |
42 | static int debug; | |
43 | ||
44 | module_param(def_output, charp, S_IRUGO); | |
45 | module_param(def_mode, charp, S_IRUGO); | |
46 | module_param(debug, int, 0644); | |
47 | ||
48 | MODULE_PARM_DESC(def_output, "vpbe output name (default:Composite)"); | |
49 | MODULE_PARM_DESC(def_mode, "vpbe output mode name (default:ntsc"); | |
50 | MODULE_PARM_DESC(debug, "Debug level 0-1"); | |
51 | ||
52 | MODULE_DESCRIPTION("TI DMXXX VPBE Display controller"); | |
53 | MODULE_LICENSE("GPL"); | |
54 | MODULE_AUTHOR("Texas Instruments"); | |
55 | ||
56 | /** | |
57 | * vpbe_current_encoder_info - Get config info for current encoder | |
58 | * @vpbe_dev - vpbe device ptr | |
59 | * | |
60 | * Return ptr to current encoder config info | |
61 | */ | |
62 | static struct encoder_config_info* | |
63 | vpbe_current_encoder_info(struct vpbe_device *vpbe_dev) | |
64 | { | |
65 | struct vpbe_config *cfg = vpbe_dev->cfg; | |
66 | int index = vpbe_dev->current_sd_index; | |
67 | ||
68 | return ((index == 0) ? &cfg->venc : | |
69 | &cfg->ext_encoders[index-1]); | |
70 | } | |
71 | ||
72 | /** | |
73 | * vpbe_find_encoder_sd_index - Given a name find encoder sd index | |
74 | * | |
75 | * @vpbe_config - ptr to vpbe cfg | |
76 | * @output_index - index used by application | |
77 | * | |
78 | * Return sd index of the encoder | |
79 | */ | |
80 | static int vpbe_find_encoder_sd_index(struct vpbe_config *cfg, | |
81 | int index) | |
82 | { | |
83 | char *encoder_name = cfg->outputs[index].subdev_name; | |
84 | int i; | |
85 | ||
86 | /* Venc is always first */ | |
87 | if (!strcmp(encoder_name, cfg->venc.module_name)) | |
88 | return 0; | |
89 | ||
90 | for (i = 0; i < cfg->num_ext_encoders; i++) { | |
91 | if (!strcmp(encoder_name, | |
92 | cfg->ext_encoders[i].module_name)) | |
93 | return i+1; | |
94 | } | |
95 | ||
96 | return -EINVAL; | |
97 | } | |
98 | ||
99 | /** | |
100 | * vpbe_g_cropcap - Get crop capabilities of the display | |
101 | * @vpbe_dev - vpbe device ptr | |
102 | * @cropcap - cropcap is a ptr to struct v4l2_cropcap | |
103 | * | |
104 | * Update the crop capabilities in crop cap for current | |
105 | * mode | |
106 | */ | |
107 | static int vpbe_g_cropcap(struct vpbe_device *vpbe_dev, | |
108 | struct v4l2_cropcap *cropcap) | |
109 | { | |
110 | if (NULL == cropcap) | |
111 | return -EINVAL; | |
112 | cropcap->bounds.left = 0; | |
113 | cropcap->bounds.top = 0; | |
114 | cropcap->bounds.width = vpbe_dev->current_timings.xres; | |
115 | cropcap->bounds.height = vpbe_dev->current_timings.yres; | |
116 | cropcap->defrect = cropcap->bounds; | |
117 | ||
118 | return 0; | |
119 | } | |
120 | ||
121 | /** | |
122 | * vpbe_enum_outputs - enumerate outputs | |
123 | * @vpbe_dev - vpbe device ptr | |
124 | * @output - ptr to v4l2_output structure | |
125 | * | |
126 | * Enumerates the outputs available at the vpbe display | |
127 | * returns the status, -EINVAL if end of output list | |
128 | */ | |
129 | static int vpbe_enum_outputs(struct vpbe_device *vpbe_dev, | |
130 | struct v4l2_output *output) | |
131 | { | |
132 | struct vpbe_config *cfg = vpbe_dev->cfg; | |
133 | int temp_index = output->index; | |
134 | ||
135 | if (temp_index >= cfg->num_outputs) | |
136 | return -EINVAL; | |
137 | ||
138 | *output = cfg->outputs[temp_index].output; | |
139 | output->index = temp_index; | |
140 | ||
141 | return 0; | |
142 | } | |
143 | ||
9a7f95ad MH |
144 | static int vpbe_get_mode_info(struct vpbe_device *vpbe_dev, char *mode, |
145 | int output_index) | |
66715cdc MH |
146 | { |
147 | struct vpbe_config *cfg = vpbe_dev->cfg; | |
148 | struct vpbe_enc_mode_info var; | |
9a7f95ad | 149 | int curr_output = output_index; |
66715cdc MH |
150 | int i; |
151 | ||
152 | if (NULL == mode) | |
153 | return -EINVAL; | |
154 | ||
155 | for (i = 0; i < cfg->outputs[curr_output].num_modes; i++) { | |
156 | var = cfg->outputs[curr_output].modes[i]; | |
157 | if (!strcmp(mode, var.name)) { | |
158 | vpbe_dev->current_timings = var; | |
159 | return 0; | |
160 | } | |
161 | } | |
162 | ||
163 | return -EINVAL; | |
164 | } | |
165 | ||
166 | static int vpbe_get_current_mode_info(struct vpbe_device *vpbe_dev, | |
167 | struct vpbe_enc_mode_info *mode_info) | |
168 | { | |
169 | if (NULL == mode_info) | |
170 | return -EINVAL; | |
171 | ||
172 | *mode_info = vpbe_dev->current_timings; | |
173 | ||
174 | return 0; | |
175 | } | |
176 | ||
66715cdc MH |
177 | /* Get std by std id */ |
178 | static int vpbe_get_std_info(struct vpbe_device *vpbe_dev, | |
179 | v4l2_std_id std_id) | |
180 | { | |
181 | struct vpbe_config *cfg = vpbe_dev->cfg; | |
182 | struct vpbe_enc_mode_info var; | |
183 | int curr_output = vpbe_dev->current_out_index; | |
184 | int i; | |
185 | ||
186 | for (i = 0; i < vpbe_dev->cfg->outputs[curr_output].num_modes; i++) { | |
187 | var = cfg->outputs[curr_output].modes[i]; | |
188 | if ((var.timings_type & VPBE_ENC_STD) && | |
36864082 | 189 | (var.std_id & std_id)) { |
66715cdc MH |
190 | vpbe_dev->current_timings = var; |
191 | return 0; | |
192 | } | |
193 | } | |
194 | ||
195 | return -EINVAL; | |
196 | } | |
197 | ||
198 | static int vpbe_get_std_info_by_name(struct vpbe_device *vpbe_dev, | |
199 | char *std_name) | |
200 | { | |
201 | struct vpbe_config *cfg = vpbe_dev->cfg; | |
202 | struct vpbe_enc_mode_info var; | |
203 | int curr_output = vpbe_dev->current_out_index; | |
204 | int i; | |
205 | ||
206 | for (i = 0; i < vpbe_dev->cfg->outputs[curr_output].num_modes; i++) { | |
207 | var = cfg->outputs[curr_output].modes[i]; | |
208 | if (!strcmp(var.name, std_name)) { | |
209 | vpbe_dev->current_timings = var; | |
210 | return 0; | |
211 | } | |
212 | } | |
213 | ||
214 | return -EINVAL; | |
215 | } | |
216 | ||
217 | /** | |
218 | * vpbe_set_output - Set output | |
219 | * @vpbe_dev - vpbe device ptr | |
220 | * @index - index of output | |
221 | * | |
222 | * Set vpbe output to the output specified by the index | |
223 | */ | |
224 | static int vpbe_set_output(struct vpbe_device *vpbe_dev, int index) | |
225 | { | |
226 | struct encoder_config_info *curr_enc_info = | |
227 | vpbe_current_encoder_info(vpbe_dev); | |
228 | struct vpbe_config *cfg = vpbe_dev->cfg; | |
9a7f95ad | 229 | struct venc_platform_data *venc_device = vpbe_dev->venc_device; |
27ffaeb0 | 230 | u32 if_params; |
66715cdc MH |
231 | int enc_out_index; |
232 | int sd_index; | |
233 | int ret = 0; | |
234 | ||
235 | if (index >= cfg->num_outputs) | |
236 | return -EINVAL; | |
237 | ||
238 | mutex_lock(&vpbe_dev->lock); | |
239 | ||
240 | sd_index = vpbe_dev->current_sd_index; | |
241 | enc_out_index = cfg->outputs[index].output.index; | |
242 | /* | |
243 | * Currently we switch the encoder based on output selected | |
244 | * by the application. If media controller is implemented later | |
245 | * there is will be an API added to setup_link between venc | |
246 | * and external encoder. So in that case below comparison always | |
247 | * match and encoder will not be switched. But if application | |
248 | * chose not to use media controller, then this provides current | |
249 | * way of switching encoder at the venc output. | |
250 | */ | |
251 | if (strcmp(curr_enc_info->module_name, | |
252 | cfg->outputs[index].subdev_name)) { | |
253 | /* Need to switch the encoder at the output */ | |
254 | sd_index = vpbe_find_encoder_sd_index(cfg, index); | |
255 | if (sd_index < 0) { | |
256 | ret = -EINVAL; | |
257 | goto out; | |
258 | } | |
259 | ||
9a7f95ad MH |
260 | if_params = cfg->outputs[index].if_params; |
261 | venc_device->setup_if_config(if_params); | |
66715cdc MH |
262 | if (ret) |
263 | goto out; | |
264 | } | |
265 | ||
266 | /* Set output at the encoder */ | |
267 | ret = v4l2_subdev_call(vpbe_dev->encoders[sd_index], video, | |
268 | s_routing, 0, enc_out_index, 0); | |
269 | if (ret) | |
270 | goto out; | |
271 | ||
272 | /* | |
273 | * It is assumed that venc or extenal encoder will set a default | |
274 | * mode in the sub device. For external encoder or LCD pannel output, | |
275 | * we also need to set up the lcd port for the required mode. So setup | |
276 | * the lcd port for the default mode that is configured in the board | |
277 | * arch/arm/mach-davinci/board-dm355-evm.setup file for the external | |
278 | * encoder. | |
279 | */ | |
280 | ret = vpbe_get_mode_info(vpbe_dev, | |
9a7f95ad | 281 | cfg->outputs[index].default_mode, index); |
66715cdc MH |
282 | if (!ret) { |
283 | struct osd_state *osd_device = vpbe_dev->osd_device; | |
284 | ||
285 | osd_device->ops.set_left_margin(osd_device, | |
286 | vpbe_dev->current_timings.left_margin); | |
287 | osd_device->ops.set_top_margin(osd_device, | |
288 | vpbe_dev->current_timings.upper_margin); | |
289 | vpbe_dev->current_sd_index = sd_index; | |
290 | vpbe_dev->current_out_index = index; | |
291 | } | |
292 | out: | |
293 | mutex_unlock(&vpbe_dev->lock); | |
294 | return ret; | |
295 | } | |
296 | ||
297 | static int vpbe_set_default_output(struct vpbe_device *vpbe_dev) | |
298 | { | |
299 | struct vpbe_config *cfg = vpbe_dev->cfg; | |
300 | int ret = 0; | |
301 | int i; | |
302 | ||
303 | for (i = 0; i < cfg->num_outputs; i++) { | |
304 | if (!strcmp(def_output, | |
305 | cfg->outputs[i].output.name)) { | |
306 | ret = vpbe_set_output(vpbe_dev, i); | |
307 | if (!ret) | |
308 | vpbe_dev->current_out_index = i; | |
309 | return ret; | |
310 | } | |
311 | } | |
312 | return ret; | |
313 | } | |
314 | ||
315 | /** | |
316 | * vpbe_get_output - Get output | |
317 | * @vpbe_dev - vpbe device ptr | |
318 | * | |
319 | * return current vpbe output to the the index | |
320 | */ | |
321 | static unsigned int vpbe_get_output(struct vpbe_device *vpbe_dev) | |
322 | { | |
323 | return vpbe_dev->current_out_index; | |
324 | } | |
325 | ||
326 | /** | |
36864082 | 327 | * vpbe_s_dv_timings - Set the given preset timings in the encoder |
66715cdc | 328 | * |
36864082 | 329 | * Sets the timings if supported by the current encoder. Return the status. |
66715cdc MH |
330 | * 0 - success & -EINVAL on error |
331 | */ | |
36864082 HV |
332 | static int vpbe_s_dv_timings(struct vpbe_device *vpbe_dev, |
333 | struct v4l2_dv_timings *dv_timings) | |
66715cdc MH |
334 | { |
335 | struct vpbe_config *cfg = vpbe_dev->cfg; | |
336 | int out_index = vpbe_dev->current_out_index; | |
36864082 | 337 | struct vpbe_output *output = &cfg->outputs[out_index]; |
66715cdc | 338 | int sd_index = vpbe_dev->current_sd_index; |
36864082 | 339 | int ret, i; |
66715cdc MH |
340 | |
341 | ||
342 | if (!(cfg->outputs[out_index].output.capabilities & | |
e32087bc | 343 | V4L2_OUT_CAP_DV_TIMINGS)) |
f9cc70bf | 344 | return -ENODATA; |
66715cdc | 345 | |
36864082 | 346 | for (i = 0; i < output->num_modes; i++) { |
ef2d41b1 | 347 | if (output->modes[i].timings_type == VPBE_ENC_DV_TIMINGS && |
36864082 HV |
348 | !memcmp(&output->modes[i].dv_timings, |
349 | dv_timings, sizeof(*dv_timings))) | |
350 | break; | |
351 | } | |
352 | if (i >= output->num_modes) | |
353 | return -EINVAL; | |
354 | vpbe_dev->current_timings = output->modes[i]; | |
66715cdc MH |
355 | mutex_lock(&vpbe_dev->lock); |
356 | ||
66715cdc | 357 | ret = v4l2_subdev_call(vpbe_dev->encoders[sd_index], video, |
36864082 | 358 | s_dv_timings, dv_timings); |
9a7f95ad MH |
359 | if (!ret && (vpbe_dev->amp != NULL)) { |
360 | /* Call amplifier subdevice */ | |
361 | ret = v4l2_subdev_call(vpbe_dev->amp, video, | |
36864082 | 362 | s_dv_timings, dv_timings); |
9a7f95ad | 363 | } |
66715cdc MH |
364 | /* set the lcd controller output for the given mode */ |
365 | if (!ret) { | |
366 | struct osd_state *osd_device = vpbe_dev->osd_device; | |
367 | ||
368 | osd_device->ops.set_left_margin(osd_device, | |
369 | vpbe_dev->current_timings.left_margin); | |
370 | osd_device->ops.set_top_margin(osd_device, | |
371 | vpbe_dev->current_timings.upper_margin); | |
372 | } | |
373 | mutex_unlock(&vpbe_dev->lock); | |
374 | ||
375 | return ret; | |
376 | } | |
377 | ||
378 | /** | |
36864082 | 379 | * vpbe_g_dv_timings - Get the timings in the current encoder |
66715cdc | 380 | * |
36864082 | 381 | * Get the timings in the current encoder. Return the status. 0 - success |
66715cdc MH |
382 | * -EINVAL on error |
383 | */ | |
36864082 HV |
384 | static int vpbe_g_dv_timings(struct vpbe_device *vpbe_dev, |
385 | struct v4l2_dv_timings *dv_timings) | |
66715cdc | 386 | { |
f9cc70bf PL |
387 | struct vpbe_config *cfg = vpbe_dev->cfg; |
388 | int out_index = vpbe_dev->current_out_index; | |
389 | ||
390 | if (!(cfg->outputs[out_index].output.capabilities & | |
391 | V4L2_OUT_CAP_DV_TIMINGS)) | |
392 | return -ENODATA; | |
393 | ||
66715cdc | 394 | if (vpbe_dev->current_timings.timings_type & |
ef2d41b1 | 395 | VPBE_ENC_DV_TIMINGS) { |
36864082 | 396 | *dv_timings = vpbe_dev->current_timings.dv_timings; |
66715cdc MH |
397 | return 0; |
398 | } | |
399 | ||
400 | return -EINVAL; | |
401 | } | |
402 | ||
403 | /** | |
36864082 | 404 | * vpbe_enum_dv_timings - Enumerate the dv timings in the current encoder |
66715cdc | 405 | * |
36864082 | 406 | * Get the timings in the current encoder. Return the status. 0 - success |
66715cdc MH |
407 | * -EINVAL on error |
408 | */ | |
36864082 HV |
409 | static int vpbe_enum_dv_timings(struct vpbe_device *vpbe_dev, |
410 | struct v4l2_enum_dv_timings *timings) | |
66715cdc MH |
411 | { |
412 | struct vpbe_config *cfg = vpbe_dev->cfg; | |
413 | int out_index = vpbe_dev->current_out_index; | |
414 | struct vpbe_output *output = &cfg->outputs[out_index]; | |
415 | int j = 0; | |
416 | int i; | |
417 | ||
e32087bc | 418 | if (!(output->output.capabilities & V4L2_OUT_CAP_DV_TIMINGS)) |
f9cc70bf | 419 | return -ENODATA; |
66715cdc MH |
420 | |
421 | for (i = 0; i < output->num_modes; i++) { | |
ef2d41b1 | 422 | if (output->modes[i].timings_type == VPBE_ENC_DV_TIMINGS) { |
36864082 | 423 | if (j == timings->index) |
66715cdc MH |
424 | break; |
425 | j++; | |
426 | } | |
427 | } | |
428 | ||
429 | if (i == output->num_modes) | |
430 | return -EINVAL; | |
36864082 HV |
431 | timings->timings = output->modes[i].dv_timings; |
432 | return 0; | |
66715cdc MH |
433 | } |
434 | ||
435 | /** | |
436 | * vpbe_s_std - Set the given standard in the encoder | |
437 | * | |
438 | * Sets the standard if supported by the current encoder. Return the status. | |
439 | * 0 - success & -EINVAL on error | |
440 | */ | |
314527ac | 441 | static int vpbe_s_std(struct vpbe_device *vpbe_dev, v4l2_std_id std_id) |
66715cdc MH |
442 | { |
443 | struct vpbe_config *cfg = vpbe_dev->cfg; | |
444 | int out_index = vpbe_dev->current_out_index; | |
445 | int sd_index = vpbe_dev->current_sd_index; | |
446 | int ret; | |
447 | ||
448 | if (!(cfg->outputs[out_index].output.capabilities & | |
449 | V4L2_OUT_CAP_STD)) | |
f9cc70bf | 450 | return -ENODATA; |
66715cdc | 451 | |
314527ac | 452 | ret = vpbe_get_std_info(vpbe_dev, std_id); |
66715cdc MH |
453 | if (ret) |
454 | return ret; | |
455 | ||
456 | mutex_lock(&vpbe_dev->lock); | |
457 | ||
458 | ret = v4l2_subdev_call(vpbe_dev->encoders[sd_index], video, | |
314527ac | 459 | s_std_output, std_id); |
66715cdc MH |
460 | /* set the lcd controller output for the given mode */ |
461 | if (!ret) { | |
462 | struct osd_state *osd_device = vpbe_dev->osd_device; | |
463 | ||
464 | osd_device->ops.set_left_margin(osd_device, | |
465 | vpbe_dev->current_timings.left_margin); | |
466 | osd_device->ops.set_top_margin(osd_device, | |
467 | vpbe_dev->current_timings.upper_margin); | |
468 | } | |
469 | mutex_unlock(&vpbe_dev->lock); | |
470 | ||
471 | return ret; | |
472 | } | |
473 | ||
474 | /** | |
475 | * vpbe_g_std - Get the standard in the current encoder | |
476 | * | |
477 | * Get the standard in the current encoder. Return the status. 0 - success | |
478 | * -EINVAL on error | |
479 | */ | |
480 | static int vpbe_g_std(struct vpbe_device *vpbe_dev, v4l2_std_id *std_id) | |
481 | { | |
36864082 | 482 | struct vpbe_enc_mode_info *cur_timings = &vpbe_dev->current_timings; |
f9cc70bf PL |
483 | struct vpbe_config *cfg = vpbe_dev->cfg; |
484 | int out_index = vpbe_dev->current_out_index; | |
485 | ||
486 | if (!(cfg->outputs[out_index].output.capabilities & V4L2_OUT_CAP_STD)) | |
487 | return -ENODATA; | |
66715cdc | 488 | |
36864082 HV |
489 | if (cur_timings->timings_type & VPBE_ENC_STD) { |
490 | *std_id = cur_timings->std_id; | |
66715cdc MH |
491 | return 0; |
492 | } | |
493 | ||
494 | return -EINVAL; | |
495 | } | |
496 | ||
497 | /** | |
498 | * vpbe_set_mode - Set mode in the current encoder using mode info | |
499 | * | |
500 | * Use the mode string to decide what timings to set in the encoder | |
501 | * This is typically useful when fbset command is used to change the current | |
502 | * timings by specifying a string to indicate the timings. | |
503 | */ | |
504 | static int vpbe_set_mode(struct vpbe_device *vpbe_dev, | |
505 | struct vpbe_enc_mode_info *mode_info) | |
506 | { | |
507 | struct vpbe_enc_mode_info *preset_mode = NULL; | |
508 | struct vpbe_config *cfg = vpbe_dev->cfg; | |
36864082 | 509 | struct v4l2_dv_timings dv_timings; |
66715cdc MH |
510 | struct osd_state *osd_device; |
511 | int out_index = vpbe_dev->current_out_index; | |
512 | int ret = 0; | |
513 | int i; | |
514 | ||
515 | if ((NULL == mode_info) || (NULL == mode_info->name)) | |
516 | return -EINVAL; | |
517 | ||
518 | for (i = 0; i < cfg->outputs[out_index].num_modes; i++) { | |
519 | if (!strcmp(mode_info->name, | |
520 | cfg->outputs[out_index].modes[i].name)) { | |
521 | preset_mode = &cfg->outputs[out_index].modes[i]; | |
522 | /* | |
523 | * it may be one of the 3 timings type. Check and | |
524 | * invoke right API | |
525 | */ | |
526 | if (preset_mode->timings_type & VPBE_ENC_STD) | |
527 | return vpbe_s_std(vpbe_dev, | |
314527ac | 528 | preset_mode->std_id); |
36864082 | 529 | if (preset_mode->timings_type & |
ef2d41b1 | 530 | VPBE_ENC_DV_TIMINGS) { |
36864082 HV |
531 | dv_timings = |
532 | preset_mode->dv_timings; | |
533 | return vpbe_s_dv_timings(vpbe_dev, &dv_timings); | |
66715cdc MH |
534 | } |
535 | } | |
536 | } | |
537 | ||
538 | /* Only custom timing should reach here */ | |
539 | if (preset_mode == NULL) | |
540 | return -EINVAL; | |
541 | ||
542 | mutex_lock(&vpbe_dev->lock); | |
543 | ||
544 | osd_device = vpbe_dev->osd_device; | |
545 | vpbe_dev->current_timings = *preset_mode; | |
546 | osd_device->ops.set_left_margin(osd_device, | |
547 | vpbe_dev->current_timings.left_margin); | |
548 | osd_device->ops.set_top_margin(osd_device, | |
549 | vpbe_dev->current_timings.upper_margin); | |
550 | ||
551 | mutex_unlock(&vpbe_dev->lock); | |
552 | ||
553 | return ret; | |
554 | } | |
555 | ||
556 | static int vpbe_set_default_mode(struct vpbe_device *vpbe_dev) | |
557 | { | |
558 | int ret; | |
559 | ||
560 | ret = vpbe_get_std_info_by_name(vpbe_dev, def_mode); | |
561 | if (ret) | |
562 | return ret; | |
563 | ||
564 | /* set the default mode in the encoder */ | |
565 | return vpbe_set_mode(vpbe_dev, &vpbe_dev->current_timings); | |
566 | } | |
567 | ||
568 | static int platform_device_get(struct device *dev, void *data) | |
569 | { | |
570 | struct platform_device *pdev = to_platform_device(dev); | |
571 | struct vpbe_device *vpbe_dev = data; | |
572 | ||
caff80c3 | 573 | if (strstr(pdev->name, "vpbe-osd") != NULL) |
66715cdc | 574 | vpbe_dev->osd_device = platform_get_drvdata(pdev); |
caff80c3 | 575 | if (strstr(pdev->name, "vpbe-venc") != NULL) |
9a7f95ad | 576 | vpbe_dev->venc_device = dev_get_platdata(&pdev->dev); |
66715cdc MH |
577 | |
578 | return 0; | |
579 | } | |
580 | ||
581 | /** | |
582 | * vpbe_initialize() - Initialize the vpbe display controller | |
583 | * @vpbe_dev - vpbe device ptr | |
584 | * | |
585 | * Master frame buffer device drivers calls this to initialize vpbe | |
586 | * display controller. This will then registers v4l2 device and the sub | |
587 | * devices and sets a current encoder sub device for display. v4l2 display | |
588 | * device driver is the master and frame buffer display device driver is | |
589 | * the slave. Frame buffer display driver checks the initialized during | |
590 | * probe and exit if not initialized. Returns status. | |
591 | */ | |
592 | static int vpbe_initialize(struct device *dev, struct vpbe_device *vpbe_dev) | |
593 | { | |
594 | struct encoder_config_info *enc_info; | |
9a7f95ad | 595 | struct amp_config_info *amp_info; |
66715cdc MH |
596 | struct v4l2_subdev **enc_subdev; |
597 | struct osd_state *osd_device; | |
598 | struct i2c_adapter *i2c_adap; | |
66715cdc MH |
599 | int num_encoders; |
600 | int ret = 0; | |
601 | int err; | |
602 | int i; | |
603 | ||
604 | /* | |
605 | * v4l2 abd FBDev frame buffer devices will get the vpbe_dev pointer | |
606 | * from the platform device by iteration of platform drivers and | |
607 | * matching with device name | |
608 | */ | |
609 | if (NULL == vpbe_dev || NULL == dev) { | |
610 | printk(KERN_ERR "Null device pointers.\n"); | |
611 | return -ENODEV; | |
612 | } | |
613 | ||
614 | if (vpbe_dev->initialized) | |
615 | return 0; | |
616 | ||
617 | mutex_lock(&vpbe_dev->lock); | |
618 | ||
619 | if (strcmp(vpbe_dev->cfg->module_name, "dm644x-vpbe-display") != 0) { | |
620 | /* We have dac clock available for platform */ | |
621 | vpbe_dev->dac_clk = clk_get(vpbe_dev->pdev, "vpss_dac"); | |
622 | if (IS_ERR(vpbe_dev->dac_clk)) { | |
623 | ret = PTR_ERR(vpbe_dev->dac_clk); | |
ac0fe5ba | 624 | goto fail_mutex_unlock; |
66715cdc | 625 | } |
1f5a5e62 | 626 | if (clk_prepare_enable(vpbe_dev->dac_clk)) { |
66715cdc | 627 | ret = -ENODEV; |
47efeb52 | 628 | clk_put(vpbe_dev->dac_clk); |
ac0fe5ba | 629 | goto fail_mutex_unlock; |
66715cdc MH |
630 | } |
631 | } | |
632 | ||
633 | /* first enable vpss clocks */ | |
634 | vpss_enable_clock(VPSS_VPBE_CLOCK, 1); | |
635 | ||
636 | /* First register a v4l2 device */ | |
637 | ret = v4l2_device_register(dev, &vpbe_dev->v4l2_dev); | |
638 | if (ret) { | |
639 | v4l2_err(dev->driver, | |
640 | "Unable to register v4l2 device.\n"); | |
ac0fe5ba | 641 | goto fail_clk_put; |
66715cdc MH |
642 | } |
643 | v4l2_info(&vpbe_dev->v4l2_dev, "vpbe v4l2 device registered\n"); | |
644 | ||
645 | err = bus_for_each_dev(&platform_bus_type, NULL, vpbe_dev, | |
646 | platform_device_get); | |
5d97046a WY |
647 | if (err < 0) { |
648 | ret = err; | |
649 | goto fail_dev_unregister; | |
650 | } | |
66715cdc MH |
651 | |
652 | vpbe_dev->venc = venc_sub_dev_init(&vpbe_dev->v4l2_dev, | |
653 | vpbe_dev->cfg->venc.module_name); | |
654 | /* register venc sub device */ | |
655 | if (vpbe_dev->venc == NULL) { | |
656 | v4l2_err(&vpbe_dev->v4l2_dev, | |
657 | "vpbe unable to init venc sub device\n"); | |
658 | ret = -ENODEV; | |
ac0fe5ba | 659 | goto fail_dev_unregister; |
66715cdc MH |
660 | } |
661 | /* initialize osd device */ | |
662 | osd_device = vpbe_dev->osd_device; | |
663 | ||
664 | if (NULL != osd_device->ops.initialize) { | |
665 | err = osd_device->ops.initialize(osd_device); | |
666 | if (err) { | |
667 | v4l2_err(&vpbe_dev->v4l2_dev, | |
668 | "unable to initialize the OSD device"); | |
669 | err = -ENOMEM; | |
ac0fe5ba | 670 | goto fail_dev_unregister; |
66715cdc MH |
671 | } |
672 | } | |
673 | ||
674 | /* | |
675 | * Register any external encoders that are configured. At index 0 we | |
676 | * store venc sd index. | |
677 | */ | |
678 | num_encoders = vpbe_dev->cfg->num_ext_encoders + 1; | |
679 | vpbe_dev->encoders = kmalloc( | |
680 | sizeof(struct v4l2_subdev *)*num_encoders, | |
681 | GFP_KERNEL); | |
682 | if (NULL == vpbe_dev->encoders) { | |
683 | v4l2_err(&vpbe_dev->v4l2_dev, | |
684 | "unable to allocate memory for encoders sub devices"); | |
685 | ret = -ENOMEM; | |
ac0fe5ba | 686 | goto fail_dev_unregister; |
66715cdc MH |
687 | } |
688 | ||
689 | i2c_adap = i2c_get_adapter(vpbe_dev->cfg->i2c_adapter_id); | |
690 | for (i = 0; i < (vpbe_dev->cfg->num_ext_encoders + 1); i++) { | |
691 | if (i == 0) { | |
692 | /* venc is at index 0 */ | |
693 | enc_subdev = &vpbe_dev->encoders[i]; | |
694 | *enc_subdev = vpbe_dev->venc; | |
695 | continue; | |
696 | } | |
697 | enc_info = &vpbe_dev->cfg->ext_encoders[i]; | |
698 | if (enc_info->is_i2c) { | |
699 | enc_subdev = &vpbe_dev->encoders[i]; | |
700 | *enc_subdev = v4l2_i2c_new_subdev_board( | |
701 | &vpbe_dev->v4l2_dev, i2c_adap, | |
702 | &enc_info->board_info, NULL); | |
703 | if (*enc_subdev) | |
704 | v4l2_info(&vpbe_dev->v4l2_dev, | |
705 | "v4l2 sub device %s registered\n", | |
706 | enc_info->module_name); | |
707 | else { | |
708 | v4l2_err(&vpbe_dev->v4l2_dev, "encoder %s" | |
709 | " failed to register", | |
710 | enc_info->module_name); | |
711 | ret = -ENODEV; | |
ac0fe5ba | 712 | goto fail_kfree_encoders; |
66715cdc MH |
713 | } |
714 | } else | |
715 | v4l2_warn(&vpbe_dev->v4l2_dev, "non-i2c encoders" | |
716 | " currently not supported"); | |
717 | } | |
9a7f95ad MH |
718 | /* Add amplifier subdevice for dm365 */ |
719 | if ((strcmp(vpbe_dev->cfg->module_name, "dm365-vpbe-display") == 0) && | |
720 | vpbe_dev->cfg->amp != NULL) { | |
721 | amp_info = vpbe_dev->cfg->amp; | |
722 | if (amp_info->is_i2c) { | |
723 | vpbe_dev->amp = v4l2_i2c_new_subdev_board( | |
724 | &vpbe_dev->v4l2_dev, i2c_adap, | |
725 | &_info->board_info, NULL); | |
726 | if (!vpbe_dev->amp) { | |
727 | v4l2_err(&vpbe_dev->v4l2_dev, | |
728 | "amplifier %s failed to register", | |
729 | amp_info->module_name); | |
730 | ret = -ENODEV; | |
ac0fe5ba | 731 | goto fail_kfree_encoders; |
9a7f95ad MH |
732 | } |
733 | v4l2_info(&vpbe_dev->v4l2_dev, | |
734 | "v4l2 sub device %s registered\n", | |
735 | amp_info->module_name); | |
736 | } else { | |
737 | vpbe_dev->amp = NULL; | |
738 | v4l2_warn(&vpbe_dev->v4l2_dev, "non-i2c amplifiers" | |
739 | " currently not supported"); | |
740 | } | |
741 | } else { | |
742 | vpbe_dev->amp = NULL; | |
743 | } | |
66715cdc MH |
744 | |
745 | /* set the current encoder and output to that of venc by default */ | |
746 | vpbe_dev->current_sd_index = 0; | |
747 | vpbe_dev->current_out_index = 0; | |
66715cdc MH |
748 | |
749 | mutex_unlock(&vpbe_dev->lock); | |
750 | ||
751 | printk(KERN_NOTICE "Setting default output to %s\n", def_output); | |
752 | ret = vpbe_set_default_output(vpbe_dev); | |
753 | if (ret) { | |
754 | v4l2_err(&vpbe_dev->v4l2_dev, "Failed to set default output %s", | |
755 | def_output); | |
756 | return ret; | |
757 | } | |
758 | ||
759 | printk(KERN_NOTICE "Setting default mode to %s\n", def_mode); | |
760 | ret = vpbe_set_default_mode(vpbe_dev); | |
761 | if (ret) { | |
762 | v4l2_err(&vpbe_dev->v4l2_dev, "Failed to set default mode %s", | |
763 | def_mode); | |
764 | return ret; | |
765 | } | |
766 | vpbe_dev->initialized = 1; | |
767 | /* TBD handling of bootargs for default output and mode */ | |
768 | return 0; | |
769 | ||
ac0fe5ba | 770 | fail_kfree_encoders: |
66715cdc | 771 | kfree(vpbe_dev->encoders); |
ac0fe5ba | 772 | fail_dev_unregister: |
66715cdc | 773 | v4l2_device_unregister(&vpbe_dev->v4l2_dev); |
ac0fe5ba | 774 | fail_clk_put: |
1f5a5e62 MK |
775 | if (strcmp(vpbe_dev->cfg->module_name, "dm644x-vpbe-display") != 0) { |
776 | clk_disable_unprepare(vpbe_dev->dac_clk); | |
66715cdc | 777 | clk_put(vpbe_dev->dac_clk); |
1f5a5e62 | 778 | } |
ac0fe5ba | 779 | fail_mutex_unlock: |
66715cdc MH |
780 | mutex_unlock(&vpbe_dev->lock); |
781 | return ret; | |
782 | } | |
783 | ||
784 | /** | |
785 | * vpbe_deinitialize() - de-initialize the vpbe display controller | |
786 | * @dev - Master and slave device ptr | |
787 | * | |
788 | * vpbe_master and slave frame buffer devices calls this to de-initialize | |
789 | * the display controller. It is called when master and slave device | |
790 | * driver modules are removed and no longer requires the display controller. | |
791 | */ | |
792 | static void vpbe_deinitialize(struct device *dev, struct vpbe_device *vpbe_dev) | |
793 | { | |
794 | v4l2_device_unregister(&vpbe_dev->v4l2_dev); | |
1f5a5e62 MK |
795 | if (strcmp(vpbe_dev->cfg->module_name, "dm644x-vpbe-display") != 0) { |
796 | clk_disable_unprepare(vpbe_dev->dac_clk); | |
66715cdc | 797 | clk_put(vpbe_dev->dac_clk); |
1f5a5e62 | 798 | } |
66715cdc | 799 | |
9a7f95ad | 800 | kfree(vpbe_dev->amp); |
66715cdc MH |
801 | kfree(vpbe_dev->encoders); |
802 | vpbe_dev->initialized = 0; | |
803 | /* disable vpss clocks */ | |
804 | vpss_enable_clock(VPSS_VPBE_CLOCK, 0); | |
805 | } | |
806 | ||
807 | static struct vpbe_device_ops vpbe_dev_ops = { | |
808 | .g_cropcap = vpbe_g_cropcap, | |
809 | .enum_outputs = vpbe_enum_outputs, | |
810 | .set_output = vpbe_set_output, | |
811 | .get_output = vpbe_get_output, | |
36864082 HV |
812 | .s_dv_timings = vpbe_s_dv_timings, |
813 | .g_dv_timings = vpbe_g_dv_timings, | |
814 | .enum_dv_timings = vpbe_enum_dv_timings, | |
66715cdc MH |
815 | .s_std = vpbe_s_std, |
816 | .g_std = vpbe_g_std, | |
817 | .initialize = vpbe_initialize, | |
818 | .deinitialize = vpbe_deinitialize, | |
819 | .get_mode_info = vpbe_get_current_mode_info, | |
820 | .set_mode = vpbe_set_mode, | |
821 | }; | |
822 | ||
4c62e976 | 823 | static int vpbe_probe(struct platform_device *pdev) |
66715cdc MH |
824 | { |
825 | struct vpbe_device *vpbe_dev; | |
826 | struct vpbe_config *cfg; | |
827 | int ret = -EINVAL; | |
828 | ||
829 | if (pdev->dev.platform_data == NULL) { | |
830 | v4l2_err(pdev->dev.driver, "No platform data\n"); | |
831 | return -ENODEV; | |
832 | } | |
833 | cfg = pdev->dev.platform_data; | |
834 | ||
835 | if (!cfg->module_name[0] || | |
836 | !cfg->osd.module_name[0] || | |
837 | !cfg->venc.module_name[0]) { | |
838 | v4l2_err(pdev->dev.driver, "vpbe display module names not" | |
839 | " defined\n"); | |
840 | return ret; | |
841 | } | |
842 | ||
843 | vpbe_dev = kzalloc(sizeof(*vpbe_dev), GFP_KERNEL); | |
844 | if (vpbe_dev == NULL) { | |
845 | v4l2_err(pdev->dev.driver, "Unable to allocate memory" | |
846 | " for vpbe_device\n"); | |
847 | return -ENOMEM; | |
848 | } | |
849 | vpbe_dev->cfg = cfg; | |
850 | vpbe_dev->ops = vpbe_dev_ops; | |
851 | vpbe_dev->pdev = &pdev->dev; | |
852 | ||
853 | if (cfg->outputs->num_modes > 0) | |
854 | vpbe_dev->current_timings = vpbe_dev->cfg->outputs[0].modes[0]; | |
75e5ac7e JL |
855 | else { |
856 | kfree(vpbe_dev); | |
66715cdc | 857 | return -ENODEV; |
75e5ac7e | 858 | } |
66715cdc MH |
859 | |
860 | /* set the driver data in platform device */ | |
861 | platform_set_drvdata(pdev, vpbe_dev); | |
862 | mutex_init(&vpbe_dev->lock); | |
863 | ||
864 | return 0; | |
865 | } | |
866 | ||
867 | static int vpbe_remove(struct platform_device *device) | |
868 | { | |
869 | struct vpbe_device *vpbe_dev = platform_get_drvdata(device); | |
870 | ||
871 | kfree(vpbe_dev); | |
872 | ||
873 | return 0; | |
874 | } | |
875 | ||
876 | static struct platform_driver vpbe_driver = { | |
877 | .driver = { | |
878 | .name = "vpbe_controller", | |
66715cdc MH |
879 | }, |
880 | .probe = vpbe_probe, | |
881 | .remove = vpbe_remove, | |
882 | }; | |
883 | ||
1d6629b1 | 884 | module_platform_driver(vpbe_driver); |