linux/drivers/media/platform/davinci/vpfe_capture.c
<<
>>
Prefs
   1/*
   2 * Copyright (C) 2008-2009 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; either version 2 of the License, or
   7 * (at your option) any later version.
   8 *
   9 * This program is distributed in the hope that it will be useful,
  10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 * GNU General Public License for more details.
  13 *
  14 * Driver name : VPFE Capture driver
  15 *    VPFE Capture driver allows applications to capture and stream video
  16 *    frames on DaVinci SoCs (DM6446, DM355 etc) from a YUV source such as
  17 *    TVP5146 or  Raw Bayer RGB image data from an image sensor
  18 *    such as Microns' MT9T001, MT9T031 etc.
  19 *
  20 *    These SoCs have, in common, a Video Processing Subsystem (VPSS) that
  21 *    consists of a Video Processing Front End (VPFE) for capturing
  22 *    video/raw image data and Video Processing Back End (VPBE) for displaying
  23 *    YUV data through an in-built analog encoder or Digital LCD port. This
  24 *    driver is for capture through VPFE. A typical EVM using these SoCs have
  25 *    following high level configuration.
  26 *
  27 *
  28 *    decoder(TVP5146/          YUV/
  29 *           MT9T001)   -->  Raw Bayer RGB ---> MUX -> VPFE (CCDC/ISIF)
  30 *                              data input              |      |
  31 *                                                      V      |
  32 *                                                    SDRAM    |
  33 *                                                             V
  34 *                                                         Image Processor
  35 *                                                             |
  36 *                                                             V
  37 *                                                           SDRAM
  38 *    The data flow happens from a decoder connected to the VPFE over a
  39 *    YUV embedded (BT.656/BT.1120) or separate sync or raw bayer rgb interface
  40 *    and to the input of VPFE through an optional MUX (if more inputs are
  41 *    to be interfaced on the EVM). The input data is first passed through
  42 *    CCDC (CCD Controller, a.k.a Image Sensor Interface, ISIF). The CCDC
  43 *    does very little or no processing on YUV data and does pre-process Raw
  44 *    Bayer RGB data through modules such as Defect Pixel Correction (DFC)
  45 *    Color Space Conversion (CSC), data gain/offset etc. After this, data
  46 *    can be written to SDRAM or can be connected to the image processing
  47 *    block such as IPIPE (on DM355 only).
  48 *
  49 *    Features supported
  50 *              - MMAP IO
  51 *              - Capture using TVP5146 over BT.656
  52 *              - support for interfacing decoders using sub device model
  53 *              - Work with DM355 or DM6446 CCDC to do Raw Bayer RGB/YUV
  54 *                data capture to SDRAM.
  55 *    TODO list
  56 *              - Support multiple REQBUF after open
  57 *              - Support for de-allocating buffers through REQBUF
  58 *              - Support for Raw Bayer RGB capture
  59 *              - Support for chaining Image Processor
  60 *              - Support for static allocation of buffers
  61 *              - Support for USERPTR IO
  62 *              - Support for STREAMON before QBUF
  63 *              - Support for control ioctls
  64 */
  65#include <linux/module.h>
  66#include <linux/slab.h>
  67#include <linux/init.h>
  68#include <linux/platform_device.h>
  69#include <linux/interrupt.h>
  70#include <media/v4l2-common.h>
  71#include <linux/io.h>
  72#include <media/davinci/vpfe_capture.h>
  73#include "ccdc_hw_device.h"
  74
  75static int debug;
  76static u32 numbuffers = 3;
  77static u32 bufsize = (720 * 576 * 2);
  78
  79module_param(numbuffers, uint, S_IRUGO);
  80module_param(bufsize, uint, S_IRUGO);
  81module_param(debug, int, 0644);
  82
  83MODULE_PARM_DESC(numbuffers, "buffer count (default:3)");
  84MODULE_PARM_DESC(bufsize, "buffer size in bytes (default:720 x 576 x 2)");
  85MODULE_PARM_DESC(debug, "Debug level 0-1");
  86
  87MODULE_DESCRIPTION("VPFE Video for Linux Capture Driver");
  88MODULE_LICENSE("GPL");
  89MODULE_AUTHOR("Texas Instruments");
  90
  91/* standard information */
  92struct vpfe_standard {
  93        v4l2_std_id std_id;
  94        unsigned int width;
  95        unsigned int height;
  96        struct v4l2_fract pixelaspect;
  97        /* 0 - progressive, 1 - interlaced */
  98        int frame_format;
  99};
 100
 101/* ccdc configuration */
 102struct ccdc_config {
 103        /* This make sure vpfe is probed and ready to go */
 104        int vpfe_probed;
 105        /* name of ccdc device */
 106        char name[32];
 107};
 108
 109/* data structures */
 110static struct vpfe_config_params config_params = {
 111        .min_numbuffers = 3,
 112        .numbuffers = 3,
 113        .min_bufsize = 720 * 480 * 2,
 114        .device_bufsize = 720 * 576 * 2,
 115};
 116
 117/* ccdc device registered */
 118static const struct ccdc_hw_device *ccdc_dev;
 119/* lock for accessing ccdc information */
 120static DEFINE_MUTEX(ccdc_lock);
 121/* ccdc configuration */
 122static struct ccdc_config *ccdc_cfg;
 123
 124static const struct vpfe_standard vpfe_standards[] = {
 125        {V4L2_STD_525_60, 720, 480, {11, 10}, 1},
 126        {V4L2_STD_625_50, 720, 576, {54, 59}, 1},
 127};
 128
 129/* Used when raw Bayer image from ccdc is directly captured to SDRAM */
 130static const struct vpfe_pixel_format vpfe_pix_fmts[] = {
 131        {
 132                .fmtdesc = {
 133                        .index = 0,
 134                        .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
 135                        .description = "Bayer GrRBGb 8bit A-Law compr.",
 136                        .pixelformat = V4L2_PIX_FMT_SBGGR8,
 137                },
 138                .bpp = 1,
 139        },
 140        {
 141                .fmtdesc = {
 142                        .index = 1,
 143                        .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
 144                        .description = "Bayer GrRBGb - 16bit",
 145                        .pixelformat = V4L2_PIX_FMT_SBGGR16,
 146                },
 147                .bpp = 2,
 148        },
 149        {
 150                .fmtdesc = {
 151                        .index = 2,
 152                        .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
 153                        .description = "Bayer GrRBGb 8bit DPCM compr.",
 154                        .pixelformat = V4L2_PIX_FMT_SGRBG10DPCM8,
 155                },
 156                .bpp = 1,
 157        },
 158        {
 159                .fmtdesc = {
 160                        .index = 3,
 161                        .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
 162                        .description = "YCbCr 4:2:2 Interleaved UYVY",
 163                        .pixelformat = V4L2_PIX_FMT_UYVY,
 164                },
 165                .bpp = 2,
 166        },
 167        {
 168                .fmtdesc = {
 169                        .index = 4,
 170                        .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
 171                        .description = "YCbCr 4:2:2 Interleaved YUYV",
 172                        .pixelformat = V4L2_PIX_FMT_YUYV,
 173                },
 174                .bpp = 2,
 175        },
 176        {
 177                .fmtdesc = {
 178                        .index = 5,
 179                        .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
 180                        .description = "Y/CbCr 4:2:0 - Semi planar",
 181                        .pixelformat = V4L2_PIX_FMT_NV12,
 182                },
 183                .bpp = 1,
 184        },
 185};
 186
 187/*
 188 * vpfe_lookup_pix_format()
 189 * lookup an entry in the vpfe pix format table based on pix_format
 190 */
 191static const struct vpfe_pixel_format *vpfe_lookup_pix_format(u32 pix_format)
 192{
 193        int i;
 194
 195        for (i = 0; i < ARRAY_SIZE(vpfe_pix_fmts); i++) {
 196                if (pix_format == vpfe_pix_fmts[i].fmtdesc.pixelformat)
 197                        return &vpfe_pix_fmts[i];
 198        }
 199        return NULL;
 200}
 201
 202/*
 203 * vpfe_register_ccdc_device. CCDC module calls this to
 204 * register with vpfe capture
 205 */
 206int vpfe_register_ccdc_device(const struct ccdc_hw_device *dev)
 207{
 208        int ret = 0;
 209        printk(KERN_NOTICE "vpfe_register_ccdc_device: %s\n", dev->name);
 210
 211        BUG_ON(!dev->hw_ops.open);
 212        BUG_ON(!dev->hw_ops.enable);
 213        BUG_ON(!dev->hw_ops.set_hw_if_params);
 214        BUG_ON(!dev->hw_ops.configure);
 215        BUG_ON(!dev->hw_ops.set_buftype);
 216        BUG_ON(!dev->hw_ops.get_buftype);
 217        BUG_ON(!dev->hw_ops.enum_pix);
 218        BUG_ON(!dev->hw_ops.set_frame_format);
 219        BUG_ON(!dev->hw_ops.get_frame_format);
 220        BUG_ON(!dev->hw_ops.get_pixel_format);
 221        BUG_ON(!dev->hw_ops.set_pixel_format);
 222        BUG_ON(!dev->hw_ops.set_image_window);
 223        BUG_ON(!dev->hw_ops.get_image_window);
 224        BUG_ON(!dev->hw_ops.get_line_length);
 225        BUG_ON(!dev->hw_ops.getfid);
 226
 227        mutex_lock(&ccdc_lock);
 228        if (!ccdc_cfg) {
 229                /*
 230                 * TODO. Will this ever happen? if so, we need to fix it.
 231                 * Proabably we need to add the request to a linked list and
 232                 * walk through it during vpfe probe
 233                 */
 234                printk(KERN_ERR "vpfe capture not initialized\n");
 235                ret = -EFAULT;
 236                goto unlock;
 237        }
 238
 239        if (strcmp(dev->name, ccdc_cfg->name)) {
 240                /* ignore this ccdc */
 241                ret = -EINVAL;
 242                goto unlock;
 243        }
 244
 245        if (ccdc_dev) {
 246                printk(KERN_ERR "ccdc already registered\n");
 247                ret = -EINVAL;
 248                goto unlock;
 249        }
 250
 251        ccdc_dev = dev;
 252unlock:
 253        mutex_unlock(&ccdc_lock);
 254        return ret;
 255}
 256EXPORT_SYMBOL(vpfe_register_ccdc_device);
 257
 258/*
 259 * vpfe_unregister_ccdc_device. CCDC module calls this to
 260 * unregister with vpfe capture
 261 */
 262void vpfe_unregister_ccdc_device(const struct ccdc_hw_device *dev)
 263{
 264        if (!dev) {
 265                printk(KERN_ERR "invalid ccdc device ptr\n");
 266                return;
 267        }
 268
 269        printk(KERN_NOTICE "vpfe_unregister_ccdc_device, dev->name = %s\n",
 270                dev->name);
 271
 272        if (strcmp(dev->name, ccdc_cfg->name)) {
 273                /* ignore this ccdc */
 274                return;
 275        }
 276
 277        mutex_lock(&ccdc_lock);
 278        ccdc_dev = NULL;
 279        mutex_unlock(&ccdc_lock);
 280}
 281EXPORT_SYMBOL(vpfe_unregister_ccdc_device);
 282
 283/*
 284 * vpfe_config_ccdc_image_format()
 285 * For a pix format, configure ccdc to setup the capture
 286 */
 287static int vpfe_config_ccdc_image_format(struct vpfe_device *vpfe_dev)
 288{
 289        enum ccdc_frmfmt frm_fmt = CCDC_FRMFMT_INTERLACED;
 290        int ret = 0;
 291
 292        if (ccdc_dev->hw_ops.set_pixel_format(
 293                        vpfe_dev->fmt.fmt.pix.pixelformat) < 0) {
 294                v4l2_err(&vpfe_dev->v4l2_dev,
 295                        "couldn't set pix format in ccdc\n");
 296                return -EINVAL;
 297        }
 298        /* configure the image window */
 299        ccdc_dev->hw_ops.set_image_window(&vpfe_dev->crop);
 300
 301        switch (vpfe_dev->fmt.fmt.pix.field) {
 302        case V4L2_FIELD_INTERLACED:
 303                /* do nothing, since it is default */
 304                ret = ccdc_dev->hw_ops.set_buftype(
 305                                CCDC_BUFTYPE_FLD_INTERLEAVED);
 306                break;
 307        case V4L2_FIELD_NONE:
 308                frm_fmt = CCDC_FRMFMT_PROGRESSIVE;
 309                /* buffer type only applicable for interlaced scan */
 310                break;
 311        case V4L2_FIELD_SEQ_TB:
 312                ret = ccdc_dev->hw_ops.set_buftype(
 313                                CCDC_BUFTYPE_FLD_SEPARATED);
 314                break;
 315        default:
 316                return -EINVAL;
 317        }
 318
 319        /* set the frame format */
 320        if (!ret)
 321                ret = ccdc_dev->hw_ops.set_frame_format(frm_fmt);
 322        return ret;
 323}
 324/*
 325 * vpfe_config_image_format()
 326 * For a given standard, this functions sets up the default
 327 * pix format & crop values in the vpfe device and ccdc.  It first
 328 * starts with defaults based values from the standard table.
 329 * It then checks if sub device supports get_fmt and then override the
 330 * values based on that.Sets crop values to match with scan resolution
 331 * starting at 0,0. It calls vpfe_config_ccdc_image_format() set the
 332 * values in ccdc
 333 */
 334static int vpfe_config_image_format(struct vpfe_device *vpfe_dev,
 335                                    v4l2_std_id std_id)
 336{
 337        struct vpfe_subdev_info *sdinfo = vpfe_dev->current_subdev;
 338        struct v4l2_subdev_format fmt = {
 339                .which = V4L2_SUBDEV_FORMAT_ACTIVE,
 340        };
 341        struct v4l2_mbus_framefmt *mbus_fmt = &fmt.format;
 342        struct v4l2_pix_format *pix = &vpfe_dev->fmt.fmt.pix;
 343        int i, ret;
 344
 345        for (i = 0; i < ARRAY_SIZE(vpfe_standards); i++) {
 346                if (vpfe_standards[i].std_id & std_id) {
 347                        vpfe_dev->std_info.active_pixels =
 348                                        vpfe_standards[i].width;
 349                        vpfe_dev->std_info.active_lines =
 350                                        vpfe_standards[i].height;
 351                        vpfe_dev->std_info.frame_format =
 352                                        vpfe_standards[i].frame_format;
 353                        vpfe_dev->std_index = i;
 354                        break;
 355                }
 356        }
 357
 358        if (i ==  ARRAY_SIZE(vpfe_standards)) {
 359                v4l2_err(&vpfe_dev->v4l2_dev, "standard not supported\n");
 360                return -EINVAL;
 361        }
 362
 363        vpfe_dev->crop.top = 0;
 364        vpfe_dev->crop.left = 0;
 365        vpfe_dev->crop.width = vpfe_dev->std_info.active_pixels;
 366        vpfe_dev->crop.height = vpfe_dev->std_info.active_lines;
 367        pix->width = vpfe_dev->crop.width;
 368        pix->height = vpfe_dev->crop.height;
 369
 370        /* first field and frame format based on standard frame format */
 371        if (vpfe_dev->std_info.frame_format) {
 372                pix->field = V4L2_FIELD_INTERLACED;
 373                /* assume V4L2_PIX_FMT_UYVY as default */
 374                pix->pixelformat = V4L2_PIX_FMT_UYVY;
 375                v4l2_fill_mbus_format(mbus_fmt, pix,
 376                                MEDIA_BUS_FMT_YUYV10_2X10);
 377        } else {
 378                pix->field = V4L2_FIELD_NONE;
 379                /* assume V4L2_PIX_FMT_SBGGR8 */
 380                pix->pixelformat = V4L2_PIX_FMT_SBGGR8;
 381                v4l2_fill_mbus_format(mbus_fmt, pix,
 382                                MEDIA_BUS_FMT_SBGGR8_1X8);
 383        }
 384
 385        /* if sub device supports get_fmt, override the defaults */
 386        ret = v4l2_device_call_until_err(&vpfe_dev->v4l2_dev,
 387                        sdinfo->grp_id, pad, get_fmt, NULL, &fmt);
 388
 389        if (ret && ret != -ENOIOCTLCMD) {
 390                v4l2_err(&vpfe_dev->v4l2_dev,
 391                        "error in getting get_fmt from sub device\n");
 392                return ret;
 393        }
 394        v4l2_fill_pix_format(pix, mbus_fmt);
 395        pix->bytesperline = pix->width * 2;
 396        pix->sizeimage = pix->bytesperline * pix->height;
 397
 398        /* Sets the values in CCDC */
 399        ret = vpfe_config_ccdc_image_format(vpfe_dev);
 400        if (ret)
 401                return ret;
 402
 403        /* Update the values of sizeimage and bytesperline */
 404        pix->bytesperline = ccdc_dev->hw_ops.get_line_length();
 405        pix->sizeimage = pix->bytesperline * pix->height;
 406
 407        return 0;
 408}
 409
 410static int vpfe_initialize_device(struct vpfe_device *vpfe_dev)
 411{
 412        int ret;
 413
 414        /* set first input of current subdevice as the current input */
 415        vpfe_dev->current_input = 0;
 416
 417        /* set default standard */
 418        vpfe_dev->std_index = 0;
 419
 420        /* Configure the default format information */
 421        ret = vpfe_config_image_format(vpfe_dev,
 422                                vpfe_standards[vpfe_dev->std_index].std_id);
 423        if (ret)
 424                return ret;
 425
 426        /* now open the ccdc device to initialize it */
 427        mutex_lock(&ccdc_lock);
 428        if (!ccdc_dev) {
 429                v4l2_err(&vpfe_dev->v4l2_dev, "ccdc device not registered\n");
 430                ret = -ENODEV;
 431                goto unlock;
 432        }
 433
 434        if (!try_module_get(ccdc_dev->owner)) {
 435                v4l2_err(&vpfe_dev->v4l2_dev, "Couldn't lock ccdc module\n");
 436                ret = -ENODEV;
 437                goto unlock;
 438        }
 439        ret = ccdc_dev->hw_ops.open(vpfe_dev->pdev);
 440        if (!ret)
 441                vpfe_dev->initialized = 1;
 442
 443        /* Clear all VPFE/CCDC interrupts */
 444        if (vpfe_dev->cfg->clr_intr)
 445                vpfe_dev->cfg->clr_intr(-1);
 446
 447unlock:
 448        mutex_unlock(&ccdc_lock);
 449        return ret;
 450}
 451
 452/*
 453 * vpfe_open : It creates object of file handle structure and
 454 * stores it in private_data  member of filepointer
 455 */
 456static int vpfe_open(struct file *file)
 457{
 458        struct vpfe_device *vpfe_dev = video_drvdata(file);
 459        struct video_device *vdev = video_devdata(file);
 460        struct vpfe_fh *fh;
 461
 462        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_open\n");
 463
 464        if (!vpfe_dev->cfg->num_subdevs) {
 465                v4l2_err(&vpfe_dev->v4l2_dev, "No decoder registered\n");
 466                return -ENODEV;
 467        }
 468
 469        /* Allocate memory for the file handle object */
 470        fh = kmalloc(sizeof(*fh), GFP_KERNEL);
 471        if (!fh)
 472                return -ENOMEM;
 473
 474        /* store pointer to fh in private_data member of file */
 475        file->private_data = fh;
 476        fh->vpfe_dev = vpfe_dev;
 477        v4l2_fh_init(&fh->fh, vdev);
 478        mutex_lock(&vpfe_dev->lock);
 479        /* If decoder is not initialized. initialize it */
 480        if (!vpfe_dev->initialized) {
 481                if (vpfe_initialize_device(vpfe_dev)) {
 482                        mutex_unlock(&vpfe_dev->lock);
 483                        v4l2_fh_exit(&fh->fh);
 484                        kfree(fh);
 485                        return -ENODEV;
 486                }
 487        }
 488        /* Increment device usrs counter */
 489        vpfe_dev->usrs++;
 490        /* Set io_allowed member to false */
 491        fh->io_allowed = 0;
 492        v4l2_fh_add(&fh->fh);
 493        mutex_unlock(&vpfe_dev->lock);
 494        return 0;
 495}
 496
 497static void vpfe_schedule_next_buffer(struct vpfe_device *vpfe_dev)
 498{
 499        unsigned long addr;
 500
 501        vpfe_dev->next_frm = list_entry(vpfe_dev->dma_queue.next,
 502                                        struct videobuf_buffer, queue);
 503        list_del(&vpfe_dev->next_frm->queue);
 504        vpfe_dev->next_frm->state = VIDEOBUF_ACTIVE;
 505        addr = videobuf_to_dma_contig(vpfe_dev->next_frm);
 506
 507        ccdc_dev->hw_ops.setfbaddr(addr);
 508}
 509
 510static void vpfe_schedule_bottom_field(struct vpfe_device *vpfe_dev)
 511{
 512        unsigned long addr;
 513
 514        addr = videobuf_to_dma_contig(vpfe_dev->cur_frm);
 515        addr += vpfe_dev->field_off;
 516        ccdc_dev->hw_ops.setfbaddr(addr);
 517}
 518
 519static void vpfe_process_buffer_complete(struct vpfe_device *vpfe_dev)
 520{
 521        v4l2_get_timestamp(&vpfe_dev->cur_frm->ts);
 522        vpfe_dev->cur_frm->state = VIDEOBUF_DONE;
 523        vpfe_dev->cur_frm->size = vpfe_dev->fmt.fmt.pix.sizeimage;
 524        wake_up_interruptible(&vpfe_dev->cur_frm->done);
 525        vpfe_dev->cur_frm = vpfe_dev->next_frm;
 526}
 527
 528/* ISR for VINT0*/
 529static irqreturn_t vpfe_isr(int irq, void *dev_id)
 530{
 531        struct vpfe_device *vpfe_dev = dev_id;
 532        enum v4l2_field field;
 533        int fid;
 534
 535        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "\nStarting vpfe_isr...\n");
 536        field = vpfe_dev->fmt.fmt.pix.field;
 537
 538        /* if streaming not started, don't do anything */
 539        if (!vpfe_dev->started)
 540                goto clear_intr;
 541
 542        /* only for 6446 this will be applicable */
 543        if (ccdc_dev->hw_ops.reset)
 544                ccdc_dev->hw_ops.reset();
 545
 546        if (field == V4L2_FIELD_NONE) {
 547                /* handle progressive frame capture */
 548                v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev,
 549                        "frame format is progressive...\n");
 550                if (vpfe_dev->cur_frm != vpfe_dev->next_frm)
 551                        vpfe_process_buffer_complete(vpfe_dev);
 552                goto clear_intr;
 553        }
 554
 555        /* interlaced or TB capture check which field we are in hardware */
 556        fid = ccdc_dev->hw_ops.getfid();
 557
 558        /* switch the software maintained field id */
 559        vpfe_dev->field_id ^= 1;
 560        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "field id = %x:%x.\n",
 561                fid, vpfe_dev->field_id);
 562        if (fid == vpfe_dev->field_id) {
 563                /* we are in-sync here,continue */
 564                if (fid == 0) {
 565                        /*
 566                         * One frame is just being captured. If the next frame
 567                         * is available, release the current frame and move on
 568                         */
 569                        if (vpfe_dev->cur_frm != vpfe_dev->next_frm)
 570                                vpfe_process_buffer_complete(vpfe_dev);
 571                        /*
 572                         * based on whether the two fields are stored
 573                         * interleavely or separately in memory, reconfigure
 574                         * the CCDC memory address
 575                         */
 576                        if (field == V4L2_FIELD_SEQ_TB)
 577                                vpfe_schedule_bottom_field(vpfe_dev);
 578                        goto clear_intr;
 579                }
 580                /*
 581                 * if one field is just being captured configure
 582                 * the next frame get the next frame from the empty
 583                 * queue if no frame is available hold on to the
 584                 * current buffer
 585                 */
 586                spin_lock(&vpfe_dev->dma_queue_lock);
 587                if (!list_empty(&vpfe_dev->dma_queue) &&
 588                    vpfe_dev->cur_frm == vpfe_dev->next_frm)
 589                        vpfe_schedule_next_buffer(vpfe_dev);
 590                spin_unlock(&vpfe_dev->dma_queue_lock);
 591        } else if (fid == 0) {
 592                /*
 593                 * out of sync. Recover from any hardware out-of-sync.
 594                 * May loose one frame
 595                 */
 596                vpfe_dev->field_id = fid;
 597        }
 598clear_intr:
 599        if (vpfe_dev->cfg->clr_intr)
 600                vpfe_dev->cfg->clr_intr(irq);
 601
 602        return IRQ_HANDLED;
 603}
 604
 605/* vdint1_isr - isr handler for VINT1 interrupt */
 606static irqreturn_t vdint1_isr(int irq, void *dev_id)
 607{
 608        struct vpfe_device *vpfe_dev = dev_id;
 609
 610        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "\nInside vdint1_isr...\n");
 611
 612        /* if streaming not started, don't do anything */
 613        if (!vpfe_dev->started) {
 614                if (vpfe_dev->cfg->clr_intr)
 615                        vpfe_dev->cfg->clr_intr(irq);
 616                return IRQ_HANDLED;
 617        }
 618
 619        spin_lock(&vpfe_dev->dma_queue_lock);
 620        if ((vpfe_dev->fmt.fmt.pix.field == V4L2_FIELD_NONE) &&
 621            !list_empty(&vpfe_dev->dma_queue) &&
 622            vpfe_dev->cur_frm == vpfe_dev->next_frm)
 623                vpfe_schedule_next_buffer(vpfe_dev);
 624        spin_unlock(&vpfe_dev->dma_queue_lock);
 625
 626        if (vpfe_dev->cfg->clr_intr)
 627                vpfe_dev->cfg->clr_intr(irq);
 628
 629        return IRQ_HANDLED;
 630}
 631
 632static void vpfe_detach_irq(struct vpfe_device *vpfe_dev)
 633{
 634        enum ccdc_frmfmt frame_format;
 635
 636        frame_format = ccdc_dev->hw_ops.get_frame_format();
 637        if (frame_format == CCDC_FRMFMT_PROGRESSIVE)
 638                free_irq(vpfe_dev->ccdc_irq1, vpfe_dev);
 639}
 640
 641static int vpfe_attach_irq(struct vpfe_device *vpfe_dev)
 642{
 643        enum ccdc_frmfmt frame_format;
 644
 645        frame_format = ccdc_dev->hw_ops.get_frame_format();
 646        if (frame_format == CCDC_FRMFMT_PROGRESSIVE) {
 647                return request_irq(vpfe_dev->ccdc_irq1, vdint1_isr,
 648                                    0, "vpfe_capture1",
 649                                    vpfe_dev);
 650        }
 651        return 0;
 652}
 653
 654/* vpfe_stop_ccdc_capture: stop streaming in ccdc/isif */
 655static void vpfe_stop_ccdc_capture(struct vpfe_device *vpfe_dev)
 656{
 657        vpfe_dev->started = 0;
 658        ccdc_dev->hw_ops.enable(0);
 659        if (ccdc_dev->hw_ops.enable_out_to_sdram)
 660                ccdc_dev->hw_ops.enable_out_to_sdram(0);
 661}
 662
 663/*
 664 * vpfe_release : This function deletes buffer queue, frees the
 665 * buffers and the vpfe file  handle
 666 */
 667static int vpfe_release(struct file *file)
 668{
 669        struct vpfe_device *vpfe_dev = video_drvdata(file);
 670        struct vpfe_fh *fh = file->private_data;
 671        struct vpfe_subdev_info *sdinfo;
 672        int ret;
 673
 674        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_release\n");
 675
 676        /* Get the device lock */
 677        mutex_lock(&vpfe_dev->lock);
 678        /* if this instance is doing IO */
 679        if (fh->io_allowed) {
 680                if (vpfe_dev->started) {
 681                        sdinfo = vpfe_dev->current_subdev;
 682                        ret = v4l2_device_call_until_err(&vpfe_dev->v4l2_dev,
 683                                                         sdinfo->grp_id,
 684                                                         video, s_stream, 0);
 685                        if (ret && (ret != -ENOIOCTLCMD))
 686                                v4l2_err(&vpfe_dev->v4l2_dev,
 687                                "stream off failed in subdev\n");
 688                        vpfe_stop_ccdc_capture(vpfe_dev);
 689                        vpfe_detach_irq(vpfe_dev);
 690                        videobuf_streamoff(&vpfe_dev->buffer_queue);
 691                }
 692                vpfe_dev->io_usrs = 0;
 693                vpfe_dev->numbuffers = config_params.numbuffers;
 694                videobuf_stop(&vpfe_dev->buffer_queue);
 695                videobuf_mmap_free(&vpfe_dev->buffer_queue);
 696        }
 697
 698        /* Decrement device usrs counter */
 699        vpfe_dev->usrs--;
 700        v4l2_fh_del(&fh->fh);
 701        v4l2_fh_exit(&fh->fh);
 702        /* If this is the last file handle */
 703        if (!vpfe_dev->usrs) {
 704                vpfe_dev->initialized = 0;
 705                if (ccdc_dev->hw_ops.close)
 706                        ccdc_dev->hw_ops.close(vpfe_dev->pdev);
 707                module_put(ccdc_dev->owner);
 708        }
 709        mutex_unlock(&vpfe_dev->lock);
 710        file->private_data = NULL;
 711        /* Free memory allocated to file handle object */
 712        kfree(fh);
 713        return 0;
 714}
 715
 716/*
 717 * vpfe_mmap : It is used to map kernel space buffers
 718 * into user spaces
 719 */
 720static int vpfe_mmap(struct file *file, struct vm_area_struct *vma)
 721{
 722        /* Get the device object and file handle object */
 723        struct vpfe_device *vpfe_dev = video_drvdata(file);
 724
 725        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_mmap\n");
 726
 727        return videobuf_mmap_mapper(&vpfe_dev->buffer_queue, vma);
 728}
 729
 730/*
 731 * vpfe_poll: It is used for select/poll system call
 732 */
 733static __poll_t vpfe_poll(struct file *file, poll_table *wait)
 734{
 735        struct vpfe_device *vpfe_dev = video_drvdata(file);
 736
 737        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_poll\n");
 738
 739        if (vpfe_dev->started)
 740                return videobuf_poll_stream(file,
 741                                            &vpfe_dev->buffer_queue, wait);
 742        return 0;
 743}
 744
 745/* vpfe capture driver file operations */
 746static const struct v4l2_file_operations vpfe_fops = {
 747        .owner = THIS_MODULE,
 748        .open = vpfe_open,
 749        .release = vpfe_release,
 750        .unlocked_ioctl = video_ioctl2,
 751        .mmap = vpfe_mmap,
 752        .poll = vpfe_poll
 753};
 754
 755/*
 756 * vpfe_check_format()
 757 * This function adjust the input pixel format as per hardware
 758 * capabilities and update the same in pixfmt.
 759 * Following algorithm used :-
 760 *
 761 *      If given pixformat is not in the vpfe list of pix formats or not
 762 *      supported by the hardware, current value of pixformat in the device
 763 *      is used
 764 *      If given field is not supported, then current field is used. If field
 765 *      is different from current, then it is matched with that from sub device.
 766 *      Minimum height is 2 lines for interlaced or tb field and 1 line for
 767 *      progressive. Maximum height is clamped to active active lines of scan
 768 *      Minimum width is 32 bytes in memory and width is clamped to active
 769 *      pixels of scan.
 770 *      bytesperline is a multiple of 32.
 771 */
 772static const struct vpfe_pixel_format *
 773        vpfe_check_format(struct vpfe_device *vpfe_dev,
 774                          struct v4l2_pix_format *pixfmt)
 775{
 776        u32 min_height = 1, min_width = 32, max_width, max_height;
 777        const struct vpfe_pixel_format *vpfe_pix_fmt;
 778        u32 pix;
 779        int temp, found;
 780
 781        vpfe_pix_fmt = vpfe_lookup_pix_format(pixfmt->pixelformat);
 782        if (!vpfe_pix_fmt) {
 783                /*
 784                 * use current pixel format in the vpfe device. We
 785                 * will find this pix format in the table
 786                 */
 787                pixfmt->pixelformat = vpfe_dev->fmt.fmt.pix.pixelformat;
 788                vpfe_pix_fmt = vpfe_lookup_pix_format(pixfmt->pixelformat);
 789        }
 790
 791        /* check if hw supports it */
 792        temp = 0;
 793        found = 0;
 794        while (ccdc_dev->hw_ops.enum_pix(&pix, temp) >= 0) {
 795                if (vpfe_pix_fmt->fmtdesc.pixelformat == pix) {
 796                        found = 1;
 797                        break;
 798                }
 799                temp++;
 800        }
 801
 802        if (!found) {
 803                /* use current pixel format */
 804                pixfmt->pixelformat = vpfe_dev->fmt.fmt.pix.pixelformat;
 805                /*
 806                 * Since this is currently used in the vpfe device, we
 807                 * will find this pix format in the table
 808                 */
 809                vpfe_pix_fmt = vpfe_lookup_pix_format(pixfmt->pixelformat);
 810        }
 811
 812        /* check what field format is supported */
 813        if (pixfmt->field == V4L2_FIELD_ANY) {
 814                /* if field is any, use current value as default */
 815                pixfmt->field = vpfe_dev->fmt.fmt.pix.field;
 816        }
 817
 818        /*
 819         * if field is not same as current field in the vpfe device
 820         * try matching the field with the sub device field
 821         */
 822        if (vpfe_dev->fmt.fmt.pix.field != pixfmt->field) {
 823                /*
 824                 * If field value is not in the supported fields, use current
 825                 * field used in the device as default
 826                 */
 827                switch (pixfmt->field) {
 828                case V4L2_FIELD_INTERLACED:
 829                case V4L2_FIELD_SEQ_TB:
 830                        /* if sub device is supporting progressive, use that */
 831                        if (!vpfe_dev->std_info.frame_format)
 832                                pixfmt->field = V4L2_FIELD_NONE;
 833                        break;
 834                case V4L2_FIELD_NONE:
 835                        if (vpfe_dev->std_info.frame_format)
 836                                pixfmt->field = V4L2_FIELD_INTERLACED;
 837                        break;
 838
 839                default:
 840                        /* use current field as default */
 841                        pixfmt->field = vpfe_dev->fmt.fmt.pix.field;
 842                        break;
 843                }
 844        }
 845
 846        /* Now adjust image resolutions supported */
 847        if (pixfmt->field == V4L2_FIELD_INTERLACED ||
 848            pixfmt->field == V4L2_FIELD_SEQ_TB)
 849                min_height = 2;
 850
 851        max_width = vpfe_dev->std_info.active_pixels;
 852        max_height = vpfe_dev->std_info.active_lines;
 853        min_width /= vpfe_pix_fmt->bpp;
 854
 855        v4l2_info(&vpfe_dev->v4l2_dev, "width = %d, height = %d, bpp = %d\n",
 856                  pixfmt->width, pixfmt->height, vpfe_pix_fmt->bpp);
 857
 858        pixfmt->width = clamp((pixfmt->width), min_width, max_width);
 859        pixfmt->height = clamp((pixfmt->height), min_height, max_height);
 860
 861        /* If interlaced, adjust height to be a multiple of 2 */
 862        if (pixfmt->field == V4L2_FIELD_INTERLACED)
 863                pixfmt->height &= (~1);
 864        /*
 865         * recalculate bytesperline and sizeimage since width
 866         * and height might have changed
 867         */
 868        pixfmt->bytesperline = (((pixfmt->width * vpfe_pix_fmt->bpp) + 31)
 869                                & ~31);
 870        if (pixfmt->pixelformat == V4L2_PIX_FMT_NV12)
 871                pixfmt->sizeimage =
 872                        pixfmt->bytesperline * pixfmt->height +
 873                        ((pixfmt->bytesperline * pixfmt->height) >> 1);
 874        else
 875                pixfmt->sizeimage = pixfmt->bytesperline * pixfmt->height;
 876
 877        v4l2_info(&vpfe_dev->v4l2_dev, "adjusted width = %d, height = %d, bpp = %d, bytesperline = %d, sizeimage = %d\n",
 878                 pixfmt->width, pixfmt->height, vpfe_pix_fmt->bpp,
 879                 pixfmt->bytesperline, pixfmt->sizeimage);
 880        return vpfe_pix_fmt;
 881}
 882
 883static int vpfe_querycap(struct file *file, void  *priv,
 884                               struct v4l2_capability *cap)
 885{
 886        struct vpfe_device *vpfe_dev = video_drvdata(file);
 887
 888        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_querycap\n");
 889
 890        cap->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
 891        cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
 892        strscpy(cap->driver, CAPTURE_DRV_NAME, sizeof(cap->driver));
 893        strscpy(cap->bus_info, "VPFE", sizeof(cap->bus_info));
 894        strscpy(cap->card, vpfe_dev->cfg->card_name, sizeof(cap->card));
 895        return 0;
 896}
 897
 898static int vpfe_g_fmt_vid_cap(struct file *file, void *priv,
 899                                struct v4l2_format *fmt)
 900{
 901        struct vpfe_device *vpfe_dev = video_drvdata(file);
 902
 903        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_g_fmt_vid_cap\n");
 904        /* Fill in the information about format */
 905        *fmt = vpfe_dev->fmt;
 906        return 0;
 907}
 908
 909static int vpfe_enum_fmt_vid_cap(struct file *file, void  *priv,
 910                                   struct v4l2_fmtdesc *fmt)
 911{
 912        struct vpfe_device *vpfe_dev = video_drvdata(file);
 913        const struct vpfe_pixel_format *pix_fmt;
 914        int temp_index;
 915        u32 pix;
 916
 917        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_enum_fmt_vid_cap\n");
 918
 919        if (ccdc_dev->hw_ops.enum_pix(&pix, fmt->index) < 0)
 920                return -EINVAL;
 921
 922        /* Fill in the information about format */
 923        pix_fmt = vpfe_lookup_pix_format(pix);
 924        if (pix_fmt) {
 925                temp_index = fmt->index;
 926                *fmt = pix_fmt->fmtdesc;
 927                fmt->index = temp_index;
 928                return 0;
 929        }
 930        return -EINVAL;
 931}
 932
 933static int vpfe_s_fmt_vid_cap(struct file *file, void *priv,
 934                                struct v4l2_format *fmt)
 935{
 936        struct vpfe_device *vpfe_dev = video_drvdata(file);
 937        const struct vpfe_pixel_format *pix_fmts;
 938        int ret;
 939
 940        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_s_fmt_vid_cap\n");
 941
 942        /* If streaming is started, return error */
 943        if (vpfe_dev->started) {
 944                v4l2_err(&vpfe_dev->v4l2_dev, "Streaming is started\n");
 945                return -EBUSY;
 946        }
 947
 948        /* Check for valid frame format */
 949        pix_fmts = vpfe_check_format(vpfe_dev, &fmt->fmt.pix);
 950        if (!pix_fmts)
 951                return -EINVAL;
 952
 953        /* store the pixel format in the device  object */
 954        ret = mutex_lock_interruptible(&vpfe_dev->lock);
 955        if (ret)
 956                return ret;
 957
 958        /* First detach any IRQ if currently attached */
 959        vpfe_detach_irq(vpfe_dev);
 960        vpfe_dev->fmt = *fmt;
 961        /* set image capture parameters in the ccdc */
 962        ret = vpfe_config_ccdc_image_format(vpfe_dev);
 963        mutex_unlock(&vpfe_dev->lock);
 964        return ret;
 965}
 966
 967static int vpfe_try_fmt_vid_cap(struct file *file, void *priv,
 968                                  struct v4l2_format *f)
 969{
 970        struct vpfe_device *vpfe_dev = video_drvdata(file);
 971        const struct vpfe_pixel_format *pix_fmts;
 972
 973        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_try_fmt_vid_cap\n");
 974
 975        pix_fmts = vpfe_check_format(vpfe_dev, &f->fmt.pix);
 976        if (!pix_fmts)
 977                return -EINVAL;
 978        return 0;
 979}
 980
 981/*
 982 * vpfe_get_subdev_input_index - Get subdev index and subdev input index for a
 983 * given app input index
 984 */
 985static int vpfe_get_subdev_input_index(struct vpfe_device *vpfe_dev,
 986                                        int *subdev_index,
 987                                        int *subdev_input_index,
 988                                        int app_input_index)
 989{
 990        struct vpfe_config *cfg = vpfe_dev->cfg;
 991        struct vpfe_subdev_info *sdinfo;
 992        int i, j = 0;
 993
 994        for (i = 0; i < cfg->num_subdevs; i++) {
 995                sdinfo = &cfg->sub_devs[i];
 996                if (app_input_index < (j + sdinfo->num_inputs)) {
 997                        *subdev_index = i;
 998                        *subdev_input_index = app_input_index - j;
 999                        return 0;
1000                }
1001                j += sdinfo->num_inputs;
1002        }
1003        return -EINVAL;
1004}
1005
1006/*
1007 * vpfe_get_app_input - Get app input index for a given subdev input index
1008 * driver stores the input index of the current sub device and translate it
1009 * when application request the current input
1010 */
1011static int vpfe_get_app_input_index(struct vpfe_device *vpfe_dev,
1012                                    int *app_input_index)
1013{
1014        struct vpfe_config *cfg = vpfe_dev->cfg;
1015        struct vpfe_subdev_info *sdinfo;
1016        int i, j = 0;
1017
1018        for (i = 0; i < cfg->num_subdevs; i++) {
1019                sdinfo = &cfg->sub_devs[i];
1020                if (!strcmp(sdinfo->name, vpfe_dev->current_subdev->name)) {
1021                        if (vpfe_dev->current_input >= sdinfo->num_inputs)
1022                                return -1;
1023                        *app_input_index = j + vpfe_dev->current_input;
1024                        return 0;
1025                }
1026                j += sdinfo->num_inputs;
1027        }
1028        return -EINVAL;
1029}
1030
1031static int vpfe_enum_input(struct file *file, void *priv,
1032                                 struct v4l2_input *inp)
1033{
1034        struct vpfe_device *vpfe_dev = video_drvdata(file);
1035        struct vpfe_subdev_info *sdinfo;
1036        int subdev, index ;
1037
1038        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_enum_input\n");
1039
1040        if (vpfe_get_subdev_input_index(vpfe_dev,
1041                                        &subdev,
1042                                        &index,
1043                                        inp->index) < 0) {
1044                v4l2_err(&vpfe_dev->v4l2_dev, "input information not found for the subdev\n");
1045                return -EINVAL;
1046        }
1047        sdinfo = &vpfe_dev->cfg->sub_devs[subdev];
1048        *inp = sdinfo->inputs[index];
1049        return 0;
1050}
1051
1052static int vpfe_g_input(struct file *file, void *priv, unsigned int *index)
1053{
1054        struct vpfe_device *vpfe_dev = video_drvdata(file);
1055
1056        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_g_input\n");
1057
1058        return vpfe_get_app_input_index(vpfe_dev, index);
1059}
1060
1061
1062static int vpfe_s_input(struct file *file, void *priv, unsigned int index)
1063{
1064        struct vpfe_device *vpfe_dev = video_drvdata(file);
1065        struct v4l2_subdev *sd;
1066        struct vpfe_subdev_info *sdinfo;
1067        int subdev_index, inp_index;
1068        struct vpfe_route *route;
1069        u32 input, output;
1070        int ret;
1071
1072        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_s_input\n");
1073
1074        ret = mutex_lock_interruptible(&vpfe_dev->lock);
1075        if (ret)
1076                return ret;
1077
1078        /*
1079         * If streaming is started return device busy
1080         * error
1081         */
1082        if (vpfe_dev->started) {
1083                v4l2_err(&vpfe_dev->v4l2_dev, "Streaming is on\n");
1084                ret = -EBUSY;
1085                goto unlock_out;
1086        }
1087        ret = vpfe_get_subdev_input_index(vpfe_dev,
1088                                          &subdev_index,
1089                                          &inp_index,
1090                                          index);
1091        if (ret < 0) {
1092                v4l2_err(&vpfe_dev->v4l2_dev, "invalid input index\n");
1093                goto unlock_out;
1094        }
1095
1096        sdinfo = &vpfe_dev->cfg->sub_devs[subdev_index];
1097        sd = vpfe_dev->sd[subdev_index];
1098        route = &sdinfo->routes[inp_index];
1099        if (route && sdinfo->can_route) {
1100                input = route->input;
1101                output = route->output;
1102        } else {
1103                input = 0;
1104                output = 0;
1105        }
1106
1107        if (sd)
1108                ret = v4l2_subdev_call(sd, video, s_routing, input, output, 0);
1109
1110        if (ret) {
1111                v4l2_err(&vpfe_dev->v4l2_dev,
1112                        "vpfe_doioctl:error in setting input in decoder\n");
1113                ret = -EINVAL;
1114                goto unlock_out;
1115        }
1116        vpfe_dev->current_subdev = sdinfo;
1117        if (sd)
1118                vpfe_dev->v4l2_dev.ctrl_handler = sd->ctrl_handler;
1119        vpfe_dev->current_input = index;
1120        vpfe_dev->std_index = 0;
1121
1122        /* set the bus/interface parameter for the sub device in ccdc */
1123        ret = ccdc_dev->hw_ops.set_hw_if_params(&sdinfo->ccdc_if_params);
1124        if (ret)
1125                goto unlock_out;
1126
1127        /* set the default image parameters in the device */
1128        ret = vpfe_config_image_format(vpfe_dev,
1129                                vpfe_standards[vpfe_dev->std_index].std_id);
1130unlock_out:
1131        mutex_unlock(&vpfe_dev->lock);
1132        return ret;
1133}
1134
1135static int vpfe_querystd(struct file *file, void *priv, v4l2_std_id *std_id)
1136{
1137        struct vpfe_device *vpfe_dev = video_drvdata(file);
1138        struct vpfe_subdev_info *sdinfo;
1139        int ret;
1140
1141        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_querystd\n");
1142
1143        ret = mutex_lock_interruptible(&vpfe_dev->lock);
1144        sdinfo = vpfe_dev->current_subdev;
1145        if (ret)
1146                return ret;
1147        /* Call querystd function of decoder device */
1148        ret = v4l2_device_call_until_err(&vpfe_dev->v4l2_dev, sdinfo->grp_id,
1149                                         video, querystd, std_id);
1150        mutex_unlock(&vpfe_dev->lock);
1151        return ret;
1152}
1153
1154static int vpfe_s_std(struct file *file, void *priv, v4l2_std_id std_id)
1155{
1156        struct vpfe_device *vpfe_dev = video_drvdata(file);
1157        struct vpfe_subdev_info *sdinfo;
1158        int ret;
1159
1160        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_s_std\n");
1161
1162        /* Call decoder driver function to set the standard */
1163        ret = mutex_lock_interruptible(&vpfe_dev->lock);
1164        if (ret)
1165                return ret;
1166
1167        sdinfo = vpfe_dev->current_subdev;
1168        /* If streaming is started, return device busy error */
1169        if (vpfe_dev->started) {
1170                v4l2_err(&vpfe_dev->v4l2_dev, "streaming is started\n");
1171                ret = -EBUSY;
1172                goto unlock_out;
1173        }
1174
1175        ret = v4l2_device_call_until_err(&vpfe_dev->v4l2_dev, sdinfo->grp_id,
1176                                         video, s_std, std_id);
1177        if (ret < 0) {
1178                v4l2_err(&vpfe_dev->v4l2_dev, "Failed to set standard\n");
1179                goto unlock_out;
1180        }
1181        ret = vpfe_config_image_format(vpfe_dev, std_id);
1182
1183unlock_out:
1184        mutex_unlock(&vpfe_dev->lock);
1185        return ret;
1186}
1187
1188static int vpfe_g_std(struct file *file, void *priv, v4l2_std_id *std_id)
1189{
1190        struct vpfe_device *vpfe_dev = video_drvdata(file);
1191
1192        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_g_std\n");
1193
1194        *std_id = vpfe_standards[vpfe_dev->std_index].std_id;
1195        return 0;
1196}
1197/*
1198 *  Videobuf operations
1199 */
1200static int vpfe_videobuf_setup(struct videobuf_queue *vq,
1201                                unsigned int *count,
1202                                unsigned int *size)
1203{
1204        struct vpfe_fh *fh = vq->priv_data;
1205        struct vpfe_device *vpfe_dev = fh->vpfe_dev;
1206
1207        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_buffer_setup\n");
1208        *size = vpfe_dev->fmt.fmt.pix.sizeimage;
1209        if (vpfe_dev->memory == V4L2_MEMORY_MMAP &&
1210                vpfe_dev->fmt.fmt.pix.sizeimage > config_params.device_bufsize)
1211                *size = config_params.device_bufsize;
1212
1213        if (*count < config_params.min_numbuffers)
1214                *count = config_params.min_numbuffers;
1215        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev,
1216                "count=%d, size=%d\n", *count, *size);
1217        return 0;
1218}
1219
1220static int vpfe_videobuf_prepare(struct videobuf_queue *vq,
1221                                struct videobuf_buffer *vb,
1222                                enum v4l2_field field)
1223{
1224        struct vpfe_fh *fh = vq->priv_data;
1225        struct vpfe_device *vpfe_dev = fh->vpfe_dev;
1226        unsigned long addr;
1227        int ret;
1228
1229        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_buffer_prepare\n");
1230
1231        /* If buffer is not initialized, initialize it */
1232        if (VIDEOBUF_NEEDS_INIT == vb->state) {
1233                vb->width = vpfe_dev->fmt.fmt.pix.width;
1234                vb->height = vpfe_dev->fmt.fmt.pix.height;
1235                vb->size = vpfe_dev->fmt.fmt.pix.sizeimage;
1236                vb->field = field;
1237
1238                ret = videobuf_iolock(vq, vb, NULL);
1239                if (ret < 0)
1240                        return ret;
1241
1242                addr = videobuf_to_dma_contig(vb);
1243                /* Make sure user addresses are aligned to 32 bytes */
1244                if (!ALIGN(addr, 32))
1245                        return -EINVAL;
1246
1247                vb->state = VIDEOBUF_PREPARED;
1248        }
1249        return 0;
1250}
1251
1252static void vpfe_videobuf_queue(struct videobuf_queue *vq,
1253                                struct videobuf_buffer *vb)
1254{
1255        /* Get the file handle object and device object */
1256        struct vpfe_fh *fh = vq->priv_data;
1257        struct vpfe_device *vpfe_dev = fh->vpfe_dev;
1258        unsigned long flags;
1259
1260        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_buffer_queue\n");
1261
1262        /* add the buffer to the DMA queue */
1263        spin_lock_irqsave(&vpfe_dev->dma_queue_lock, flags);
1264        list_add_tail(&vb->queue, &vpfe_dev->dma_queue);
1265        spin_unlock_irqrestore(&vpfe_dev->dma_queue_lock, flags);
1266
1267        /* Change state of the buffer */
1268        vb->state = VIDEOBUF_QUEUED;
1269}
1270
1271static void vpfe_videobuf_release(struct videobuf_queue *vq,
1272                                  struct videobuf_buffer *vb)
1273{
1274        struct vpfe_fh *fh = vq->priv_data;
1275        struct vpfe_device *vpfe_dev = fh->vpfe_dev;
1276        unsigned long flags;
1277
1278        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_videobuf_release\n");
1279
1280        /*
1281         * We need to flush the buffer from the dma queue since
1282         * they are de-allocated
1283         */
1284        spin_lock_irqsave(&vpfe_dev->dma_queue_lock, flags);
1285        INIT_LIST_HEAD(&vpfe_dev->dma_queue);
1286        spin_unlock_irqrestore(&vpfe_dev->dma_queue_lock, flags);
1287        videobuf_dma_contig_free(vq, vb);
1288        vb->state = VIDEOBUF_NEEDS_INIT;
1289}
1290
1291static const struct videobuf_queue_ops vpfe_videobuf_qops = {
1292        .buf_setup      = vpfe_videobuf_setup,
1293        .buf_prepare    = vpfe_videobuf_prepare,
1294        .buf_queue      = vpfe_videobuf_queue,
1295        .buf_release    = vpfe_videobuf_release,
1296};
1297
1298/*
1299 * vpfe_reqbufs. currently support REQBUF only once opening
1300 * the device.
1301 */
1302static int vpfe_reqbufs(struct file *file, void *priv,
1303                        struct v4l2_requestbuffers *req_buf)
1304{
1305        struct vpfe_device *vpfe_dev = video_drvdata(file);
1306        struct vpfe_fh *fh = file->private_data;
1307        int ret;
1308
1309        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_reqbufs\n");
1310
1311        if (V4L2_BUF_TYPE_VIDEO_CAPTURE != req_buf->type) {
1312                v4l2_err(&vpfe_dev->v4l2_dev, "Invalid buffer type\n");
1313                return -EINVAL;
1314        }
1315
1316        ret = mutex_lock_interruptible(&vpfe_dev->lock);
1317        if (ret)
1318                return ret;
1319
1320        if (vpfe_dev->io_usrs != 0) {
1321                v4l2_err(&vpfe_dev->v4l2_dev, "Only one IO user allowed\n");
1322                ret = -EBUSY;
1323                goto unlock_out;
1324        }
1325
1326        vpfe_dev->memory = req_buf->memory;
1327        videobuf_queue_dma_contig_init(&vpfe_dev->buffer_queue,
1328                                &vpfe_videobuf_qops,
1329                                vpfe_dev->pdev,
1330                                &vpfe_dev->irqlock,
1331                                req_buf->type,
1332                                vpfe_dev->fmt.fmt.pix.field,
1333                                sizeof(struct videobuf_buffer),
1334                                fh, NULL);
1335
1336        fh->io_allowed = 1;
1337        vpfe_dev->io_usrs = 1;
1338        INIT_LIST_HEAD(&vpfe_dev->dma_queue);
1339        ret = videobuf_reqbufs(&vpfe_dev->buffer_queue, req_buf);
1340unlock_out:
1341        mutex_unlock(&vpfe_dev->lock);
1342        return ret;
1343}
1344
1345static int vpfe_querybuf(struct file *file, void *priv,
1346                         struct v4l2_buffer *buf)
1347{
1348        struct vpfe_device *vpfe_dev = video_drvdata(file);
1349
1350        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_querybuf\n");
1351
1352        if (V4L2_BUF_TYPE_VIDEO_CAPTURE != buf->type) {
1353                v4l2_err(&vpfe_dev->v4l2_dev, "Invalid buf type\n");
1354                return  -EINVAL;
1355        }
1356
1357        if (vpfe_dev->memory != V4L2_MEMORY_MMAP) {
1358                v4l2_err(&vpfe_dev->v4l2_dev, "Invalid memory\n");
1359                return -EINVAL;
1360        }
1361        /* Call videobuf_querybuf to get information */
1362        return videobuf_querybuf(&vpfe_dev->buffer_queue, buf);
1363}
1364
1365static int vpfe_qbuf(struct file *file, void *priv,
1366                     struct v4l2_buffer *p)
1367{
1368        struct vpfe_device *vpfe_dev = video_drvdata(file);
1369        struct vpfe_fh *fh = file->private_data;
1370
1371        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_qbuf\n");
1372
1373        if (V4L2_BUF_TYPE_VIDEO_CAPTURE != p->type) {
1374                v4l2_err(&vpfe_dev->v4l2_dev, "Invalid buf type\n");
1375                return -EINVAL;
1376        }
1377
1378        /*
1379         * If this file handle is not allowed to do IO,
1380         * return error
1381         */
1382        if (!fh->io_allowed) {
1383                v4l2_err(&vpfe_dev->v4l2_dev, "fh->io_allowed\n");
1384                return -EACCES;
1385        }
1386        return videobuf_qbuf(&vpfe_dev->buffer_queue, p);
1387}
1388
1389static int vpfe_dqbuf(struct file *file, void *priv,
1390                      struct v4l2_buffer *buf)
1391{
1392        struct vpfe_device *vpfe_dev = video_drvdata(file);
1393
1394        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_dqbuf\n");
1395
1396        if (V4L2_BUF_TYPE_VIDEO_CAPTURE != buf->type) {
1397                v4l2_err(&vpfe_dev->v4l2_dev, "Invalid buf type\n");
1398                return -EINVAL;
1399        }
1400        return videobuf_dqbuf(&vpfe_dev->buffer_queue,
1401                                      buf, file->f_flags & O_NONBLOCK);
1402}
1403
1404/*
1405 * vpfe_calculate_offsets : This function calculates buffers offset
1406 * for top and bottom field
1407 */
1408static void vpfe_calculate_offsets(struct vpfe_device *vpfe_dev)
1409{
1410        struct v4l2_rect image_win;
1411
1412        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_calculate_offsets\n");
1413
1414        ccdc_dev->hw_ops.get_image_window(&image_win);
1415        vpfe_dev->field_off = image_win.height * image_win.width;
1416}
1417
1418/* vpfe_start_ccdc_capture: start streaming in ccdc/isif */
1419static void vpfe_start_ccdc_capture(struct vpfe_device *vpfe_dev)
1420{
1421        ccdc_dev->hw_ops.enable(1);
1422        if (ccdc_dev->hw_ops.enable_out_to_sdram)
1423                ccdc_dev->hw_ops.enable_out_to_sdram(1);
1424        vpfe_dev->started = 1;
1425}
1426
1427/*
1428 * vpfe_streamon. Assume the DMA queue is not empty.
1429 * application is expected to call QBUF before calling
1430 * this ioctl. If not, driver returns error
1431 */
1432static int vpfe_streamon(struct file *file, void *priv,
1433                         enum v4l2_buf_type buf_type)
1434{
1435        struct vpfe_device *vpfe_dev = video_drvdata(file);
1436        struct vpfe_fh *fh = file->private_data;
1437        struct vpfe_subdev_info *sdinfo;
1438        unsigned long addr;
1439        int ret;
1440
1441        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_streamon\n");
1442
1443        if (V4L2_BUF_TYPE_VIDEO_CAPTURE != buf_type) {
1444                v4l2_err(&vpfe_dev->v4l2_dev, "Invalid buf type\n");
1445                return -EINVAL;
1446        }
1447
1448        /* If file handle is not allowed IO, return error */
1449        if (!fh->io_allowed) {
1450                v4l2_err(&vpfe_dev->v4l2_dev, "fh->io_allowed\n");
1451                return -EACCES;
1452        }
1453
1454        sdinfo = vpfe_dev->current_subdev;
1455        ret = v4l2_device_call_until_err(&vpfe_dev->v4l2_dev, sdinfo->grp_id,
1456                                        video, s_stream, 1);
1457
1458        if (ret && (ret != -ENOIOCTLCMD)) {
1459                v4l2_err(&vpfe_dev->v4l2_dev, "stream on failed in subdev\n");
1460                return -EINVAL;
1461        }
1462
1463        /* If buffer queue is empty, return error */
1464        if (list_empty(&vpfe_dev->buffer_queue.stream)) {
1465                v4l2_err(&vpfe_dev->v4l2_dev, "buffer queue is empty\n");
1466                return -EIO;
1467        }
1468
1469        /* Call videobuf_streamon to start streaming * in videobuf */
1470        ret = videobuf_streamon(&vpfe_dev->buffer_queue);
1471        if (ret)
1472                return ret;
1473
1474
1475        ret = mutex_lock_interruptible(&vpfe_dev->lock);
1476        if (ret)
1477                goto streamoff;
1478        /* Get the next frame from the buffer queue */
1479        vpfe_dev->next_frm = list_entry(vpfe_dev->dma_queue.next,
1480                                        struct videobuf_buffer, queue);
1481        vpfe_dev->cur_frm = vpfe_dev->next_frm;
1482        /* Remove buffer from the buffer queue */
1483        list_del(&vpfe_dev->cur_frm->queue);
1484        /* Mark state of the current frame to active */
1485        vpfe_dev->cur_frm->state = VIDEOBUF_ACTIVE;
1486        /* Initialize field_id and started member */
1487        vpfe_dev->field_id = 0;
1488        addr = videobuf_to_dma_contig(vpfe_dev->cur_frm);
1489
1490        /* Calculate field offset */
1491        vpfe_calculate_offsets(vpfe_dev);
1492
1493        if (vpfe_attach_irq(vpfe_dev) < 0) {
1494                v4l2_err(&vpfe_dev->v4l2_dev,
1495                         "Error in attaching interrupt handle\n");
1496                ret = -EFAULT;
1497                goto unlock_out;
1498        }
1499        if (ccdc_dev->hw_ops.configure() < 0) {
1500                v4l2_err(&vpfe_dev->v4l2_dev,
1501                         "Error in configuring ccdc\n");
1502                ret = -EINVAL;
1503                goto unlock_out;
1504        }
1505        ccdc_dev->hw_ops.setfbaddr((unsigned long)(addr));
1506        vpfe_start_ccdc_capture(vpfe_dev);
1507        mutex_unlock(&vpfe_dev->lock);
1508        return ret;
1509unlock_out:
1510        mutex_unlock(&vpfe_dev->lock);
1511streamoff:
1512        videobuf_streamoff(&vpfe_dev->buffer_queue);
1513        return ret;
1514}
1515
1516static int vpfe_streamoff(struct file *file, void *priv,
1517                          enum v4l2_buf_type buf_type)
1518{
1519        struct vpfe_device *vpfe_dev = video_drvdata(file);
1520        struct vpfe_fh *fh = file->private_data;
1521        struct vpfe_subdev_info *sdinfo;
1522        int ret;
1523
1524        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_streamoff\n");
1525
1526        if (V4L2_BUF_TYPE_VIDEO_CAPTURE != buf_type) {
1527                v4l2_err(&vpfe_dev->v4l2_dev, "Invalid buf type\n");
1528                return -EINVAL;
1529        }
1530
1531        /* If io is allowed for this file handle, return error */
1532        if (!fh->io_allowed) {
1533                v4l2_err(&vpfe_dev->v4l2_dev, "fh->io_allowed\n");
1534                return -EACCES;
1535        }
1536
1537        /* If streaming is not started, return error */
1538        if (!vpfe_dev->started) {
1539                v4l2_err(&vpfe_dev->v4l2_dev, "device started\n");
1540                return -EINVAL;
1541        }
1542
1543        ret = mutex_lock_interruptible(&vpfe_dev->lock);
1544        if (ret)
1545                return ret;
1546
1547        vpfe_stop_ccdc_capture(vpfe_dev);
1548        vpfe_detach_irq(vpfe_dev);
1549
1550        sdinfo = vpfe_dev->current_subdev;
1551        ret = v4l2_device_call_until_err(&vpfe_dev->v4l2_dev, sdinfo->grp_id,
1552                                        video, s_stream, 0);
1553
1554        if (ret && (ret != -ENOIOCTLCMD))
1555                v4l2_err(&vpfe_dev->v4l2_dev, "stream off failed in subdev\n");
1556        ret = videobuf_streamoff(&vpfe_dev->buffer_queue);
1557        mutex_unlock(&vpfe_dev->lock);
1558        return ret;
1559}
1560
1561static int vpfe_cropcap(struct file *file, void *priv,
1562                              struct v4l2_cropcap *crop)
1563{
1564        struct vpfe_device *vpfe_dev = video_drvdata(file);
1565
1566        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_cropcap\n");
1567
1568        if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1569                return -EINVAL;
1570        /* If std_index is invalid, then just return (== 1:1 aspect) */
1571        if (vpfe_dev->std_index >= ARRAY_SIZE(vpfe_standards))
1572                return 0;
1573
1574        crop->pixelaspect = vpfe_standards[vpfe_dev->std_index].pixelaspect;
1575        return 0;
1576}
1577
1578static int vpfe_g_selection(struct file *file, void *priv,
1579                            struct v4l2_selection *sel)
1580{
1581        struct vpfe_device *vpfe_dev = video_drvdata(file);
1582
1583        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_g_selection\n");
1584
1585        if (sel->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1586                return -EINVAL;
1587
1588        switch (sel->target) {
1589        case V4L2_SEL_TGT_CROP:
1590                sel->r = vpfe_dev->crop;
1591                break;
1592        case V4L2_SEL_TGT_CROP_DEFAULT:
1593        case V4L2_SEL_TGT_CROP_BOUNDS:
1594                sel->r.width = vpfe_standards[vpfe_dev->std_index].width;
1595                sel->r.height = vpfe_standards[vpfe_dev->std_index].height;
1596                break;
1597        default:
1598                return -EINVAL;
1599        }
1600        return 0;
1601}
1602
1603static int vpfe_s_selection(struct file *file, void *priv,
1604                            struct v4l2_selection *sel)
1605{
1606        struct vpfe_device *vpfe_dev = video_drvdata(file);
1607        struct v4l2_rect rect = sel->r;
1608        int ret;
1609
1610        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_s_selection\n");
1611
1612        if (sel->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
1613            sel->target != V4L2_SEL_TGT_CROP)
1614                return -EINVAL;
1615
1616        if (vpfe_dev->started) {
1617                /* make sure streaming is not started */
1618                v4l2_err(&vpfe_dev->v4l2_dev,
1619                        "Cannot change crop when streaming is ON\n");
1620                return -EBUSY;
1621        }
1622
1623        ret = mutex_lock_interruptible(&vpfe_dev->lock);
1624        if (ret)
1625                return ret;
1626
1627        if (rect.top < 0 || rect.left < 0) {
1628                v4l2_err(&vpfe_dev->v4l2_dev,
1629                        "doesn't support negative values for top & left\n");
1630                ret = -EINVAL;
1631                goto unlock_out;
1632        }
1633
1634        /* adjust the width to 16 pixel boundary */
1635        rect.width = ((rect.width + 15) & ~0xf);
1636
1637        /* make sure parameters are valid */
1638        if ((rect.left + rect.width >
1639                vpfe_dev->std_info.active_pixels) ||
1640            (rect.top + rect.height >
1641                vpfe_dev->std_info.active_lines)) {
1642                v4l2_err(&vpfe_dev->v4l2_dev, "Error in S_SELECTION params\n");
1643                ret = -EINVAL;
1644                goto unlock_out;
1645        }
1646        ccdc_dev->hw_ops.set_image_window(&rect);
1647        vpfe_dev->fmt.fmt.pix.width = rect.width;
1648        vpfe_dev->fmt.fmt.pix.height = rect.height;
1649        vpfe_dev->fmt.fmt.pix.bytesperline =
1650                ccdc_dev->hw_ops.get_line_length();
1651        vpfe_dev->fmt.fmt.pix.sizeimage =
1652                vpfe_dev->fmt.fmt.pix.bytesperline *
1653                vpfe_dev->fmt.fmt.pix.height;
1654        vpfe_dev->crop = rect;
1655        sel->r = rect;
1656unlock_out:
1657        mutex_unlock(&vpfe_dev->lock);
1658        return ret;
1659}
1660
1661/* vpfe capture ioctl operations */
1662static const struct v4l2_ioctl_ops vpfe_ioctl_ops = {
1663        .vidioc_querycap         = vpfe_querycap,
1664        .vidioc_g_fmt_vid_cap    = vpfe_g_fmt_vid_cap,
1665        .vidioc_enum_fmt_vid_cap = vpfe_enum_fmt_vid_cap,
1666        .vidioc_s_fmt_vid_cap    = vpfe_s_fmt_vid_cap,
1667        .vidioc_try_fmt_vid_cap  = vpfe_try_fmt_vid_cap,
1668        .vidioc_enum_input       = vpfe_enum_input,
1669        .vidioc_g_input          = vpfe_g_input,
1670        .vidioc_s_input          = vpfe_s_input,
1671        .vidioc_querystd         = vpfe_querystd,
1672        .vidioc_s_std            = vpfe_s_std,
1673        .vidioc_g_std            = vpfe_g_std,
1674        .vidioc_reqbufs          = vpfe_reqbufs,
1675        .vidioc_querybuf         = vpfe_querybuf,
1676        .vidioc_qbuf             = vpfe_qbuf,
1677        .vidioc_dqbuf            = vpfe_dqbuf,
1678        .vidioc_streamon         = vpfe_streamon,
1679        .vidioc_streamoff        = vpfe_streamoff,
1680        .vidioc_cropcap          = vpfe_cropcap,
1681        .vidioc_g_selection      = vpfe_g_selection,
1682        .vidioc_s_selection      = vpfe_s_selection,
1683};
1684
1685static struct vpfe_device *vpfe_initialize(void)
1686{
1687        struct vpfe_device *vpfe_dev;
1688
1689        /* Default number of buffers should be 3 */
1690        if ((numbuffers > 0) &&
1691            (numbuffers < config_params.min_numbuffers))
1692                numbuffers = config_params.min_numbuffers;
1693
1694        /*
1695         * Set buffer size to min buffers size if invalid buffer size is
1696         * given
1697         */
1698        if (bufsize < config_params.min_bufsize)
1699                bufsize = config_params.min_bufsize;
1700
1701        config_params.numbuffers = numbuffers;
1702
1703        if (numbuffers)
1704                config_params.device_bufsize = bufsize;
1705
1706        /* Allocate memory for device objects */
1707        vpfe_dev = kzalloc(sizeof(*vpfe_dev), GFP_KERNEL);
1708
1709        return vpfe_dev;
1710}
1711
1712/*
1713 * vpfe_probe : This function creates device entries by register
1714 * itself to the V4L2 driver and initializes fields of each
1715 * device objects
1716 */
1717static int vpfe_probe(struct platform_device *pdev)
1718{
1719        struct vpfe_subdev_info *sdinfo;
1720        struct vpfe_config *vpfe_cfg;
1721        struct resource *res1;
1722        struct vpfe_device *vpfe_dev;
1723        struct i2c_adapter *i2c_adap;
1724        struct video_device *vfd;
1725        int ret, i, j;
1726        int num_subdevs = 0;
1727
1728        /* Get the pointer to the device object */
1729        vpfe_dev = vpfe_initialize();
1730
1731        if (!vpfe_dev) {
1732                v4l2_err(pdev->dev.driver,
1733                        "Failed to allocate memory for vpfe_dev\n");
1734                return -ENOMEM;
1735        }
1736
1737        vpfe_dev->pdev = &pdev->dev;
1738
1739        if (!pdev->dev.platform_data) {
1740                v4l2_err(pdev->dev.driver, "Unable to get vpfe config\n");
1741                ret = -ENODEV;
1742                goto probe_free_dev_mem;
1743        }
1744
1745        vpfe_cfg = pdev->dev.platform_data;
1746        vpfe_dev->cfg = vpfe_cfg;
1747        if (!vpfe_cfg->ccdc || !vpfe_cfg->card_name || !vpfe_cfg->sub_devs) {
1748                v4l2_err(pdev->dev.driver, "null ptr in vpfe_cfg\n");
1749                ret = -ENOENT;
1750                goto probe_free_dev_mem;
1751        }
1752
1753        /* Allocate memory for ccdc configuration */
1754        ccdc_cfg = kmalloc(sizeof(*ccdc_cfg), GFP_KERNEL);
1755        if (!ccdc_cfg) {
1756                ret = -ENOMEM;
1757                goto probe_free_dev_mem;
1758        }
1759
1760        mutex_lock(&ccdc_lock);
1761
1762        strncpy(ccdc_cfg->name, vpfe_cfg->ccdc, 32);
1763        /* Get VINT0 irq resource */
1764        res1 = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
1765        if (!res1) {
1766                v4l2_err(pdev->dev.driver,
1767                         "Unable to get interrupt for VINT0\n");
1768                ret = -ENODEV;
1769                goto probe_free_ccdc_cfg_mem;
1770        }
1771        vpfe_dev->ccdc_irq0 = res1->start;
1772
1773        /* Get VINT1 irq resource */
1774        res1 = platform_get_resource(pdev, IORESOURCE_IRQ, 1);
1775        if (!res1) {
1776                v4l2_err(pdev->dev.driver,
1777                         "Unable to get interrupt for VINT1\n");
1778                ret = -ENODEV;
1779                goto probe_free_ccdc_cfg_mem;
1780        }
1781        vpfe_dev->ccdc_irq1 = res1->start;
1782
1783        ret = request_irq(vpfe_dev->ccdc_irq0, vpfe_isr, 0,
1784                          "vpfe_capture0", vpfe_dev);
1785
1786        if (0 != ret) {
1787                v4l2_err(pdev->dev.driver, "Unable to request interrupt\n");
1788                goto probe_free_ccdc_cfg_mem;
1789        }
1790
1791        vfd = &vpfe_dev->video_dev;
1792        /* Initialize field of video device */
1793        vfd->release            = video_device_release_empty;
1794        vfd->fops               = &vpfe_fops;
1795        vfd->ioctl_ops          = &vpfe_ioctl_ops;
1796        vfd->tvnorms            = 0;
1797        vfd->v4l2_dev           = &vpfe_dev->v4l2_dev;
1798        snprintf(vfd->name, sizeof(vfd->name),
1799                 "%s_V%d.%d.%d",
1800                 CAPTURE_DRV_NAME,
1801                 (VPFE_CAPTURE_VERSION_CODE >> 16) & 0xff,
1802                 (VPFE_CAPTURE_VERSION_CODE >> 8) & 0xff,
1803                 (VPFE_CAPTURE_VERSION_CODE) & 0xff);
1804
1805        ret = v4l2_device_register(&pdev->dev, &vpfe_dev->v4l2_dev);
1806        if (ret) {
1807                v4l2_err(pdev->dev.driver,
1808                        "Unable to register v4l2 device.\n");
1809                goto probe_out_release_irq;
1810        }
1811        v4l2_info(&vpfe_dev->v4l2_dev, "v4l2 device registered\n");
1812        spin_lock_init(&vpfe_dev->irqlock);
1813        spin_lock_init(&vpfe_dev->dma_queue_lock);
1814        mutex_init(&vpfe_dev->lock);
1815
1816        /* Initialize field of the device objects */
1817        vpfe_dev->numbuffers = config_params.numbuffers;
1818
1819        /* register video device */
1820        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev,
1821                "trying to register vpfe device.\n");
1822        v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev,
1823                "video_dev=%p\n", &vpfe_dev->video_dev);
1824        vpfe_dev->fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1825        ret = video_register_device(&vpfe_dev->video_dev,
1826                                    VFL_TYPE_GRABBER, -1);
1827
1828        if (ret) {
1829                v4l2_err(pdev->dev.driver,
1830                        "Unable to register video device.\n");
1831                goto probe_out_v4l2_unregister;
1832        }
1833
1834        v4l2_info(&vpfe_dev->v4l2_dev, "video device registered\n");
1835        /* set the driver data in platform device */
1836        platform_set_drvdata(pdev, vpfe_dev);
1837        /* set driver private data */
1838        video_set_drvdata(&vpfe_dev->video_dev, vpfe_dev);
1839        i2c_adap = i2c_get_adapter(vpfe_cfg->i2c_adapter_id);
1840        num_subdevs = vpfe_cfg->num_subdevs;
1841        vpfe_dev->sd = kmalloc_array(num_subdevs,
1842                                     sizeof(*vpfe_dev->sd),
1843                                     GFP_KERNEL);
1844        if (!vpfe_dev->sd) {
1845                ret = -ENOMEM;
1846                goto probe_out_video_unregister;
1847        }
1848
1849        for (i = 0; i < num_subdevs; i++) {
1850                struct v4l2_input *inps;
1851
1852                sdinfo = &vpfe_cfg->sub_devs[i];
1853
1854                /* Load up the subdevice */
1855                vpfe_dev->sd[i] =
1856                        v4l2_i2c_new_subdev_board(&vpfe_dev->v4l2_dev,
1857                                                  i2c_adap,
1858                                                  &sdinfo->board_info,
1859                                                  NULL);
1860                if (vpfe_dev->sd[i]) {
1861                        v4l2_info(&vpfe_dev->v4l2_dev,
1862                                  "v4l2 sub device %s registered\n",
1863                                  sdinfo->name);
1864                        vpfe_dev->sd[i]->grp_id = sdinfo->grp_id;
1865                        /* update tvnorms from the sub devices */
1866                        for (j = 0; j < sdinfo->num_inputs; j++) {
1867                                inps = &sdinfo->inputs[j];
1868                                vfd->tvnorms |= inps->std;
1869                        }
1870                } else {
1871                        v4l2_info(&vpfe_dev->v4l2_dev,
1872                                  "v4l2 sub device %s register fails\n",
1873                                  sdinfo->name);
1874                        ret = -ENXIO;
1875                        goto probe_sd_out;
1876                }
1877        }
1878
1879        /* set first sub device as current one */
1880        vpfe_dev->current_subdev = &vpfe_cfg->sub_devs[0];
1881        vpfe_dev->v4l2_dev.ctrl_handler = vpfe_dev->sd[0]->ctrl_handler;
1882
1883        /* We have at least one sub device to work with */
1884        mutex_unlock(&ccdc_lock);
1885        return 0;
1886
1887probe_sd_out:
1888        kfree(vpfe_dev->sd);
1889probe_out_video_unregister:
1890        video_unregister_device(&vpfe_dev->video_dev);
1891probe_out_v4l2_unregister:
1892        v4l2_device_unregister(&vpfe_dev->v4l2_dev);
1893probe_out_release_irq:
1894        free_irq(vpfe_dev->ccdc_irq0, vpfe_dev);
1895probe_free_ccdc_cfg_mem:
1896        kfree(ccdc_cfg);
1897        mutex_unlock(&ccdc_lock);
1898probe_free_dev_mem:
1899        kfree(vpfe_dev);
1900        return ret;
1901}
1902
1903/*
1904 * vpfe_remove : It un-register device from V4L2 driver
1905 */
1906static int vpfe_remove(struct platform_device *pdev)
1907{
1908        struct vpfe_device *vpfe_dev = platform_get_drvdata(pdev);
1909
1910        v4l2_info(pdev->dev.driver, "vpfe_remove\n");
1911
1912        free_irq(vpfe_dev->ccdc_irq0, vpfe_dev);
1913        kfree(vpfe_dev->sd);
1914        v4l2_device_unregister(&vpfe_dev->v4l2_dev);
1915        video_unregister_device(&vpfe_dev->video_dev);
1916        kfree(vpfe_dev);
1917        kfree(ccdc_cfg);
1918        return 0;
1919}
1920
1921static int vpfe_suspend(struct device *dev)
1922{
1923        return 0;
1924}
1925
1926static int vpfe_resume(struct device *dev)
1927{
1928        return 0;
1929}
1930
1931static const struct dev_pm_ops vpfe_dev_pm_ops = {
1932        .suspend = vpfe_suspend,
1933        .resume = vpfe_resume,
1934};
1935
1936static struct platform_driver vpfe_driver = {
1937        .driver = {
1938                .name = CAPTURE_DRV_NAME,
1939                .pm = &vpfe_dev_pm_ops,
1940        },
1941        .probe = vpfe_probe,
1942        .remove = vpfe_remove,
1943};
1944
1945module_platform_driver(vpfe_driver);
1946