1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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
58
59
60
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
74
75
76
77
78
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
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
101
102
103
104
105
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
123
124
125
126
127
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
177
178static 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) &&
189 (var.std_id & std_id)) {
190 vpbe_dev->current_timings = var;
191 return 0;
192 }
193 }
194
195 return -EINVAL;
196}
197
198static 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
219
220
221
222
223
224static 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;
229 struct venc_platform_data *venc_device = vpbe_dev->venc_device;
230 u32 if_params;
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
244
245
246
247
248
249
250
251 if (strcmp(curr_enc_info->module_name,
252 cfg->outputs[index].subdev_name)) {
253
254 sd_index = vpbe_find_encoder_sd_index(cfg, index);
255 if (sd_index < 0) {
256 ret = -EINVAL;
257 goto out;
258 }
259
260 if_params = cfg->outputs[index].if_params;
261 venc_device->setup_if_config(if_params);
262 if (ret)
263 goto out;
264 }
265
266
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
274
275
276
277
278
279
280 ret = vpbe_get_mode_info(vpbe_dev,
281 cfg->outputs[index].default_mode, index);
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 }
292out:
293 mutex_unlock(&vpbe_dev->lock);
294 return ret;
295}
296
297static 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
317
318
319
320
321static unsigned int vpbe_get_output(struct vpbe_device *vpbe_dev)
322{
323 return vpbe_dev->current_out_index;
324}
325
326
327
328
329
330
331
332static int vpbe_s_dv_timings(struct vpbe_device *vpbe_dev,
333 struct v4l2_dv_timings *dv_timings)
334{
335 struct vpbe_config *cfg = vpbe_dev->cfg;
336 int out_index = vpbe_dev->current_out_index;
337 struct vpbe_output *output = &cfg->outputs[out_index];
338 int sd_index = vpbe_dev->current_sd_index;
339 int ret, i;
340
341
342 if (!(cfg->outputs[out_index].output.capabilities &
343 V4L2_OUT_CAP_DV_TIMINGS))
344 return -ENODATA;
345
346 for (i = 0; i < output->num_modes; i++) {
347 if (output->modes[i].timings_type == VPBE_ENC_DV_TIMINGS &&
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];
355 mutex_lock(&vpbe_dev->lock);
356
357 ret = v4l2_subdev_call(vpbe_dev->encoders[sd_index], video,
358 s_dv_timings, dv_timings);
359 if (!ret && (vpbe_dev->amp != NULL)) {
360
361 ret = v4l2_subdev_call(vpbe_dev->amp, video,
362 s_dv_timings, dv_timings);
363 }
364
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
379
380
381
382
383
384static int vpbe_g_dv_timings(struct vpbe_device *vpbe_dev,
385 struct v4l2_dv_timings *dv_timings)
386{
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
394 if (vpbe_dev->current_timings.timings_type &
395 VPBE_ENC_DV_TIMINGS) {
396 *dv_timings = vpbe_dev->current_timings.dv_timings;
397 return 0;
398 }
399
400 return -EINVAL;
401}
402
403
404
405
406
407
408
409static int vpbe_enum_dv_timings(struct vpbe_device *vpbe_dev,
410 struct v4l2_enum_dv_timings *timings)
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
418 if (!(output->output.capabilities & V4L2_OUT_CAP_DV_TIMINGS))
419 return -ENODATA;
420
421 for (i = 0; i < output->num_modes; i++) {
422 if (output->modes[i].timings_type == VPBE_ENC_DV_TIMINGS) {
423 if (j == timings->index)
424 break;
425 j++;
426 }
427 }
428
429 if (i == output->num_modes)
430 return -EINVAL;
431 timings->timings = output->modes[i].dv_timings;
432 return 0;
433}
434
435
436
437
438
439
440
441static int vpbe_s_std(struct vpbe_device *vpbe_dev, v4l2_std_id std_id)
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))
450 return -ENODATA;
451
452 ret = vpbe_get_std_info(vpbe_dev, std_id);
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,
459 s_std_output, std_id);
460
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
476
477
478
479
480static int vpbe_g_std(struct vpbe_device *vpbe_dev, v4l2_std_id *std_id)
481{
482 struct vpbe_enc_mode_info *cur_timings = &vpbe_dev->current_timings;
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;
488
489 if (cur_timings->timings_type & VPBE_ENC_STD) {
490 *std_id = cur_timings->std_id;
491 return 0;
492 }
493
494 return -EINVAL;
495}
496
497
498
499
500
501
502
503
504static 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;
509 struct v4l2_dv_timings dv_timings;
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
524
525
526 if (preset_mode->timings_type & VPBE_ENC_STD)
527 return vpbe_s_std(vpbe_dev,
528 preset_mode->std_id);
529 if (preset_mode->timings_type &
530 VPBE_ENC_DV_TIMINGS) {
531 dv_timings =
532 preset_mode->dv_timings;
533 return vpbe_s_dv_timings(vpbe_dev, &dv_timings);
534 }
535 }
536 }
537
538
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
556static 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
565 return vpbe_set_mode(vpbe_dev, &vpbe_dev->current_timings);
566}
567
568static 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
573 if (strstr(pdev->name, "vpbe-osd") != NULL)
574 vpbe_dev->osd_device = platform_get_drvdata(pdev);
575 if (strstr(pdev->name, "vpbe-venc") != NULL)
576 vpbe_dev->venc_device = dev_get_platdata(&pdev->dev);
577
578 return 0;
579}
580
581
582
583
584
585
586
587
588
589
590
591
592static int vpbe_initialize(struct device *dev, struct vpbe_device *vpbe_dev)
593{
594 struct encoder_config_info *enc_info;
595 struct amp_config_info *amp_info;
596 struct v4l2_subdev **enc_subdev;
597 struct osd_state *osd_device;
598 struct i2c_adapter *i2c_adap;
599 int num_encoders;
600 int ret = 0;
601 int err;
602 int i;
603
604
605
606
607
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
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);
624 goto fail_mutex_unlock;
625 }
626 if (clk_prepare_enable(vpbe_dev->dac_clk)) {
627 ret = -ENODEV;
628 clk_put(vpbe_dev->dac_clk);
629 goto fail_mutex_unlock;
630 }
631 }
632
633
634 vpss_enable_clock(VPSS_VPBE_CLOCK, 1);
635
636
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");
641 goto fail_clk_put;
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);
647 if (err < 0) {
648 ret = err;
649 goto fail_dev_unregister;
650 }
651
652 vpbe_dev->venc = venc_sub_dev_init(&vpbe_dev->v4l2_dev,
653 vpbe_dev->cfg->venc.module_name);
654
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;
659 goto fail_dev_unregister;
660 }
661
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;
670 goto fail_dev_unregister;
671 }
672 }
673
674
675
676
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;
686 goto fail_dev_unregister;
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
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;
712 goto fail_kfree_encoders;
713 }
714 } else
715 v4l2_warn(&vpbe_dev->v4l2_dev, "non-i2c encoders"
716 " currently not supported");
717 }
718
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;
731 goto fail_kfree_encoders;
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 }
744
745
746 vpbe_dev->current_sd_index = 0;
747 vpbe_dev->current_out_index = 0;
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
768 return 0;
769
770fail_kfree_encoders:
771 kfree(vpbe_dev->encoders);
772fail_dev_unregister:
773 v4l2_device_unregister(&vpbe_dev->v4l2_dev);
774fail_clk_put:
775 if (strcmp(vpbe_dev->cfg->module_name, "dm644x-vpbe-display") != 0) {
776 clk_disable_unprepare(vpbe_dev->dac_clk);
777 clk_put(vpbe_dev->dac_clk);
778 }
779fail_mutex_unlock:
780 mutex_unlock(&vpbe_dev->lock);
781 return ret;
782}
783
784
785
786
787
788
789
790
791
792static void vpbe_deinitialize(struct device *dev, struct vpbe_device *vpbe_dev)
793{
794 v4l2_device_unregister(&vpbe_dev->v4l2_dev);
795 if (strcmp(vpbe_dev->cfg->module_name, "dm644x-vpbe-display") != 0) {
796 clk_disable_unprepare(vpbe_dev->dac_clk);
797 clk_put(vpbe_dev->dac_clk);
798 }
799
800 kfree(vpbe_dev->amp);
801 kfree(vpbe_dev->encoders);
802 vpbe_dev->initialized = 0;
803
804 vpss_enable_clock(VPSS_VPBE_CLOCK, 0);
805}
806
807static 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,
812 .s_dv_timings = vpbe_s_dv_timings,
813 .g_dv_timings = vpbe_g_dv_timings,
814 .enum_dv_timings = vpbe_enum_dv_timings,
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
823static int vpbe_probe(struct platform_device *pdev)
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];
855 else {
856 kfree(vpbe_dev);
857 return -ENODEV;
858 }
859
860
861 platform_set_drvdata(pdev, vpbe_dev);
862 mutex_init(&vpbe_dev->lock);
863
864 return 0;
865}
866
867static 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
876static struct platform_driver vpbe_driver = {
877 .driver = {
878 .name = "vpbe_controller",
879 },
880 .probe = vpbe_probe,
881 .remove = vpbe_remove,
882};
883
884module_platform_driver(vpbe_driver);
885