2 * Copyright (C) 2010 Texas Instruments Inc
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.
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.
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
17 #include <linux/kernel.h>
18 #include <linux/init.h>
19 #include <linux/module.h>
20 #include <linux/errno.h>
22 #include <linux/string.h>
23 #include <linux/wait.h>
24 #include <linux/time.h>
25 #include <linux/platform_device.h>
27 #include <linux/slab.h>
28 #include <linux/clk.h>
29 #include <linux/err.h>
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>
37 #define VPBE_DEFAULT_OUTPUT "Composite"
38 #define VPBE_DEFAULT_MODE "ntsc"
40 static char *def_output = VPBE_DEFAULT_OUTPUT;
41 static char *def_mode = VPBE_DEFAULT_MODE;
44 module_param(def_output, charp, S_IRUGO);
45 module_param(def_mode, charp, S_IRUGO);
46 module_param(debug, int, 0644);
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");
52 MODULE_DESCRIPTION("TI DMXXX VPBE Display controller");
53 MODULE_LICENSE("GPL");
54 MODULE_AUTHOR("Texas Instruments");
57 * vpbe_current_encoder_info - Get config info for current encoder
58 * @vpbe_dev - vpbe device ptr
60 * Return ptr to current encoder config info
62 static struct encoder_config_info*
63 vpbe_current_encoder_info(struct vpbe_device *vpbe_dev)
65 struct vpbe_config *cfg = vpbe_dev->cfg;
66 int index = vpbe_dev->current_sd_index;
68 return ((index == 0) ? &cfg->venc :
69 &cfg->ext_encoders[index-1]);
73 * vpbe_find_encoder_sd_index - Given a name find encoder sd index
75 * @vpbe_config - ptr to vpbe cfg
76 * @output_index - index used by application
78 * Return sd index of the encoder
80 static int vpbe_find_encoder_sd_index(struct vpbe_config *cfg,
83 char *encoder_name = cfg->outputs[index].subdev_name;
86 /* Venc is always first */
87 if (!strcmp(encoder_name, cfg->venc.module_name))
90 for (i = 0; i < cfg->num_ext_encoders; i++) {
91 if (!strcmp(encoder_name,
92 cfg->ext_encoders[i].module_name))
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
104 * Update the crop capabilities in crop cap for current
107 static int vpbe_g_cropcap(struct vpbe_device *vpbe_dev,
108 struct v4l2_cropcap *cropcap)
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;
122 * vpbe_enum_outputs - enumerate outputs
123 * @vpbe_dev - vpbe device ptr
124 * @output - ptr to v4l2_output structure
126 * Enumerates the outputs available at the vpbe display
127 * returns the status, -EINVAL if end of output list
129 static int vpbe_enum_outputs(struct vpbe_device *vpbe_dev,
130 struct v4l2_output *output)
132 struct vpbe_config *cfg = vpbe_dev->cfg;
133 int temp_index = output->index;
135 if (temp_index >= cfg->num_outputs)
138 *output = cfg->outputs[temp_index].output;
139 output->index = temp_index;
144 static int vpbe_get_mode_info(struct vpbe_device *vpbe_dev, char *mode,
147 struct vpbe_config *cfg = vpbe_dev->cfg;
148 struct vpbe_enc_mode_info var;
149 int curr_output = output_index;
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;
166 static int vpbe_get_current_mode_info(struct vpbe_device *vpbe_dev,
167 struct vpbe_enc_mode_info *mode_info)
169 if (NULL == mode_info)
172 *mode_info = vpbe_dev->current_timings;
177 /* Get std by std id */
178 static int vpbe_get_std_info(struct vpbe_device *vpbe_dev,
181 struct vpbe_config *cfg = vpbe_dev->cfg;
182 struct vpbe_enc_mode_info var;
183 int curr_output = vpbe_dev->current_out_index;
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;
198 static int vpbe_get_std_info_by_name(struct vpbe_device *vpbe_dev,
201 struct vpbe_config *cfg = vpbe_dev->cfg;
202 struct vpbe_enc_mode_info var;
203 int curr_output = vpbe_dev->current_out_index;
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;
218 * vpbe_set_output - Set output
219 * @vpbe_dev - vpbe device ptr
220 * @index - index of output
222 * Set vpbe output to the output specified by the index
224 static int vpbe_set_output(struct vpbe_device *vpbe_dev, int index)
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 enum v4l2_mbus_pixelcode if_params;
235 if (index >= cfg->num_outputs)
238 mutex_lock(&vpbe_dev->lock);
240 sd_index = vpbe_dev->current_sd_index;
241 enc_out_index = cfg->outputs[index].output.index;
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.
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);
260 if_params = cfg->outputs[index].if_params;
261 venc_device->setup_if_config(if_params);
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);
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
280 ret = vpbe_get_mode_info(vpbe_dev,
281 cfg->outputs[index].default_mode, index);
283 struct osd_state *osd_device = vpbe_dev->osd_device;
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;
293 mutex_unlock(&vpbe_dev->lock);
297 static int vpbe_set_default_output(struct vpbe_device *vpbe_dev)
299 struct vpbe_config *cfg = vpbe_dev->cfg;
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);
308 vpbe_dev->current_out_index = i;
316 * vpbe_get_output - Get output
317 * @vpbe_dev - vpbe device ptr
319 * return current vpbe output to the the index
321 static unsigned int vpbe_get_output(struct vpbe_device *vpbe_dev)
323 return vpbe_dev->current_out_index;
327 * vpbe_s_dv_timings - Set the given preset timings in the encoder
329 * Sets the timings if supported by the current encoder. Return the status.
330 * 0 - success & -EINVAL on error
332 static int vpbe_s_dv_timings(struct vpbe_device *vpbe_dev,
333 struct v4l2_dv_timings *dv_timings)
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;
342 if (!(cfg->outputs[out_index].output.capabilities &
343 V4L2_OUT_CAP_DV_TIMINGS))
346 for (i = 0; i < output->num_modes; i++) {
347 if (output->modes[i].timings_type == VPBE_ENC_CUSTOM_TIMINGS &&
348 !memcmp(&output->modes[i].dv_timings,
349 dv_timings, sizeof(*dv_timings)))
352 if (i >= output->num_modes)
354 vpbe_dev->current_timings = output->modes[i];
355 mutex_lock(&vpbe_dev->lock);
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 /* Call amplifier subdevice */
361 ret = v4l2_subdev_call(vpbe_dev->amp, video,
362 s_dv_timings, dv_timings);
364 /* set the lcd controller output for the given mode */
366 struct osd_state *osd_device = vpbe_dev->osd_device;
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);
373 mutex_unlock(&vpbe_dev->lock);
379 * vpbe_g_dv_timings - Get the timings in the current encoder
381 * Get the timings in the current encoder. Return the status. 0 - success
384 static int vpbe_g_dv_timings(struct vpbe_device *vpbe_dev,
385 struct v4l2_dv_timings *dv_timings)
387 if (vpbe_dev->current_timings.timings_type &
388 VPBE_ENC_CUSTOM_TIMINGS) {
389 *dv_timings = vpbe_dev->current_timings.dv_timings;
397 * vpbe_enum_dv_timings - Enumerate the dv timings in the current encoder
399 * Get the timings in the current encoder. Return the status. 0 - success
402 static int vpbe_enum_dv_timings(struct vpbe_device *vpbe_dev,
403 struct v4l2_enum_dv_timings *timings)
405 struct vpbe_config *cfg = vpbe_dev->cfg;
406 int out_index = vpbe_dev->current_out_index;
407 struct vpbe_output *output = &cfg->outputs[out_index];
411 if (!(output->output.capabilities & V4L2_OUT_CAP_DV_TIMINGS))
414 for (i = 0; i < output->num_modes; i++) {
415 if (output->modes[i].timings_type == VPBE_ENC_CUSTOM_TIMINGS) {
416 if (j == timings->index)
422 if (i == output->num_modes)
424 timings->timings = output->modes[i].dv_timings;
429 * vpbe_s_std - Set the given standard in the encoder
431 * Sets the standard if supported by the current encoder. Return the status.
432 * 0 - success & -EINVAL on error
434 static int vpbe_s_std(struct vpbe_device *vpbe_dev, v4l2_std_id *std_id)
436 struct vpbe_config *cfg = vpbe_dev->cfg;
437 int out_index = vpbe_dev->current_out_index;
438 int sd_index = vpbe_dev->current_sd_index;
441 if (!(cfg->outputs[out_index].output.capabilities &
445 ret = vpbe_get_std_info(vpbe_dev, *std_id);
449 mutex_lock(&vpbe_dev->lock);
451 ret = v4l2_subdev_call(vpbe_dev->encoders[sd_index], video,
452 s_std_output, *std_id);
453 /* set the lcd controller output for the given mode */
455 struct osd_state *osd_device = vpbe_dev->osd_device;
457 osd_device->ops.set_left_margin(osd_device,
458 vpbe_dev->current_timings.left_margin);
459 osd_device->ops.set_top_margin(osd_device,
460 vpbe_dev->current_timings.upper_margin);
462 mutex_unlock(&vpbe_dev->lock);
468 * vpbe_g_std - Get the standard in the current encoder
470 * Get the standard in the current encoder. Return the status. 0 - success
473 static int vpbe_g_std(struct vpbe_device *vpbe_dev, v4l2_std_id *std_id)
475 struct vpbe_enc_mode_info *cur_timings = &vpbe_dev->current_timings;
477 if (cur_timings->timings_type & VPBE_ENC_STD) {
478 *std_id = cur_timings->std_id;
486 * vpbe_set_mode - Set mode in the current encoder using mode info
488 * Use the mode string to decide what timings to set in the encoder
489 * This is typically useful when fbset command is used to change the current
490 * timings by specifying a string to indicate the timings.
492 static int vpbe_set_mode(struct vpbe_device *vpbe_dev,
493 struct vpbe_enc_mode_info *mode_info)
495 struct vpbe_enc_mode_info *preset_mode = NULL;
496 struct vpbe_config *cfg = vpbe_dev->cfg;
497 struct v4l2_dv_timings dv_timings;
498 struct osd_state *osd_device;
499 int out_index = vpbe_dev->current_out_index;
503 if ((NULL == mode_info) || (NULL == mode_info->name))
506 for (i = 0; i < cfg->outputs[out_index].num_modes; i++) {
507 if (!strcmp(mode_info->name,
508 cfg->outputs[out_index].modes[i].name)) {
509 preset_mode = &cfg->outputs[out_index].modes[i];
511 * it may be one of the 3 timings type. Check and
514 if (preset_mode->timings_type & VPBE_ENC_STD)
515 return vpbe_s_std(vpbe_dev,
516 &preset_mode->std_id);
517 if (preset_mode->timings_type &
518 VPBE_ENC_CUSTOM_TIMINGS) {
520 preset_mode->dv_timings;
521 return vpbe_s_dv_timings(vpbe_dev, &dv_timings);
526 /* Only custom timing should reach here */
527 if (preset_mode == NULL)
530 mutex_lock(&vpbe_dev->lock);
532 osd_device = vpbe_dev->osd_device;
533 vpbe_dev->current_timings = *preset_mode;
534 osd_device->ops.set_left_margin(osd_device,
535 vpbe_dev->current_timings.left_margin);
536 osd_device->ops.set_top_margin(osd_device,
537 vpbe_dev->current_timings.upper_margin);
539 mutex_unlock(&vpbe_dev->lock);
544 static int vpbe_set_default_mode(struct vpbe_device *vpbe_dev)
548 ret = vpbe_get_std_info_by_name(vpbe_dev, def_mode);
552 /* set the default mode in the encoder */
553 return vpbe_set_mode(vpbe_dev, &vpbe_dev->current_timings);
556 static int platform_device_get(struct device *dev, void *data)
558 struct platform_device *pdev = to_platform_device(dev);
559 struct vpbe_device *vpbe_dev = data;
561 if (strcmp("vpbe-osd", pdev->name) == 0)
562 vpbe_dev->osd_device = platform_get_drvdata(pdev);
563 if (strcmp("vpbe-venc", pdev->name) == 0)
564 vpbe_dev->venc_device = dev_get_platdata(&pdev->dev);
570 * vpbe_initialize() - Initialize the vpbe display controller
571 * @vpbe_dev - vpbe device ptr
573 * Master frame buffer device drivers calls this to initialize vpbe
574 * display controller. This will then registers v4l2 device and the sub
575 * devices and sets a current encoder sub device for display. v4l2 display
576 * device driver is the master and frame buffer display device driver is
577 * the slave. Frame buffer display driver checks the initialized during
578 * probe and exit if not initialized. Returns status.
580 static int vpbe_initialize(struct device *dev, struct vpbe_device *vpbe_dev)
582 struct encoder_config_info *enc_info;
583 struct amp_config_info *amp_info;
584 struct v4l2_subdev **enc_subdev;
585 struct osd_state *osd_device;
586 struct i2c_adapter *i2c_adap;
594 * v4l2 abd FBDev frame buffer devices will get the vpbe_dev pointer
595 * from the platform device by iteration of platform drivers and
596 * matching with device name
598 if (NULL == vpbe_dev || NULL == dev) {
599 printk(KERN_ERR "Null device pointers.\n");
603 if (vpbe_dev->initialized)
606 mutex_lock(&vpbe_dev->lock);
608 if (strcmp(vpbe_dev->cfg->module_name, "dm644x-vpbe-display") != 0) {
609 /* We have dac clock available for platform */
610 vpbe_dev->dac_clk = clk_get(vpbe_dev->pdev, "vpss_dac");
611 if (IS_ERR(vpbe_dev->dac_clk)) {
612 ret = PTR_ERR(vpbe_dev->dac_clk);
613 goto fail_mutex_unlock;
615 if (clk_enable(vpbe_dev->dac_clk)) {
617 goto fail_mutex_unlock;
621 /* first enable vpss clocks */
622 vpss_enable_clock(VPSS_VPBE_CLOCK, 1);
624 /* First register a v4l2 device */
625 ret = v4l2_device_register(dev, &vpbe_dev->v4l2_dev);
627 v4l2_err(dev->driver,
628 "Unable to register v4l2 device.\n");
631 v4l2_info(&vpbe_dev->v4l2_dev, "vpbe v4l2 device registered\n");
633 err = bus_for_each_dev(&platform_bus_type, NULL, vpbe_dev,
634 platform_device_get);
638 vpbe_dev->venc = venc_sub_dev_init(&vpbe_dev->v4l2_dev,
639 vpbe_dev->cfg->venc.module_name);
640 /* register venc sub device */
641 if (vpbe_dev->venc == NULL) {
642 v4l2_err(&vpbe_dev->v4l2_dev,
643 "vpbe unable to init venc sub device\n");
645 goto fail_dev_unregister;
647 /* initialize osd device */
648 osd_device = vpbe_dev->osd_device;
650 if (NULL != osd_device->ops.initialize) {
651 err = osd_device->ops.initialize(osd_device);
653 v4l2_err(&vpbe_dev->v4l2_dev,
654 "unable to initialize the OSD device");
656 goto fail_dev_unregister;
661 * Register any external encoders that are configured. At index 0 we
662 * store venc sd index.
664 num_encoders = vpbe_dev->cfg->num_ext_encoders + 1;
665 vpbe_dev->encoders = kmalloc(
666 sizeof(struct v4l2_subdev *)*num_encoders,
668 if (NULL == vpbe_dev->encoders) {
669 v4l2_err(&vpbe_dev->v4l2_dev,
670 "unable to allocate memory for encoders sub devices");
672 goto fail_dev_unregister;
675 i2c_adap = i2c_get_adapter(vpbe_dev->cfg->i2c_adapter_id);
676 for (i = 0; i < (vpbe_dev->cfg->num_ext_encoders + 1); i++) {
678 /* venc is at index 0 */
679 enc_subdev = &vpbe_dev->encoders[i];
680 *enc_subdev = vpbe_dev->venc;
683 enc_info = &vpbe_dev->cfg->ext_encoders[i];
684 if (enc_info->is_i2c) {
685 enc_subdev = &vpbe_dev->encoders[i];
686 *enc_subdev = v4l2_i2c_new_subdev_board(
687 &vpbe_dev->v4l2_dev, i2c_adap,
688 &enc_info->board_info, NULL);
690 v4l2_info(&vpbe_dev->v4l2_dev,
691 "v4l2 sub device %s registered\n",
692 enc_info->module_name);
694 v4l2_err(&vpbe_dev->v4l2_dev, "encoder %s"
695 " failed to register",
696 enc_info->module_name);
698 goto fail_kfree_encoders;
701 v4l2_warn(&vpbe_dev->v4l2_dev, "non-i2c encoders"
702 " currently not supported");
704 /* Add amplifier subdevice for dm365 */
705 if ((strcmp(vpbe_dev->cfg->module_name, "dm365-vpbe-display") == 0) &&
706 vpbe_dev->cfg->amp != NULL) {
707 amp_info = vpbe_dev->cfg->amp;
708 if (amp_info->is_i2c) {
709 vpbe_dev->amp = v4l2_i2c_new_subdev_board(
710 &vpbe_dev->v4l2_dev, i2c_adap,
711 &_info->board_info, NULL);
712 if (!vpbe_dev->amp) {
713 v4l2_err(&vpbe_dev->v4l2_dev,
714 "amplifier %s failed to register",
715 amp_info->module_name);
717 goto fail_kfree_encoders;
719 v4l2_info(&vpbe_dev->v4l2_dev,
720 "v4l2 sub device %s registered\n",
721 amp_info->module_name);
723 vpbe_dev->amp = NULL;
724 v4l2_warn(&vpbe_dev->v4l2_dev, "non-i2c amplifiers"
725 " currently not supported");
728 vpbe_dev->amp = NULL;
731 /* set the current encoder and output to that of venc by default */
732 vpbe_dev->current_sd_index = 0;
733 vpbe_dev->current_out_index = 0;
736 mutex_unlock(&vpbe_dev->lock);
738 printk(KERN_NOTICE "Setting default output to %s\n", def_output);
739 ret = vpbe_set_default_output(vpbe_dev);
741 v4l2_err(&vpbe_dev->v4l2_dev, "Failed to set default output %s",
746 printk(KERN_NOTICE "Setting default mode to %s\n", def_mode);
747 ret = vpbe_set_default_mode(vpbe_dev);
749 v4l2_err(&vpbe_dev->v4l2_dev, "Failed to set default mode %s",
753 vpbe_dev->initialized = 1;
754 /* TBD handling of bootargs for default output and mode */
758 kfree(vpbe_dev->encoders);
760 v4l2_device_unregister(&vpbe_dev->v4l2_dev);
762 if (strcmp(vpbe_dev->cfg->module_name, "dm644x-vpbe-display") != 0)
763 clk_put(vpbe_dev->dac_clk);
765 mutex_unlock(&vpbe_dev->lock);
770 * vpbe_deinitialize() - de-initialize the vpbe display controller
771 * @dev - Master and slave device ptr
773 * vpbe_master and slave frame buffer devices calls this to de-initialize
774 * the display controller. It is called when master and slave device
775 * driver modules are removed and no longer requires the display controller.
777 static void vpbe_deinitialize(struct device *dev, struct vpbe_device *vpbe_dev)
779 v4l2_device_unregister(&vpbe_dev->v4l2_dev);
780 if (strcmp(vpbe_dev->cfg->module_name, "dm644x-vpbe-display") != 0)
781 clk_put(vpbe_dev->dac_clk);
783 kfree(vpbe_dev->amp);
784 kfree(vpbe_dev->encoders);
785 vpbe_dev->initialized = 0;
786 /* disable vpss clocks */
787 vpss_enable_clock(VPSS_VPBE_CLOCK, 0);
790 static struct vpbe_device_ops vpbe_dev_ops = {
791 .g_cropcap = vpbe_g_cropcap,
792 .enum_outputs = vpbe_enum_outputs,
793 .set_output = vpbe_set_output,
794 .get_output = vpbe_get_output,
795 .s_dv_timings = vpbe_s_dv_timings,
796 .g_dv_timings = vpbe_g_dv_timings,
797 .enum_dv_timings = vpbe_enum_dv_timings,
800 .initialize = vpbe_initialize,
801 .deinitialize = vpbe_deinitialize,
802 .get_mode_info = vpbe_get_current_mode_info,
803 .set_mode = vpbe_set_mode,
806 static __devinit int vpbe_probe(struct platform_device *pdev)
808 struct vpbe_device *vpbe_dev;
809 struct vpbe_config *cfg;
812 if (pdev->dev.platform_data == NULL) {
813 v4l2_err(pdev->dev.driver, "No platform data\n");
816 cfg = pdev->dev.platform_data;
818 if (!cfg->module_name[0] ||
819 !cfg->osd.module_name[0] ||
820 !cfg->venc.module_name[0]) {
821 v4l2_err(pdev->dev.driver, "vpbe display module names not"
826 vpbe_dev = kzalloc(sizeof(*vpbe_dev), GFP_KERNEL);
827 if (vpbe_dev == NULL) {
828 v4l2_err(pdev->dev.driver, "Unable to allocate memory"
829 " for vpbe_device\n");
833 vpbe_dev->ops = vpbe_dev_ops;
834 vpbe_dev->pdev = &pdev->dev;
836 if (cfg->outputs->num_modes > 0)
837 vpbe_dev->current_timings = vpbe_dev->cfg->outputs[0].modes[0];
843 /* set the driver data in platform device */
844 platform_set_drvdata(pdev, vpbe_dev);
845 mutex_init(&vpbe_dev->lock);
850 static int vpbe_remove(struct platform_device *device)
852 struct vpbe_device *vpbe_dev = platform_get_drvdata(device);
859 static struct platform_driver vpbe_driver = {
861 .name = "vpbe_controller",
862 .owner = THIS_MODULE,
865 .remove = vpbe_remove,
868 module_platform_driver(vpbe_driver);