aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/media/video/davinci/vpbe.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/media/video/davinci/vpbe.c')
-rw-r--r--drivers/media/video/davinci/vpbe.c886
1 files changed, 0 insertions, 886 deletions
diff --git a/drivers/media/video/davinci/vpbe.c b/drivers/media/video/davinci/vpbe.c
deleted file mode 100644
index c4a82a1a8a97..000000000000
--- a/drivers/media/video/davinci/vpbe.c
+++ /dev/null
@@ -1,886 +0,0 @@
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
40static char *def_output = VPBE_DEFAULT_OUTPUT;
41static char *def_mode = VPBE_DEFAULT_MODE;
42static int debug;
43
44module_param(def_output, charp, S_IRUGO);
45module_param(def_mode, charp, S_IRUGO);
46module_param(debug, int, 0644);
47
48MODULE_PARM_DESC(def_output, "vpbe output name (default:Composite)");
49MODULE_PARM_DESC(def_mode, "vpbe output mode name (default:ntsc");
50MODULE_PARM_DESC(debug, "Debug level 0-1");
51
52MODULE_DESCRIPTION("TI DMXXX VPBE Display controller");
53MODULE_LICENSE("GPL");
54MODULE_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 */
62static struct encoder_config_info*
63vpbe_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 */
80static 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 */
107static 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 */
129static 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
144static int vpbe_get_mode_info(struct vpbe_device *vpbe_dev, char *mode,
145 int output_index)
146{
147 struct vpbe_config *cfg = vpbe_dev->cfg;
148 struct vpbe_enc_mode_info var;
149 int curr_output = output_index;
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
166static 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
177static int vpbe_get_dv_preset_info(struct vpbe_device *vpbe_dev,
178 unsigned int dv_preset)
179{
180 struct vpbe_config *cfg = vpbe_dev->cfg;
181 struct vpbe_enc_mode_info var;
182 int curr_output = vpbe_dev->current_out_index;
183 int i;
184
185 for (i = 0; i < vpbe_dev->cfg->outputs[curr_output].num_modes; i++) {
186 var = cfg->outputs[curr_output].modes[i];
187 if ((var.timings_type & VPBE_ENC_DV_PRESET) &&
188 (var.timings.dv_preset == dv_preset)) {
189 vpbe_dev->current_timings = var;
190 return 0;
191 }
192 }
193
194 return -EINVAL;
195}
196
197/* Get std by std id */
198static int vpbe_get_std_info(struct vpbe_device *vpbe_dev,
199 v4l2_std_id std_id)
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 ((var.timings_type & VPBE_ENC_STD) &&
209 (var.timings.std_id & std_id)) {
210 vpbe_dev->current_timings = var;
211 return 0;
212 }
213 }
214
215 return -EINVAL;
216}
217
218static int vpbe_get_std_info_by_name(struct vpbe_device *vpbe_dev,
219 char *std_name)
220{
221 struct vpbe_config *cfg = vpbe_dev->cfg;
222 struct vpbe_enc_mode_info var;
223 int curr_output = vpbe_dev->current_out_index;
224 int i;
225
226 for (i = 0; i < vpbe_dev->cfg->outputs[curr_output].num_modes; i++) {
227 var = cfg->outputs[curr_output].modes[i];
228 if (!strcmp(var.name, std_name)) {
229 vpbe_dev->current_timings = var;
230 return 0;
231 }
232 }
233
234 return -EINVAL;
235}
236
237/**
238 * vpbe_set_output - Set output
239 * @vpbe_dev - vpbe device ptr
240 * @index - index of output
241 *
242 * Set vpbe output to the output specified by the index
243 */
244static int vpbe_set_output(struct vpbe_device *vpbe_dev, int index)
245{
246 struct encoder_config_info *curr_enc_info =
247 vpbe_current_encoder_info(vpbe_dev);
248 struct vpbe_config *cfg = vpbe_dev->cfg;
249 struct venc_platform_data *venc_device = vpbe_dev->venc_device;
250 enum v4l2_mbus_pixelcode if_params;
251 int enc_out_index;
252 int sd_index;
253 int ret = 0;
254
255 if (index >= cfg->num_outputs)
256 return -EINVAL;
257
258 mutex_lock(&vpbe_dev->lock);
259
260 sd_index = vpbe_dev->current_sd_index;
261 enc_out_index = cfg->outputs[index].output.index;
262 /*
263 * Currently we switch the encoder based on output selected
264 * by the application. If media controller is implemented later
265 * there is will be an API added to setup_link between venc
266 * and external encoder. So in that case below comparison always
267 * match and encoder will not be switched. But if application
268 * chose not to use media controller, then this provides current
269 * way of switching encoder at the venc output.
270 */
271 if (strcmp(curr_enc_info->module_name,
272 cfg->outputs[index].subdev_name)) {
273 /* Need to switch the encoder at the output */
274 sd_index = vpbe_find_encoder_sd_index(cfg, index);
275 if (sd_index < 0) {
276 ret = -EINVAL;
277 goto out;
278 }
279
280 if_params = cfg->outputs[index].if_params;
281 venc_device->setup_if_config(if_params);
282 if (ret)
283 goto out;
284 }
285
286 /* Set output at the encoder */
287 ret = v4l2_subdev_call(vpbe_dev->encoders[sd_index], video,
288 s_routing, 0, enc_out_index, 0);
289 if (ret)
290 goto out;
291
292 /*
293 * It is assumed that venc or extenal encoder will set a default
294 * mode in the sub device. For external encoder or LCD pannel output,
295 * we also need to set up the lcd port for the required mode. So setup
296 * the lcd port for the default mode that is configured in the board
297 * arch/arm/mach-davinci/board-dm355-evm.setup file for the external
298 * encoder.
299 */
300 ret = vpbe_get_mode_info(vpbe_dev,
301 cfg->outputs[index].default_mode, index);
302 if (!ret) {
303 struct osd_state *osd_device = vpbe_dev->osd_device;
304
305 osd_device->ops.set_left_margin(osd_device,
306 vpbe_dev->current_timings.left_margin);
307 osd_device->ops.set_top_margin(osd_device,
308 vpbe_dev->current_timings.upper_margin);
309 vpbe_dev->current_sd_index = sd_index;
310 vpbe_dev->current_out_index = index;
311 }
312out:
313 mutex_unlock(&vpbe_dev->lock);
314 return ret;
315}
316
317static int vpbe_set_default_output(struct vpbe_device *vpbe_dev)
318{
319 struct vpbe_config *cfg = vpbe_dev->cfg;
320 int ret = 0;
321 int i;
322
323 for (i = 0; i < cfg->num_outputs; i++) {
324 if (!strcmp(def_output,
325 cfg->outputs[i].output.name)) {
326 ret = vpbe_set_output(vpbe_dev, i);
327 if (!ret)
328 vpbe_dev->current_out_index = i;
329 return ret;
330 }
331 }
332 return ret;
333}
334
335/**
336 * vpbe_get_output - Get output
337 * @vpbe_dev - vpbe device ptr
338 *
339 * return current vpbe output to the the index
340 */
341static unsigned int vpbe_get_output(struct vpbe_device *vpbe_dev)
342{
343 return vpbe_dev->current_out_index;
344}
345
346/**
347 * vpbe_s_dv_preset - Set the given preset timings in the encoder
348 *
349 * Sets the preset if supported by the current encoder. Return the status.
350 * 0 - success & -EINVAL on error
351 */
352static int vpbe_s_dv_preset(struct vpbe_device *vpbe_dev,
353 struct v4l2_dv_preset *dv_preset)
354{
355 struct vpbe_config *cfg = vpbe_dev->cfg;
356 int out_index = vpbe_dev->current_out_index;
357 int sd_index = vpbe_dev->current_sd_index;
358 int ret;
359
360
361 if (!(cfg->outputs[out_index].output.capabilities &
362 V4L2_OUT_CAP_PRESETS))
363 return -EINVAL;
364
365 ret = vpbe_get_dv_preset_info(vpbe_dev, dv_preset->preset);
366
367 if (ret)
368 return ret;
369
370 mutex_lock(&vpbe_dev->lock);
371
372
373 ret = v4l2_subdev_call(vpbe_dev->encoders[sd_index], video,
374 s_dv_preset, dv_preset);
375 if (!ret && (vpbe_dev->amp != NULL)) {
376 /* Call amplifier subdevice */
377 ret = v4l2_subdev_call(vpbe_dev->amp, video,
378 s_dv_preset, dv_preset);
379 }
380 /* set the lcd controller output for the given mode */
381 if (!ret) {
382 struct osd_state *osd_device = vpbe_dev->osd_device;
383
384 osd_device->ops.set_left_margin(osd_device,
385 vpbe_dev->current_timings.left_margin);
386 osd_device->ops.set_top_margin(osd_device,
387 vpbe_dev->current_timings.upper_margin);
388 }
389 mutex_unlock(&vpbe_dev->lock);
390
391 return ret;
392}
393
394/**
395 * vpbe_g_dv_preset - Get the preset in the current encoder
396 *
397 * Get the preset in the current encoder. Return the status. 0 - success
398 * -EINVAL on error
399 */
400static int vpbe_g_dv_preset(struct vpbe_device *vpbe_dev,
401 struct v4l2_dv_preset *dv_preset)
402{
403 if (vpbe_dev->current_timings.timings_type &
404 VPBE_ENC_DV_PRESET) {
405 dv_preset->preset = vpbe_dev->current_timings.timings.dv_preset;
406 return 0;
407 }
408
409 return -EINVAL;
410}
411
412/**
413 * vpbe_enum_dv_presets - Enumerate the dv presets in the current encoder
414 *
415 * Get the preset in the current encoder. Return the status. 0 - success
416 * -EINVAL on error
417 */
418static int vpbe_enum_dv_presets(struct vpbe_device *vpbe_dev,
419 struct v4l2_dv_enum_preset *preset_info)
420{
421 struct vpbe_config *cfg = vpbe_dev->cfg;
422 int out_index = vpbe_dev->current_out_index;
423 struct vpbe_output *output = &cfg->outputs[out_index];
424 int j = 0;
425 int i;
426
427 if (!(output->output.capabilities & V4L2_OUT_CAP_PRESETS))
428 return -EINVAL;
429
430 for (i = 0; i < output->num_modes; i++) {
431 if (output->modes[i].timings_type == VPBE_ENC_DV_PRESET) {
432 if (j == preset_info->index)
433 break;
434 j++;
435 }
436 }
437
438 if (i == output->num_modes)
439 return -EINVAL;
440
441 return v4l_fill_dv_preset_info(output->modes[i].timings.dv_preset,
442 preset_info);
443}
444
445/**
446 * vpbe_s_std - Set the given standard in the encoder
447 *
448 * Sets the standard if supported by the current encoder. Return the status.
449 * 0 - success & -EINVAL on error
450 */
451static int vpbe_s_std(struct vpbe_device *vpbe_dev, v4l2_std_id *std_id)
452{
453 struct vpbe_config *cfg = vpbe_dev->cfg;
454 int out_index = vpbe_dev->current_out_index;
455 int sd_index = vpbe_dev->current_sd_index;
456 int ret;
457
458 if (!(cfg->outputs[out_index].output.capabilities &
459 V4L2_OUT_CAP_STD))
460 return -EINVAL;
461
462 ret = vpbe_get_std_info(vpbe_dev, *std_id);
463 if (ret)
464 return ret;
465
466 mutex_lock(&vpbe_dev->lock);
467
468 ret = v4l2_subdev_call(vpbe_dev->encoders[sd_index], video,
469 s_std_output, *std_id);
470 /* set the lcd controller output for the given mode */
471 if (!ret) {
472 struct osd_state *osd_device = vpbe_dev->osd_device;
473
474 osd_device->ops.set_left_margin(osd_device,
475 vpbe_dev->current_timings.left_margin);
476 osd_device->ops.set_top_margin(osd_device,
477 vpbe_dev->current_timings.upper_margin);
478 }
479 mutex_unlock(&vpbe_dev->lock);
480
481 return ret;
482}
483
484/**
485 * vpbe_g_std - Get the standard in the current encoder
486 *
487 * Get the standard in the current encoder. Return the status. 0 - success
488 * -EINVAL on error
489 */
490static int vpbe_g_std(struct vpbe_device *vpbe_dev, v4l2_std_id *std_id)
491{
492 struct vpbe_enc_mode_info cur_timings = vpbe_dev->current_timings;
493
494 if (cur_timings.timings_type & VPBE_ENC_STD) {
495 *std_id = cur_timings.timings.std_id;
496 return 0;
497 }
498
499 return -EINVAL;
500}
501
502/**
503 * vpbe_set_mode - Set mode in the current encoder using mode info
504 *
505 * Use the mode string to decide what timings to set in the encoder
506 * This is typically useful when fbset command is used to change the current
507 * timings by specifying a string to indicate the timings.
508 */
509static int vpbe_set_mode(struct vpbe_device *vpbe_dev,
510 struct vpbe_enc_mode_info *mode_info)
511{
512 struct vpbe_enc_mode_info *preset_mode = NULL;
513 struct vpbe_config *cfg = vpbe_dev->cfg;
514 struct v4l2_dv_preset dv_preset;
515 struct osd_state *osd_device;
516 int out_index = vpbe_dev->current_out_index;
517 int ret = 0;
518 int i;
519
520 if ((NULL == mode_info) || (NULL == mode_info->name))
521 return -EINVAL;
522
523 for (i = 0; i < cfg->outputs[out_index].num_modes; i++) {
524 if (!strcmp(mode_info->name,
525 cfg->outputs[out_index].modes[i].name)) {
526 preset_mode = &cfg->outputs[out_index].modes[i];
527 /*
528 * it may be one of the 3 timings type. Check and
529 * invoke right API
530 */
531 if (preset_mode->timings_type & VPBE_ENC_STD)
532 return vpbe_s_std(vpbe_dev,
533 &preset_mode->timings.std_id);
534 if (preset_mode->timings_type & VPBE_ENC_DV_PRESET) {
535 dv_preset.preset =
536 preset_mode->timings.dv_preset;
537 return vpbe_s_dv_preset(vpbe_dev, &dv_preset);
538 }
539 }
540 }
541
542 /* Only custom timing should reach here */
543 if (preset_mode == NULL)
544 return -EINVAL;
545
546 mutex_lock(&vpbe_dev->lock);
547
548 osd_device = vpbe_dev->osd_device;
549 vpbe_dev->current_timings = *preset_mode;
550 osd_device->ops.set_left_margin(osd_device,
551 vpbe_dev->current_timings.left_margin);
552 osd_device->ops.set_top_margin(osd_device,
553 vpbe_dev->current_timings.upper_margin);
554
555 mutex_unlock(&vpbe_dev->lock);
556
557 return ret;
558}
559
560static int vpbe_set_default_mode(struct vpbe_device *vpbe_dev)
561{
562 int ret;
563
564 ret = vpbe_get_std_info_by_name(vpbe_dev, def_mode);
565 if (ret)
566 return ret;
567
568 /* set the default mode in the encoder */
569 return vpbe_set_mode(vpbe_dev, &vpbe_dev->current_timings);
570}
571
572static int platform_device_get(struct device *dev, void *data)
573{
574 struct platform_device *pdev = to_platform_device(dev);
575 struct vpbe_device *vpbe_dev = data;
576
577 if (strcmp("vpbe-osd", pdev->name) == 0)
578 vpbe_dev->osd_device = platform_get_drvdata(pdev);
579 if (strcmp("vpbe-venc", pdev->name) == 0)
580 vpbe_dev->venc_device = dev_get_platdata(&pdev->dev);
581
582 return 0;
583}
584
585/**
586 * vpbe_initialize() - Initialize the vpbe display controller
587 * @vpbe_dev - vpbe device ptr
588 *
589 * Master frame buffer device drivers calls this to initialize vpbe
590 * display controller. This will then registers v4l2 device and the sub
591 * devices and sets a current encoder sub device for display. v4l2 display
592 * device driver is the master and frame buffer display device driver is
593 * the slave. Frame buffer display driver checks the initialized during
594 * probe and exit if not initialized. Returns status.
595 */
596static int vpbe_initialize(struct device *dev, struct vpbe_device *vpbe_dev)
597{
598 struct encoder_config_info *enc_info;
599 struct amp_config_info *amp_info;
600 struct v4l2_subdev **enc_subdev;
601 struct osd_state *osd_device;
602 struct i2c_adapter *i2c_adap;
603 int output_index;
604 int num_encoders;
605 int ret = 0;
606 int err;
607 int i;
608
609 /*
610 * v4l2 abd FBDev frame buffer devices will get the vpbe_dev pointer
611 * from the platform device by iteration of platform drivers and
612 * matching with device name
613 */
614 if (NULL == vpbe_dev || NULL == dev) {
615 printk(KERN_ERR "Null device pointers.\n");
616 return -ENODEV;
617 }
618
619 if (vpbe_dev->initialized)
620 return 0;
621
622 mutex_lock(&vpbe_dev->lock);
623
624 if (strcmp(vpbe_dev->cfg->module_name, "dm644x-vpbe-display") != 0) {
625 /* We have dac clock available for platform */
626 vpbe_dev->dac_clk = clk_get(vpbe_dev->pdev, "vpss_dac");
627 if (IS_ERR(vpbe_dev->dac_clk)) {
628 ret = PTR_ERR(vpbe_dev->dac_clk);
629 goto vpbe_unlock;
630 }
631 if (clk_enable(vpbe_dev->dac_clk)) {
632 ret = -ENODEV;
633 goto vpbe_unlock;
634 }
635 }
636
637 /* first enable vpss clocks */
638 vpss_enable_clock(VPSS_VPBE_CLOCK, 1);
639
640 /* First register a v4l2 device */
641 ret = v4l2_device_register(dev, &vpbe_dev->v4l2_dev);
642 if (ret) {
643 v4l2_err(dev->driver,
644 "Unable to register v4l2 device.\n");
645 goto vpbe_fail_clock;
646 }
647 v4l2_info(&vpbe_dev->v4l2_dev, "vpbe v4l2 device registered\n");
648
649 err = bus_for_each_dev(&platform_bus_type, NULL, vpbe_dev,
650 platform_device_get);
651 if (err < 0)
652 return err;
653
654 vpbe_dev->venc = venc_sub_dev_init(&vpbe_dev->v4l2_dev,
655 vpbe_dev->cfg->venc.module_name);
656 /* register venc sub device */
657 if (vpbe_dev->venc == NULL) {
658 v4l2_err(&vpbe_dev->v4l2_dev,
659 "vpbe unable to init venc sub device\n");
660 ret = -ENODEV;
661 goto vpbe_fail_v4l2_device;
662 }
663 /* initialize osd device */
664 osd_device = vpbe_dev->osd_device;
665
666 if (NULL != osd_device->ops.initialize) {
667 err = osd_device->ops.initialize(osd_device);
668 if (err) {
669 v4l2_err(&vpbe_dev->v4l2_dev,
670 "unable to initialize the OSD device");
671 err = -ENOMEM;
672 goto vpbe_fail_v4l2_device;
673 }
674 }
675
676 /*
677 * Register any external encoders that are configured. At index 0 we
678 * store venc sd index.
679 */
680 num_encoders = vpbe_dev->cfg->num_ext_encoders + 1;
681 vpbe_dev->encoders = kmalloc(
682 sizeof(struct v4l2_subdev *)*num_encoders,
683 GFP_KERNEL);
684 if (NULL == vpbe_dev->encoders) {
685 v4l2_err(&vpbe_dev->v4l2_dev,
686 "unable to allocate memory for encoders sub devices");
687 ret = -ENOMEM;
688 goto vpbe_fail_v4l2_device;
689 }
690
691 i2c_adap = i2c_get_adapter(vpbe_dev->cfg->i2c_adapter_id);
692 for (i = 0; i < (vpbe_dev->cfg->num_ext_encoders + 1); i++) {
693 if (i == 0) {
694 /* venc is at index 0 */
695 enc_subdev = &vpbe_dev->encoders[i];
696 *enc_subdev = vpbe_dev->venc;
697 continue;
698 }
699 enc_info = &vpbe_dev->cfg->ext_encoders[i];
700 if (enc_info->is_i2c) {
701 enc_subdev = &vpbe_dev->encoders[i];
702 *enc_subdev = v4l2_i2c_new_subdev_board(
703 &vpbe_dev->v4l2_dev, i2c_adap,
704 &enc_info->board_info, NULL);
705 if (*enc_subdev)
706 v4l2_info(&vpbe_dev->v4l2_dev,
707 "v4l2 sub device %s registered\n",
708 enc_info->module_name);
709 else {
710 v4l2_err(&vpbe_dev->v4l2_dev, "encoder %s"
711 " failed to register",
712 enc_info->module_name);
713 ret = -ENODEV;
714 goto vpbe_fail_sd_register;
715 }
716 } else
717 v4l2_warn(&vpbe_dev->v4l2_dev, "non-i2c encoders"
718 " currently not supported");
719 }
720 /* Add amplifier subdevice for dm365 */
721 if ((strcmp(vpbe_dev->cfg->module_name, "dm365-vpbe-display") == 0) &&
722 vpbe_dev->cfg->amp != NULL) {
723 amp_info = vpbe_dev->cfg->amp;
724 if (amp_info->is_i2c) {
725 vpbe_dev->amp = v4l2_i2c_new_subdev_board(
726 &vpbe_dev->v4l2_dev, i2c_adap,
727 &amp_info->board_info, NULL);
728 if (!vpbe_dev->amp) {
729 v4l2_err(&vpbe_dev->v4l2_dev,
730 "amplifier %s failed to register",
731 amp_info->module_name);
732 ret = -ENODEV;
733 goto vpbe_fail_amp_register;
734 }
735 v4l2_info(&vpbe_dev->v4l2_dev,
736 "v4l2 sub device %s registered\n",
737 amp_info->module_name);
738 } else {
739 vpbe_dev->amp = NULL;
740 v4l2_warn(&vpbe_dev->v4l2_dev, "non-i2c amplifiers"
741 " currently not supported");
742 }
743 } else {
744 vpbe_dev->amp = NULL;
745 }
746
747 /* set the current encoder and output to that of venc by default */
748 vpbe_dev->current_sd_index = 0;
749 vpbe_dev->current_out_index = 0;
750 output_index = 0;
751
752 mutex_unlock(&vpbe_dev->lock);
753
754 printk(KERN_NOTICE "Setting default output to %s\n", def_output);
755 ret = vpbe_set_default_output(vpbe_dev);
756 if (ret) {
757 v4l2_err(&vpbe_dev->v4l2_dev, "Failed to set default output %s",
758 def_output);
759 return ret;
760 }
761
762 printk(KERN_NOTICE "Setting default mode to %s\n", def_mode);
763 ret = vpbe_set_default_mode(vpbe_dev);
764 if (ret) {
765 v4l2_err(&vpbe_dev->v4l2_dev, "Failed to set default mode %s",
766 def_mode);
767 return ret;
768 }
769 vpbe_dev->initialized = 1;
770 /* TBD handling of bootargs for default output and mode */
771 return 0;
772
773vpbe_fail_amp_register:
774 kfree(vpbe_dev->amp);
775vpbe_fail_sd_register:
776 kfree(vpbe_dev->encoders);
777vpbe_fail_v4l2_device:
778 v4l2_device_unregister(&vpbe_dev->v4l2_dev);
779vpbe_fail_clock:
780 if (strcmp(vpbe_dev->cfg->module_name, "dm644x-vpbe-display") != 0)
781 clk_put(vpbe_dev->dac_clk);
782vpbe_unlock:
783 mutex_unlock(&vpbe_dev->lock);
784 return ret;
785}
786
787/**
788 * vpbe_deinitialize() - de-initialize the vpbe display controller
789 * @dev - Master and slave device ptr
790 *
791 * vpbe_master and slave frame buffer devices calls this to de-initialize
792 * the display controller. It is called when master and slave device
793 * driver modules are removed and no longer requires the display controller.
794 */
795static void vpbe_deinitialize(struct device *dev, struct vpbe_device *vpbe_dev)
796{
797 v4l2_device_unregister(&vpbe_dev->v4l2_dev);
798 if (strcmp(vpbe_dev->cfg->module_name, "dm644x-vpbe-display") != 0)
799 clk_put(vpbe_dev->dac_clk);
800
801 kfree(vpbe_dev->amp);
802 kfree(vpbe_dev->encoders);
803 vpbe_dev->initialized = 0;
804 /* disable vpss clocks */
805 vpss_enable_clock(VPSS_VPBE_CLOCK, 0);
806}
807
808static struct vpbe_device_ops vpbe_dev_ops = {
809 .g_cropcap = vpbe_g_cropcap,
810 .enum_outputs = vpbe_enum_outputs,
811 .set_output = vpbe_set_output,
812 .get_output = vpbe_get_output,
813 .s_dv_preset = vpbe_s_dv_preset,
814 .g_dv_preset = vpbe_g_dv_preset,
815 .enum_dv_presets = vpbe_enum_dv_presets,
816 .s_std = vpbe_s_std,
817 .g_std = vpbe_g_std,
818 .initialize = vpbe_initialize,
819 .deinitialize = vpbe_deinitialize,
820 .get_mode_info = vpbe_get_current_mode_info,
821 .set_mode = vpbe_set_mode,
822};
823
824static __devinit int vpbe_probe(struct platform_device *pdev)
825{
826 struct vpbe_device *vpbe_dev;
827 struct vpbe_config *cfg;
828 int ret = -EINVAL;
829
830 if (pdev->dev.platform_data == NULL) {
831 v4l2_err(pdev->dev.driver, "No platform data\n");
832 return -ENODEV;
833 }
834 cfg = pdev->dev.platform_data;
835
836 if (!cfg->module_name[0] ||
837 !cfg->osd.module_name[0] ||
838 !cfg->venc.module_name[0]) {
839 v4l2_err(pdev->dev.driver, "vpbe display module names not"
840 " defined\n");
841 return ret;
842 }
843
844 vpbe_dev = kzalloc(sizeof(*vpbe_dev), GFP_KERNEL);
845 if (vpbe_dev == NULL) {
846 v4l2_err(pdev->dev.driver, "Unable to allocate memory"
847 " for vpbe_device\n");
848 return -ENOMEM;
849 }
850 vpbe_dev->cfg = cfg;
851 vpbe_dev->ops = vpbe_dev_ops;
852 vpbe_dev->pdev = &pdev->dev;
853
854 if (cfg->outputs->num_modes > 0)
855 vpbe_dev->current_timings = vpbe_dev->cfg->outputs[0].modes[0];
856 else {
857 kfree(vpbe_dev);
858 return -ENODEV;
859 }
860
861 /* set the driver data in platform device */
862 platform_set_drvdata(pdev, vpbe_dev);
863 mutex_init(&vpbe_dev->lock);
864
865 return 0;
866}
867
868static int vpbe_remove(struct platform_device *device)
869{
870 struct vpbe_device *vpbe_dev = platform_get_drvdata(device);
871
872 kfree(vpbe_dev);
873
874 return 0;
875}
876
877static struct platform_driver vpbe_driver = {
878 .driver = {
879 .name = "vpbe_controller",
880 .owner = THIS_MODULE,
881 },
882 .probe = vpbe_probe,
883 .remove = vpbe_remove,
884};
885
886module_platform_driver(vpbe_driver);
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-11 07:29:18 -0500