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         enum v4l2_mbus_pixelcode 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                 .owner  = THIS_MODULE,
 880         },
 881         .probe = vpbe_probe,
 882         .remove = vpbe_remove,
 883 };
 884
 885 module_platform_driver(vpbe_driver);