LXR linux/drivers/media/platform/davinci/vpbe.c

   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * Copyright (C) 2010 Texas Instruments Inc
   4 */
   5#include <linux/kernel.h>
   6#include <linux/init.h>
   7#include <linux/module.h>
   8#include <linux/errno.h>
   9#include <linux/fs.h>
  10#include <linux/string.h>
  11#include <linux/wait.h>
  12#include <linux/time.h>
  13#include <linux/platform_device.h>
  14#include <linux/io.h>
  15#include <linux/slab.h>
  16#include <linux/clk.h>
  17#include <linux/err.h>
  18
  19#include <media/v4l2-device.h>
  20#include <media/davinci/vpbe_types.h>
  21#include <media/davinci/vpbe.h>
  22#include <media/davinci/vpss.h>
  23#include <media/davinci/vpbe_venc.h>
  24
  25#define VPBE_DEFAULT_OUTPUT     "Composite"
  26#define VPBE_DEFAULT_MODE       "ntsc"
  27
  28static char *def_output = VPBE_DEFAULT_OUTPUT;
  29static char *def_mode = VPBE_DEFAULT_MODE;
  30static int debug;
  31
  32module_param(def_output, charp, S_IRUGO);
  33module_param(def_mode, charp, S_IRUGO);
  34module_param(debug, int, 0644);
  35
  36MODULE_PARM_DESC(def_output, "vpbe output name (default:Composite)");
  37MODULE_PARM_DESC(def_mode, "vpbe output mode name (default:ntsc");
  38MODULE_PARM_DESC(debug, "Debug level 0-1");
  39
  40MODULE_DESCRIPTION("TI DMXXX VPBE Display controller");
  41MODULE_LICENSE("GPL");
  42MODULE_AUTHOR("Texas Instruments");
  43
  44/**
  45 * vpbe_current_encoder_info - Get config info for current encoder
  46 * @vpbe_dev: vpbe device ptr
  47 *
  48 * Return ptr to current encoder config info
  49 */
  50static struct encoder_config_info*
  51vpbe_current_encoder_info(struct vpbe_device *vpbe_dev)
  52{
  53        struct vpbe_config *cfg = vpbe_dev->cfg;
  54        int index = vpbe_dev->current_sd_index;
  55
  56        return ((index == 0) ? &cfg->venc :
  57                                &cfg->ext_encoders[index-1]);
  58}
  59
  60/**
  61 * vpbe_find_encoder_sd_index - Given a name find encoder sd index
  62 *
  63 * @cfg: ptr to vpbe cfg
  64 * @index: index used by application
  65 *
  66 * Return sd index of the encoder
  67 */
  68static int vpbe_find_encoder_sd_index(struct vpbe_config *cfg,
  69                             int index)
  70{
  71        char *encoder_name = cfg->outputs[index].subdev_name;
  72        int i;
  73
  74        /* Venc is always first */
  75        if (!strcmp(encoder_name, cfg->venc.module_name))
  76                return 0;
  77
  78        for (i = 0; i < cfg->num_ext_encoders; i++) {
  79                if (!strcmp(encoder_name,
  80                     cfg->ext_encoders[i].module_name))
  81                        return i+1;
  82        }
  83
  84        return -EINVAL;
  85}
  86
  87/**
  88 * vpbe_enum_outputs - enumerate outputs
  89 * @vpbe_dev: vpbe device ptr
  90 * @output: ptr to v4l2_output structure
  91 *
  92 * Enumerates the outputs available at the vpbe display
  93 * returns the status, -EINVAL if end of output list
  94 */
  95static int vpbe_enum_outputs(struct vpbe_device *vpbe_dev,
  96                             struct v4l2_output *output)
  97{
  98        struct vpbe_config *cfg = vpbe_dev->cfg;
  99        unsigned int temp_index = output->index;
 100
 101        if (temp_index >= cfg->num_outputs)
 102                return -EINVAL;
 103
 104        *output = cfg->outputs[temp_index].output;
 105        output->index = temp_index;
 106
 107        return 0;
 108}
 109
 110static int vpbe_get_mode_info(struct vpbe_device *vpbe_dev, char *mode,
 111                              int output_index)
 112{
 113        struct vpbe_config *cfg = vpbe_dev->cfg;
 114        struct vpbe_enc_mode_info var;
 115        int curr_output = output_index;
 116        int i;
 117
 118        if (!mode)
 119                return -EINVAL;
 120
 121        for (i = 0; i < cfg->outputs[curr_output].num_modes; i++) {
 122                var = cfg->outputs[curr_output].modes[i];
 123                if (!strcmp(mode, var.name)) {
 124                        vpbe_dev->current_timings = var;
 125                        return 0;
 126                }
 127        }
 128
 129        return -EINVAL;
 130}
 131
 132static int vpbe_get_current_mode_info(struct vpbe_device *vpbe_dev,
 133                                      struct vpbe_enc_mode_info *mode_info)
 134{
 135        if (!mode_info)
 136                return -EINVAL;
 137
 138        *mode_info = vpbe_dev->current_timings;
 139
 140        return 0;
 141}
 142
 143/* Get std by std id */
 144static int vpbe_get_std_info(struct vpbe_device *vpbe_dev,
 145                             v4l2_std_id std_id)
 146{
 147        struct vpbe_config *cfg = vpbe_dev->cfg;
 148        struct vpbe_enc_mode_info var;
 149        int curr_output = vpbe_dev->current_out_index;
 150        int i;
 151
 152        for (i = 0; i < vpbe_dev->cfg->outputs[curr_output].num_modes; i++) {
 153                var = cfg->outputs[curr_output].modes[i];
 154                if ((var.timings_type & VPBE_ENC_STD) &&
 155                  (var.std_id & std_id)) {
 156                        vpbe_dev->current_timings = var;
 157                        return 0;
 158                }
 159        }
 160
 161        return -EINVAL;
 162}
 163
 164static int vpbe_get_std_info_by_name(struct vpbe_device *vpbe_dev,
 165                                char *std_name)
 166{
 167        struct vpbe_config *cfg = vpbe_dev->cfg;
 168        struct vpbe_enc_mode_info var;
 169        int curr_output = vpbe_dev->current_out_index;
 170        int i;
 171
 172        for (i = 0; i < vpbe_dev->cfg->outputs[curr_output].num_modes; i++) {
 173                var = cfg->outputs[curr_output].modes[i];
 174                if (!strcmp(var.name, std_name)) {
 175                        vpbe_dev->current_timings = var;
 176                        return 0;
 177                }
 178        }
 179
 180        return -EINVAL;
 181}
 182
 183/**
 184 * vpbe_set_output - Set output
 185 * @vpbe_dev: vpbe device ptr
 186 * @index: index of output
 187 *
 188 * Set vpbe output to the output specified by the index
 189 */
 190static int vpbe_set_output(struct vpbe_device *vpbe_dev, int index)
 191{
 192        struct encoder_config_info *curr_enc_info =
 193                        vpbe_current_encoder_info(vpbe_dev);
 194        struct vpbe_config *cfg = vpbe_dev->cfg;
 195        struct venc_platform_data *venc_device = vpbe_dev->venc_device;
 196        int enc_out_index;
 197        int sd_index;
 198        int ret;
 199
 200        if (index >= cfg->num_outputs)
 201                return -EINVAL;
 202
 203        mutex_lock(&vpbe_dev->lock);
 204
 205        sd_index = vpbe_dev->current_sd_index;
 206        enc_out_index = cfg->outputs[index].output.index;
 207        /*
 208         * Currently we switch the encoder based on output selected
 209         * by the application. If media controller is implemented later
 210         * there is will be an API added to setup_link between venc
 211         * and external encoder. So in that case below comparison always
 212         * match and encoder will not be switched. But if application
 213         * chose not to use media controller, then this provides current
 214         * way of switching encoder at the venc output.
 215         */
 216        if (strcmp(curr_enc_info->module_name,
 217                   cfg->outputs[index].subdev_name)) {
 218                /* Need to switch the encoder at the output */
 219                sd_index = vpbe_find_encoder_sd_index(cfg, index);
 220                if (sd_index < 0) {
 221                        ret = -EINVAL;
 222                        goto unlock;
 223                }
 224
 225                ret = venc_device->setup_if_config(cfg->outputs[index].if_params);
 226                if (ret)
 227                        goto unlock;
 228        }
 229
 230        /* Set output at the encoder */
 231        ret = v4l2_subdev_call(vpbe_dev->encoders[sd_index], video,
 232                                       s_routing, 0, enc_out_index, 0);
 233        if (ret)
 234                goto unlock;
 235
 236        /*
 237         * It is assumed that venc or external encoder will set a default
 238         * mode in the sub device. For external encoder or LCD pannel output,
 239         * we also need to set up the lcd port for the required mode. So setup
 240         * the lcd port for the default mode that is configured in the board
 241         * arch/arm/mach-davinci/board-dm355-evm.setup file for the external
 242         * encoder.
 243         */
 244        ret = vpbe_get_mode_info(vpbe_dev,
 245                                 cfg->outputs[index].default_mode, index);
 246        if (!ret) {
 247                struct osd_state *osd_device = vpbe_dev->osd_device;
 248
 249                osd_device->ops.set_left_margin(osd_device,
 250                        vpbe_dev->current_timings.left_margin);
 251                osd_device->ops.set_top_margin(osd_device,
 252                vpbe_dev->current_timings.upper_margin);
 253                vpbe_dev->current_sd_index = sd_index;
 254                vpbe_dev->current_out_index = index;
 255        }
 256unlock:
 257        mutex_unlock(&vpbe_dev->lock);
 258        return ret;
 259}
 260
 261static int vpbe_set_default_output(struct vpbe_device *vpbe_dev)
 262{
 263        struct vpbe_config *cfg = vpbe_dev->cfg;
 264        int i;
 265
 266        for (i = 0; i < cfg->num_outputs; i++) {
 267                if (!strcmp(def_output,
 268                            cfg->outputs[i].output.name)) {
 269                        int ret = vpbe_set_output(vpbe_dev, i);
 270
 271                        if (!ret)
 272                                vpbe_dev->current_out_index = i;
 273                        return ret;
 274                }
 275        }
 276        return 0;
 277}
 278
 279/**
 280 * vpbe_get_output - Get output
 281 * @vpbe_dev: vpbe device ptr
 282 *
 283 * return current vpbe output to the the index
 284 */
 285static unsigned int vpbe_get_output(struct vpbe_device *vpbe_dev)
 286{
 287        return vpbe_dev->current_out_index;
 288}
 289
 290/*
 291 * vpbe_s_dv_timings - Set the given preset timings in the encoder
 292 *
 293 * Sets the timings if supported by the current encoder. Return the status.
 294 * 0 - success & -EINVAL on error
 295 */
 296static int vpbe_s_dv_timings(struct vpbe_device *vpbe_dev,
 297                    struct v4l2_dv_timings *dv_timings)
 298{
 299        struct vpbe_config *cfg = vpbe_dev->cfg;
 300        int out_index = vpbe_dev->current_out_index;
 301        struct vpbe_output *output = &cfg->outputs[out_index];
 302        int sd_index = vpbe_dev->current_sd_index;
 303        int ret, i;
 304
 305
 306        if (!(cfg->outputs[out_index].output.capabilities &
 307            V4L2_OUT_CAP_DV_TIMINGS))
 308                return -ENODATA;
 309
 310        for (i = 0; i < output->num_modes; i++) {
 311                if (output->modes[i].timings_type == VPBE_ENC_DV_TIMINGS &&
 312                    !memcmp(&output->modes[i].dv_timings,
 313                                dv_timings, sizeof(*dv_timings)))
 314                        break;
 315        }
 316        if (i >= output->num_modes)
 317                return -EINVAL;
 318        vpbe_dev->current_timings = output->modes[i];
 319        mutex_lock(&vpbe_dev->lock);
 320
 321        ret = v4l2_subdev_call(vpbe_dev->encoders[sd_index], video,
 322                                        s_dv_timings, dv_timings);
 323        if (!ret && vpbe_dev->amp) {
 324                /* Call amplifier subdevice */
 325                ret = v4l2_subdev_call(vpbe_dev->amp, video,
 326                                s_dv_timings, dv_timings);
 327        }
 328        /* set the lcd controller output for the given mode */
 329        if (!ret) {
 330                struct osd_state *osd_device = vpbe_dev->osd_device;
 331
 332                osd_device->ops.set_left_margin(osd_device,
 333                vpbe_dev->current_timings.left_margin);
 334                osd_device->ops.set_top_margin(osd_device,
 335                vpbe_dev->current_timings.upper_margin);
 336        }
 337        mutex_unlock(&vpbe_dev->lock);
 338
 339        return ret;
 340}
 341
 342/*
 343 * vpbe_g_dv_timings - Get the timings in the current encoder
 344 *
 345 * Get the timings in the current encoder. Return the status. 0 - success
 346 * -EINVAL on error
 347 */
 348static int vpbe_g_dv_timings(struct vpbe_device *vpbe_dev,
 349                     struct v4l2_dv_timings *dv_timings)
 350{
 351        struct vpbe_config *cfg = vpbe_dev->cfg;
 352        int out_index = vpbe_dev->current_out_index;
 353
 354        if (!(cfg->outputs[out_index].output.capabilities &
 355                V4L2_OUT_CAP_DV_TIMINGS))
 356                return -ENODATA;
 357
 358        if (vpbe_dev->current_timings.timings_type &
 359          VPBE_ENC_DV_TIMINGS) {
 360                *dv_timings = vpbe_dev->current_timings.dv_timings;
 361                return 0;
 362        }
 363
 364        return -EINVAL;
 365}
 366
 367/*
 368 * vpbe_enum_dv_timings - Enumerate the dv timings in the current encoder
 369 *
 370 * Get the timings in the current encoder. Return the status. 0 - success
 371 * -EINVAL on error
 372 */
 373static int vpbe_enum_dv_timings(struct vpbe_device *vpbe_dev,
 374                         struct v4l2_enum_dv_timings *timings)
 375{
 376        struct vpbe_config *cfg = vpbe_dev->cfg;
 377        int out_index = vpbe_dev->current_out_index;
 378        struct vpbe_output *output = &cfg->outputs[out_index];
 379        int j = 0;
 380        int i;
 381
 382        if (!(output->output.capabilities & V4L2_OUT_CAP_DV_TIMINGS))
 383                return -ENODATA;
 384
 385        for (i = 0; i < output->num_modes; i++) {
 386                if (output->modes[i].timings_type == VPBE_ENC_DV_TIMINGS) {
 387                        if (j == timings->index)
 388                                break;
 389                        j++;
 390                }
 391        }
 392
 393        if (i == output->num_modes)
 394                return -EINVAL;
 395        timings->timings = output->modes[i].dv_timings;
 396        return 0;
 397}
 398
 399/*
 400 * vpbe_s_std - Set the given standard in the encoder
 401 *
 402 * Sets the standard if supported by the current encoder. Return the status.
 403 * 0 - success & -EINVAL on error
 404 */
 405static int vpbe_s_std(struct vpbe_device *vpbe_dev, v4l2_std_id std_id)
 406{
 407        struct vpbe_config *cfg = vpbe_dev->cfg;
 408        int out_index = vpbe_dev->current_out_index;
 409        int sd_index = vpbe_dev->current_sd_index;
 410        int ret;
 411
 412        if (!(cfg->outputs[out_index].output.capabilities &
 413                V4L2_OUT_CAP_STD))
 414                return -ENODATA;
 415
 416        ret = vpbe_get_std_info(vpbe_dev, std_id);
 417        if (ret)
 418                return ret;
 419
 420        mutex_lock(&vpbe_dev->lock);
 421
 422        ret = v4l2_subdev_call(vpbe_dev->encoders[sd_index], video,
 423                               s_std_output, std_id);
 424        /* set the lcd controller output for the given mode */
 425        if (!ret) {
 426                struct osd_state *osd_device = vpbe_dev->osd_device;
 427
 428                osd_device->ops.set_left_margin(osd_device,
 429                vpbe_dev->current_timings.left_margin);
 430                osd_device->ops.set_top_margin(osd_device,
 431                vpbe_dev->current_timings.upper_margin);
 432        }
 433        mutex_unlock(&vpbe_dev->lock);
 434
 435        return ret;
 436}
 437
 438/*
 439 * vpbe_g_std - Get the standard in the current encoder
 440 *
 441 * Get the standard in the current encoder. Return the status. 0 - success
 442 * -EINVAL on error
 443 */
 444static int vpbe_g_std(struct vpbe_device *vpbe_dev, v4l2_std_id *std_id)
 445{
 446        struct vpbe_enc_mode_info *cur_timings = &vpbe_dev->current_timings;
 447        struct vpbe_config *cfg = vpbe_dev->cfg;
 448        int out_index = vpbe_dev->current_out_index;
 449
 450        if (!(cfg->outputs[out_index].output.capabilities & V4L2_OUT_CAP_STD))
 451                return -ENODATA;
 452
 453        if (cur_timings->timings_type & VPBE_ENC_STD) {
 454                *std_id = cur_timings->std_id;
 455                return 0;
 456        }
 457
 458        return -EINVAL;
 459}
 460
 461/*
 462 * vpbe_set_mode - Set mode in the current encoder using mode info
 463 *
 464 * Use the mode string to decide what timings to set in the encoder
 465 * This is typically useful when fbset command is used to change the current
 466 * timings by specifying a string to indicate the timings.
 467 */
 468static int vpbe_set_mode(struct vpbe_device *vpbe_dev,
 469                         struct vpbe_enc_mode_info *mode_info)
 470{
 471        struct vpbe_enc_mode_info *preset_mode = NULL;
 472        struct vpbe_config *cfg = vpbe_dev->cfg;
 473        struct v4l2_dv_timings dv_timings;
 474        struct osd_state *osd_device;
 475        int out_index = vpbe_dev->current_out_index;
 476        int i;
 477
 478        if (!mode_info || !mode_info->name)
 479                return -EINVAL;
 480
 481        for (i = 0; i < cfg->outputs[out_index].num_modes; i++) {
 482                if (!strcmp(mode_info->name,
 483                     cfg->outputs[out_index].modes[i].name)) {
 484                        preset_mode = &cfg->outputs[out_index].modes[i];
 485                        /*
 486                         * it may be one of the 3 timings type. Check and
 487                         * invoke right API
 488                         */
 489                        if (preset_mode->timings_type & VPBE_ENC_STD)
 490                                return vpbe_s_std(vpbe_dev,
 491                                                 preset_mode->std_id);
 492                        if (preset_mode->timings_type &
 493                                                VPBE_ENC_DV_TIMINGS) {
 494                                dv_timings =
 495                                        preset_mode->dv_timings;
 496                                return vpbe_s_dv_timings(vpbe_dev, &dv_timings);
 497                        }
 498                }
 499        }
 500
 501        /* Only custom timing should reach here */
 502        if (!preset_mode)
 503                return -EINVAL;
 504
 505        mutex_lock(&vpbe_dev->lock);
 506
 507        osd_device = vpbe_dev->osd_device;
 508        vpbe_dev->current_timings = *preset_mode;
 509        osd_device->ops.set_left_margin(osd_device,
 510                vpbe_dev->current_timings.left_margin);
 511        osd_device->ops.set_top_margin(osd_device,
 512                vpbe_dev->current_timings.upper_margin);
 513
 514        mutex_unlock(&vpbe_dev->lock);
 515        return 0;
 516}
 517
 518static int vpbe_set_default_mode(struct vpbe_device *vpbe_dev)
 519{
 520        int ret;
 521
 522        ret = vpbe_get_std_info_by_name(vpbe_dev, def_mode);
 523        if (ret)
 524                return ret;
 525
 526        /* set the default mode in the encoder */
 527        return vpbe_set_mode(vpbe_dev, &vpbe_dev->current_timings);
 528}
 529
 530static int platform_device_get(struct device *dev, void *data)
 531{
 532        struct platform_device *pdev = to_platform_device(dev);
 533        struct vpbe_device *vpbe_dev = data;
 534
 535        if (strstr(pdev->name, "vpbe-osd"))
 536                vpbe_dev->osd_device = platform_get_drvdata(pdev);
 537        if (strstr(pdev->name, "vpbe-venc"))
 538                vpbe_dev->venc_device = dev_get_platdata(&pdev->dev);
 539
 540        return 0;
 541}
 542
 543/**
 544 * vpbe_initialize() - Initialize the vpbe display controller
 545 * @dev: Master and slave device ptr
 546 * @vpbe_dev: vpbe device ptr
 547 *
 548 * Master frame buffer device drivers calls this to initialize vpbe
 549 * display controller. This will then registers v4l2 device and the sub
 550 * devices and sets a current encoder sub device for display. v4l2 display
 551 * device driver is the master and frame buffer display device driver is
 552 * the slave. Frame buffer display driver checks the initialized during
 553 * probe and exit if not initialized. Returns status.
 554 */
 555static int vpbe_initialize(struct device *dev, struct vpbe_device *vpbe_dev)
 556{
 557        struct encoder_config_info *enc_info;
 558        struct amp_config_info *amp_info;
 559        struct v4l2_subdev **enc_subdev;
 560        struct osd_state *osd_device;
 561        struct i2c_adapter *i2c_adap;
 562        int num_encoders;
 563        int ret = 0;
 564        int err;
 565        int i;
 566
 567        /*
 568         * v4l2 abd FBDev frame buffer devices will get the vpbe_dev pointer
 569         * from the platform device by iteration of platform drivers and
 570         * matching with device name
 571         */
 572        if (!vpbe_dev || !dev) {
 573                printk(KERN_ERR "Null device pointers.\n");
 574                return -ENODEV;
 575        }
 576
 577        if (vpbe_dev->initialized)
 578                return 0;
 579
 580        mutex_lock(&vpbe_dev->lock);
 581
 582        if (strcmp(vpbe_dev->cfg->module_name, "dm644x-vpbe-display") != 0) {
 583                /* We have dac clock available for platform */
 584                vpbe_dev->dac_clk = clk_get(vpbe_dev->pdev, "vpss_dac");
 585                if (IS_ERR(vpbe_dev->dac_clk)) {
 586                        ret =  PTR_ERR(vpbe_dev->dac_clk);
 587                        goto fail_mutex_unlock;
 588                }
 589                if (clk_prepare_enable(vpbe_dev->dac_clk)) {
 590                        ret =  -ENODEV;
 591                        clk_put(vpbe_dev->dac_clk);
 592                        goto fail_mutex_unlock;
 593                }
 594        }
 595
 596        /* first enable vpss clocks */
 597        vpss_enable_clock(VPSS_VPBE_CLOCK, 1);
 598
 599        /* First register a v4l2 device */
 600        ret = v4l2_device_register(dev, &vpbe_dev->v4l2_dev);
 601        if (ret) {
 602                v4l2_err(dev->driver,
 603                        "Unable to register v4l2 device.\n");
 604                goto fail_clk_put;
 605        }
 606        v4l2_info(&vpbe_dev->v4l2_dev, "vpbe v4l2 device registered\n");
 607
 608        err = bus_for_each_dev(&platform_bus_type, NULL, vpbe_dev,
 609                               platform_device_get);
 610        if (err < 0) {
 611                ret = err;
 612                goto fail_dev_unregister;
 613        }
 614
 615        vpbe_dev->venc = venc_sub_dev_init(&vpbe_dev->v4l2_dev,
 616                                           vpbe_dev->cfg->venc.module_name);
 617        /* register venc sub device */
 618        if (!vpbe_dev->venc) {
 619                v4l2_err(&vpbe_dev->v4l2_dev,
 620                        "vpbe unable to init venc sub device\n");
 621                ret = -ENODEV;
 622                goto fail_dev_unregister;
 623        }
 624        /* initialize osd device */
 625        osd_device = vpbe_dev->osd_device;
 626        if (osd_device->ops.initialize) {
 627                err = osd_device->ops.initialize(osd_device);
 628                if (err) {
 629                        v4l2_err(&vpbe_dev->v4l2_dev,
 630                                 "unable to initialize the OSD device");
 631                        err = -ENOMEM;
 632                        goto fail_dev_unregister;
 633                }
 634        }
 635
 636        /*
 637         * Register any external encoders that are configured. At index 0 we
 638         * store venc sd index.
 639         */
 640        num_encoders = vpbe_dev->cfg->num_ext_encoders + 1;
 641        vpbe_dev->encoders = kmalloc_array(num_encoders,
 642                                           sizeof(*vpbe_dev->encoders),
 643                                           GFP_KERNEL);
 644        if (!vpbe_dev->encoders) {
 645                ret = -ENOMEM;
 646                goto fail_dev_unregister;
 647        }
 648
 649        i2c_adap = i2c_get_adapter(vpbe_dev->cfg->i2c_adapter_id);
 650        for (i = 0; i < (vpbe_dev->cfg->num_ext_encoders + 1); i++) {
 651                if (i == 0) {
 652                        /* venc is at index 0 */
 653                        enc_subdev = &vpbe_dev->encoders[i];
 654                        *enc_subdev = vpbe_dev->venc;
 655                        continue;
 656                }
 657                enc_info = &vpbe_dev->cfg->ext_encoders[i];
 658                if (enc_info->is_i2c) {
 659                        enc_subdev = &vpbe_dev->encoders[i];
 660                        *enc_subdev = v4l2_i2c_new_subdev_board(
 661                                                &vpbe_dev->v4l2_dev, i2c_adap,
 662                                                &enc_info->board_info, NULL);
 663                        if (*enc_subdev)
 664                                v4l2_info(&vpbe_dev->v4l2_dev,
 665                                          "v4l2 sub device %s registered\n",
 666                                          enc_info->module_name);
 667                        else {
 668                                v4l2_err(&vpbe_dev->v4l2_dev, "encoder %s failed to register",
 669                                         enc_info->module_name);
 670                                ret = -ENODEV;
 671                                goto fail_kfree_encoders;
 672                        }
 673                } else
 674                        v4l2_warn(&vpbe_dev->v4l2_dev, "non-i2c encoders currently not supported");
 675        }
 676        /* Add amplifier subdevice for dm365 */
 677        if ((strcmp(vpbe_dev->cfg->module_name, "dm365-vpbe-display") == 0) &&
 678           vpbe_dev->cfg->amp) {
 679                amp_info = vpbe_dev->cfg->amp;
 680                if (amp_info->is_i2c) {
 681                        vpbe_dev->amp = v4l2_i2c_new_subdev_board(
 682                        &vpbe_dev->v4l2_dev, i2c_adap,
 683                        &amp_info->board_info, NULL);
 684                        if (!vpbe_dev->amp) {
 685                                v4l2_err(&vpbe_dev->v4l2_dev,
 686                                         "amplifier %s failed to register",
 687                                         amp_info->module_name);
 688                                ret = -ENODEV;
 689                                goto fail_kfree_encoders;
 690                        }
 691                        v4l2_info(&vpbe_dev->v4l2_dev,
 692                                          "v4l2 sub device %s registered\n",
 693                                          amp_info->module_name);
 694                } else {
 695                            vpbe_dev->amp = NULL;
 696                            v4l2_warn(&vpbe_dev->v4l2_dev, "non-i2c amplifiers currently not supported");
 697                }
 698        } else {
 699            vpbe_dev->amp = NULL;
 700        }
 701
 702        /* set the current encoder and output to that of venc by default */
 703        vpbe_dev->current_sd_index = 0;
 704        vpbe_dev->current_out_index = 0;
 705
 706        mutex_unlock(&vpbe_dev->lock);
 707
 708        printk(KERN_NOTICE "Setting default output to %s\n", def_output);
 709        ret = vpbe_set_default_output(vpbe_dev);
 710        if (ret) {
 711                v4l2_err(&vpbe_dev->v4l2_dev, "Failed to set default output %s",
 712                         def_output);
 713                goto fail_kfree_amp;
 714        }
 715
 716        printk(KERN_NOTICE "Setting default mode to %s\n", def_mode);
 717        ret = vpbe_set_default_mode(vpbe_dev);
 718        if (ret) {
 719                v4l2_err(&vpbe_dev->v4l2_dev, "Failed to set default mode %s",
 720                         def_mode);
 721                goto fail_kfree_amp;
 722        }
 723        vpbe_dev->initialized = 1;
 724        /* TBD handling of bootargs for default output and mode */
 725        return 0;
 726
 727fail_kfree_amp:
 728        mutex_lock(&vpbe_dev->lock);
 729        kfree(vpbe_dev->amp);
 730fail_kfree_encoders:
 731        kfree(vpbe_dev->encoders);
 732fail_dev_unregister:
 733        v4l2_device_unregister(&vpbe_dev->v4l2_dev);
 734fail_clk_put:
 735        if (strcmp(vpbe_dev->cfg->module_name, "dm644x-vpbe-display") != 0) {
 736                clk_disable_unprepare(vpbe_dev->dac_clk);
 737                clk_put(vpbe_dev->dac_clk);
 738        }
 739fail_mutex_unlock:
 740        mutex_unlock(&vpbe_dev->lock);
 741        return ret;
 742}
 743
 744/**
 745 * vpbe_deinitialize() - de-initialize the vpbe display controller
 746 * @dev: Master and slave device ptr
 747 * @vpbe_dev: vpbe device ptr
 748 *
 749 * vpbe_master and slave frame buffer devices calls this to de-initialize
 750 * the display controller. It is called when master and slave device
 751 * driver modules are removed and no longer requires the display controller.
 752 */
 753static void vpbe_deinitialize(struct device *dev, struct vpbe_device *vpbe_dev)
 754{
 755        v4l2_device_unregister(&vpbe_dev->v4l2_dev);
 756        if (strcmp(vpbe_dev->cfg->module_name, "dm644x-vpbe-display") != 0) {
 757                clk_disable_unprepare(vpbe_dev->dac_clk);
 758                clk_put(vpbe_dev->dac_clk);
 759        }
 760
 761        kfree(vpbe_dev->amp);
 762        kfree(vpbe_dev->encoders);
 763        vpbe_dev->initialized = 0;
 764        /* disable vpss clocks */
 765        vpss_enable_clock(VPSS_VPBE_CLOCK, 0);
 766}
 767
 768static const struct vpbe_device_ops vpbe_dev_ops = {
 769        .enum_outputs = vpbe_enum_outputs,
 770        .set_output = vpbe_set_output,
 771        .get_output = vpbe_get_output,
 772        .s_dv_timings = vpbe_s_dv_timings,
 773        .g_dv_timings = vpbe_g_dv_timings,
 774        .enum_dv_timings = vpbe_enum_dv_timings,
 775        .s_std = vpbe_s_std,
 776        .g_std = vpbe_g_std,
 777        .initialize = vpbe_initialize,
 778        .deinitialize = vpbe_deinitialize,
 779        .get_mode_info = vpbe_get_current_mode_info,
 780        .set_mode = vpbe_set_mode,
 781};
 782
 783static int vpbe_probe(struct platform_device *pdev)
 784{
 785        struct vpbe_device *vpbe_dev;
 786        struct vpbe_config *cfg;
 787
 788        if (!pdev->dev.platform_data) {
 789                v4l2_err(pdev->dev.driver, "No platform data\n");
 790                return -ENODEV;
 791        }
 792        cfg = pdev->dev.platform_data;
 793
 794        if (!cfg->module_name[0] ||
 795            !cfg->osd.module_name[0] ||
 796            !cfg->venc.module_name[0]) {
 797                v4l2_err(pdev->dev.driver, "vpbe display module names not defined\n");
 798                return -EINVAL;
 799        }
 800
 801        vpbe_dev = kzalloc(sizeof(*vpbe_dev), GFP_KERNEL);
 802        if (!vpbe_dev)
 803                return -ENOMEM;
 804
 805        vpbe_dev->cfg = cfg;
 806        vpbe_dev->ops = vpbe_dev_ops;
 807        vpbe_dev->pdev = &pdev->dev;
 808
 809        if (cfg->outputs->num_modes > 0)
 810                vpbe_dev->current_timings = vpbe_dev->cfg->outputs[0].modes[0];
 811        else {
 812                kfree(vpbe_dev);
 813                return -ENODEV;
 814        }
 815
 816        /* set the driver data in platform device */
 817        platform_set_drvdata(pdev, vpbe_dev);
 818        mutex_init(&vpbe_dev->lock);
 819
 820        return 0;
 821}
 822
 823static int vpbe_remove(struct platform_device *device)
 824{
 825        struct vpbe_device *vpbe_dev = platform_get_drvdata(device);
 826
 827        kfree(vpbe_dev);
 828
 829        return 0;
 830}
 831
 832static struct platform_driver vpbe_driver = {
 833        .driver = {
 834                .name   = "vpbe_controller",
 835        },
 836        .probe = vpbe_probe,
 837        .remove = vpbe_remove,
 838};
 839
 840module_platform_driver(vpbe_driver);
 841