Version:  2.0.40 2.2.26 2.4.37 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2

Linux/drivers/media/platform/davinci/vpbe.c

  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 
144 static 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 
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 
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) &&
189                   (var.std_id & std_id)) {
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;
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          * 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 
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         /* 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,
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         }
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 /**
327  * vpbe_s_dv_timings - Set the given preset timings in the encoder
328  *
329  * Sets the timings if supported by the current encoder. Return the status.
330  * 0 - success & -EINVAL on error
331  */
332 static 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                 /* Call amplifier subdevice */
361                 ret = v4l2_subdev_call(vpbe_dev->amp, video,
362                                 s_dv_timings, dv_timings);
363         }
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 /**
379  * vpbe_g_dv_timings - Get the timings in the current encoder
380  *
381  * Get the timings in the current encoder. Return the status. 0 - success
382  * -EINVAL on error
383  */
384 static 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  * vpbe_enum_dv_timings - Enumerate the dv timings in the current encoder
405  *
406  * Get the timings in the current encoder. Return the status. 0 - success
407  * -EINVAL on error
408  */
409 static 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  * 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  */
441 static 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         /* 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 {
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  * 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;
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                          * 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,
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         /* 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 
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  * 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;
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          * 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);
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         /* 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");
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         /* 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;
659                 goto fail_dev_unregister;
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;
670                         goto fail_dev_unregister;
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;
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                         /* 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;
712                                 goto fail_kfree_encoders;
713                         }
714                 } else
715                         v4l2_warn(&vpbe_dev->v4l2_dev, "non-i2c encoders"
716                                  " currently not supported");
717         }
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                         &amp_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         /* 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;
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 
770 fail_kfree_encoders:
771         kfree(vpbe_dev->encoders);
772 fail_dev_unregister:
773         v4l2_device_unregister(&vpbe_dev->v4l2_dev);
774 fail_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         }
779 fail_mutex_unlock:
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);
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         /* 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,
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 
823 static 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         /* 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",
879         },
880         .probe = vpbe_probe,
881         .remove = vpbe_remove,
882 };
883 
884 module_platform_driver(vpbe_driver);
885 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us