Pileus Git - ~andy/linux/blob - drivers/media/platform/davinci/vpif_capture.c

   1 /*
   2  * Copyright (C) 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  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17  *
  18  * TODO : add support for VBI & HBI data service
  19  *        add static buffer allocation
  20  */
  21 #include <linux/kernel.h>
  22 #include <linux/init.h>
  23 #include <linux/module.h>
  24 #include <linux/errno.h>
  25 #include <linux/fs.h>
  26 #include <linux/mm.h>
  27 #include <linux/interrupt.h>
  28 #include <linux/workqueue.h>
  29 #include <linux/string.h>
  30 #include <linux/videodev2.h>
  31 #include <linux/wait.h>
  32 #include <linux/time.h>
  33 #include <linux/i2c.h>
  34 #include <linux/platform_device.h>
  35 #include <linux/io.h>
  36 #include <linux/slab.h>
  37 #include <media/v4l2-device.h>
  38 #include <media/v4l2-ioctl.h>
  39 #include <media/v4l2-chip-ident.h>
  40
  41 #include "vpif_capture.h"
  42 #include "vpif.h"
  43
  44 MODULE_DESCRIPTION("TI DaVinci VPIF Capture driver");
  45 MODULE_LICENSE("GPL");
  46 MODULE_VERSION(VPIF_CAPTURE_VERSION);
  47
  48 #define vpif_err(fmt, arg...)   v4l2_err(&vpif_obj.v4l2_dev, fmt, ## arg)
  49 #define vpif_dbg(level, debug, fmt, arg...)     \
  50                 v4l2_dbg(level, debug, &vpif_obj.v4l2_dev, fmt, ## arg)
  51
  52 static int debug = 1;
  53 static u32 ch0_numbuffers = 3;
  54 static u32 ch1_numbuffers = 3;
  55 static u32 ch0_bufsize = 1920 * 1080 * 2;
  56 static u32 ch1_bufsize = 720 * 576 * 2;
  57
  58 module_param(debug, int, 0644);
  59 module_param(ch0_numbuffers, uint, S_IRUGO);
  60 module_param(ch1_numbuffers, uint, S_IRUGO);
  61 module_param(ch0_bufsize, uint, S_IRUGO);
  62 module_param(ch1_bufsize, uint, S_IRUGO);
  63
  64 MODULE_PARM_DESC(debug, "Debug level 0-1");
  65 MODULE_PARM_DESC(ch2_numbuffers, "Channel0 buffer count (default:3)");
  66 MODULE_PARM_DESC(ch3_numbuffers, "Channel1 buffer count (default:3)");
  67 MODULE_PARM_DESC(ch2_bufsize, "Channel0 buffer size (default:1920 x 1080 x 2)");
  68 MODULE_PARM_DESC(ch3_bufsize, "Channel1 buffer size (default:720 x 576 x 2)");
  69
  70 static struct vpif_config_params config_params = {
  71         .min_numbuffers = 3,
  72         .numbuffers[0] = 3,
  73         .numbuffers[1] = 3,
  74         .min_bufsize[0] = 720 * 480 * 2,
  75         .min_bufsize[1] = 720 * 480 * 2,
  76         .channel_bufsize[0] = 1920 * 1080 * 2,
  77         .channel_bufsize[1] = 720 * 576 * 2,
  78 };
  79
  80 /* global variables */
  81 static struct vpif_device vpif_obj = { {NULL} };
  82 static struct device *vpif_dev;
  83 static void vpif_calculate_offsets(struct channel_obj *ch);
  84 static void vpif_config_addr(struct channel_obj *ch, int muxmode);
  85
  86 /**
  87  * buffer_prepare :  callback function for buffer prepare
  88  * @vb: ptr to vb2_buffer
  89  *
  90  * This is the callback function for buffer prepare when vb2_qbuf()
  91  * function is called. The buffer is prepared and user space virtual address
  92  * or user address is converted into  physical address
  93  */
  94 static int vpif_buffer_prepare(struct vb2_buffer *vb)
  95 {
  96         /* Get the file handle object and channel object */
  97         struct vpif_fh *fh = vb2_get_drv_priv(vb->vb2_queue);
  98         struct vb2_queue *q = vb->vb2_queue;
  99         struct channel_obj *ch = fh->channel;
 100         struct common_obj *common;
 101         unsigned long addr;
 102
 103         vpif_dbg(2, debug, "vpif_buffer_prepare\n");
 104
 105         common = &ch->common[VPIF_VIDEO_INDEX];
 106
 107         if (vb->state != VB2_BUF_STATE_ACTIVE &&
 108                 vb->state != VB2_BUF_STATE_PREPARED) {
 109                 vb2_set_plane_payload(vb, 0, common->fmt.fmt.pix.sizeimage);
 110                 if (vb2_plane_vaddr(vb, 0) &&
 111                 vb2_get_plane_payload(vb, 0) > vb2_plane_size(vb, 0))
 112                         goto exit;
 113                 addr = vb2_dma_contig_plane_dma_addr(vb, 0);
 114
 115                 if (q->streaming) {
 116                         if (!IS_ALIGNED((addr + common->ytop_off), 8) ||
 117                                 !IS_ALIGNED((addr + common->ybtm_off), 8) ||
 118                                 !IS_ALIGNED((addr + common->ctop_off), 8) ||
 119                                 !IS_ALIGNED((addr + common->cbtm_off), 8))
 120                                 goto exit;
 121                 }
 122         }
 123         return 0;
 124 exit:
 125         vpif_dbg(1, debug, "buffer_prepare:offset is not aligned to 8 bytes\n");
 126         return -EINVAL;
 127 }
 128
 129 /**
 130  * vpif_buffer_queue_setup : Callback function for buffer setup.
 131  * @vq: vb2_queue ptr
 132  * @fmt: v4l2 format
 133  * @nbuffers: ptr to number of buffers requested by application
 134  * @nplanes:: contains number of distinct video planes needed to hold a frame
 135  * @sizes[]: contains the size (in bytes) of each plane.
 136  * @alloc_ctxs: ptr to allocation context
 137  *
 138  * This callback function is called when reqbuf() is called to adjust
 139  * the buffer count and buffer size
 140  */
 141 static int vpif_buffer_queue_setup(struct vb2_queue *vq,
 142                                 const struct v4l2_format *fmt,
 143                                 unsigned int *nbuffers, unsigned int *nplanes,
 144                                 unsigned int sizes[], void *alloc_ctxs[])
 145 {
 146         /* Get the file handle object and channel object */
 147         struct vpif_fh *fh = vb2_get_drv_priv(vq);
 148         struct channel_obj *ch = fh->channel;
 149         struct common_obj *common;
 150         unsigned long size;
 151
 152         common = &ch->common[VPIF_VIDEO_INDEX];
 153
 154         vpif_dbg(2, debug, "vpif_buffer_setup\n");
 155
 156         /* If memory type is not mmap, return */
 157         if (V4L2_MEMORY_MMAP == common->memory) {
 158                 /* Calculate the size of the buffer */
 159                 size = config_params.channel_bufsize[ch->channel_id];
 160                 /*
 161                  * Checking if the buffer size exceeds the available buffer
 162                  * ycmux_mode = 0 means 1 channel mode HD and
 163                  * ycmux_mode = 1 means 2 channels mode SD
 164                  */
 165                 if (ch->vpifparams.std_info.ycmux_mode == 0) {
 166                         if (config_params.video_limit[ch->channel_id])
 167                                 while (size * *nbuffers >
 168                                         (config_params.video_limit[0]
 169                                                 + config_params.video_limit[1]))
 170                                         (*nbuffers)--;
 171                 } else {
 172                         if (config_params.video_limit[ch->channel_id])
 173                                 while (size * *nbuffers >
 174                                 config_params.video_limit[ch->channel_id])
 175                                         (*nbuffers)--;
 176                 }
 177
 178         } else {
 179                 size = common->fmt.fmt.pix.sizeimage;
 180         }
 181
 182         if (*nbuffers < config_params.min_numbuffers)
 183                 *nbuffers = config_params.min_numbuffers;
 184
 185         *nplanes = 1;
 186         sizes[0] = size;
 187         alloc_ctxs[0] = common->alloc_ctx;
 188
 189         return 0;
 190 }
 191
 192 /**
 193  * vpif_buffer_queue : Callback function to add buffer to DMA queue
 194  * @vb: ptr to vb2_buffer
 195  */
 196 static void vpif_buffer_queue(struct vb2_buffer *vb)
 197 {
 198         /* Get the file handle object and channel object */
 199         struct vpif_fh *fh = vb2_get_drv_priv(vb->vb2_queue);
 200         struct channel_obj *ch = fh->channel;
 201         struct vpif_cap_buffer *buf = container_of(vb,
 202                                 struct vpif_cap_buffer, vb);
 203         struct common_obj *common;
 204
 205         common = &ch->common[VPIF_VIDEO_INDEX];
 206
 207         vpif_dbg(2, debug, "vpif_buffer_queue\n");
 208
 209         /* add the buffer to the DMA queue */
 210         list_add_tail(&buf->list, &common->dma_queue);
 211 }
 212
 213 /**
 214  * vpif_buf_cleanup : Callback function to free buffer
 215  * @vb: ptr to vb2_buffer
 216  *
 217  * This function is called from the videobuf2 layer to free memory
 218  * allocated to  the buffers
 219  */
 220 static void vpif_buf_cleanup(struct vb2_buffer *vb)
 221 {
 222         /* Get the file handle object and channel object */
 223         struct vpif_fh *fh = vb2_get_drv_priv(vb->vb2_queue);
 224         struct vpif_cap_buffer *buf = container_of(vb,
 225                                         struct vpif_cap_buffer, vb);
 226         struct channel_obj *ch = fh->channel;
 227         struct common_obj *common;
 228         unsigned long flags;
 229
 230         common = &ch->common[VPIF_VIDEO_INDEX];
 231
 232         spin_lock_irqsave(&common->irqlock, flags);
 233         if (vb->state == VB2_BUF_STATE_ACTIVE)
 234                 list_del_init(&buf->list);
 235         spin_unlock_irqrestore(&common->irqlock, flags);
 236
 237 }
 238
 239 static void vpif_wait_prepare(struct vb2_queue *vq)
 240 {
 241         struct vpif_fh *fh = vb2_get_drv_priv(vq);
 242         struct channel_obj *ch = fh->channel;
 243         struct common_obj *common;
 244
 245         common = &ch->common[VPIF_VIDEO_INDEX];
 246         mutex_unlock(&common->lock);
 247 }
 248
 249 static void vpif_wait_finish(struct vb2_queue *vq)
 250 {
 251         struct vpif_fh *fh = vb2_get_drv_priv(vq);
 252         struct channel_obj *ch = fh->channel;
 253         struct common_obj *common;
 254
 255         common = &ch->common[VPIF_VIDEO_INDEX];
 256         mutex_lock(&common->lock);
 257 }
 258
 259 static int vpif_buffer_init(struct vb2_buffer *vb)
 260 {
 261         struct vpif_cap_buffer *buf = container_of(vb,
 262                                         struct vpif_cap_buffer, vb);
 263
 264         INIT_LIST_HEAD(&buf->list);
 265
 266         return 0;
 267 }
 268
 269 static u8 channel_first_int[VPIF_NUMBER_OF_OBJECTS][2] =
 270         { {1, 1} };
 271
 272 static int vpif_start_streaming(struct vb2_queue *vq, unsigned int count)
 273 {
 274         struct vpif_capture_config *vpif_config_data =
 275                                         vpif_dev->platform_data;
 276         struct vpif_fh *fh = vb2_get_drv_priv(vq);
 277         struct channel_obj *ch = fh->channel;
 278         struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
 279         struct vpif_params *vpif = &ch->vpifparams;
 280         unsigned long addr = 0;
 281         int ret;
 282
 283                 /* If buffer queue is empty, return error */
 284         if (list_empty(&common->dma_queue)) {
 285                 vpif_dbg(1, debug, "buffer queue is empty\n");
 286                 return -EIO;
 287         }
 288
 289         /* Get the next frame from the buffer queue */
 290         common->cur_frm = common->next_frm = list_entry(common->dma_queue.next,
 291                                     struct vpif_cap_buffer, list);
 292         /* Remove buffer from the buffer queue */
 293         list_del(&common->cur_frm->list);
 294         /* Mark state of the current frame to active */
 295         common->cur_frm->vb.state = VB2_BUF_STATE_ACTIVE;
 296         /* Initialize field_id and started member */
 297         ch->field_id = 0;
 298         common->started = 1;
 299         addr = vb2_dma_contig_plane_dma_addr(&common->cur_frm->vb, 0);
 300
 301         /* Calculate the offset for Y and C data in the buffer */
 302         vpif_calculate_offsets(ch);
 303
 304         if ((vpif->std_info.frm_fmt &&
 305             ((common->fmt.fmt.pix.field != V4L2_FIELD_NONE) &&
 306              (common->fmt.fmt.pix.field != V4L2_FIELD_ANY))) ||
 307             (!vpif->std_info.frm_fmt &&
 308              (common->fmt.fmt.pix.field == V4L2_FIELD_NONE))) {
 309                 vpif_dbg(1, debug, "conflict in field format and std format\n");
 310                 return -EINVAL;
 311         }
 312
 313         /* configure 1 or 2 channel mode */
 314         if (vpif_config_data->setup_input_channel_mode) {
 315                 ret = vpif_config_data->
 316                         setup_input_channel_mode(vpif->std_info.ycmux_mode);
 317                 if (ret < 0) {
 318                         vpif_dbg(1, debug, "can't set vpif channel mode\n");
 319                         return ret;
 320                 }
 321         }
 322
 323         /* Call vpif_set_params function to set the parameters and addresses */
 324         ret = vpif_set_video_params(vpif, ch->channel_id);
 325
 326         if (ret < 0) {
 327                 vpif_dbg(1, debug, "can't set video params\n");
 328                 return ret;
 329         }
 330
 331         common->started = ret;
 332         vpif_config_addr(ch, ret);
 333
 334         common->set_addr(addr + common->ytop_off,
 335                          addr + common->ybtm_off,
 336                          addr + common->ctop_off,
 337                          addr + common->cbtm_off);
 338
 339         /**
 340          * Set interrupt for both the fields in VPIF Register enable channel in
 341          * VPIF register
 342          */
 343         channel_first_int[VPIF_VIDEO_INDEX][ch->channel_id] = 1;
 344         if ((VPIF_CHANNEL0_VIDEO == ch->channel_id)) {
 345                 channel0_intr_assert();
 346                 channel0_intr_enable(1);
 347                 enable_channel0(1);
 348         }
 349         if ((VPIF_CHANNEL1_VIDEO == ch->channel_id) ||
 350             (common->started == 2)) {
 351                 channel1_intr_assert();
 352                 channel1_intr_enable(1);
 353                 enable_channel1(1);
 354         }
 355
 356         return 0;
 357 }
 358
 359 /* abort streaming and wait for last buffer */
 360 static int vpif_stop_streaming(struct vb2_queue *vq)
 361 {
 362         struct vpif_fh *fh = vb2_get_drv_priv(vq);
 363         struct channel_obj *ch = fh->channel;
 364         struct common_obj *common;
 365
 366         if (!vb2_is_streaming(vq))
 367                 return 0;
 368
 369         common = &ch->common[VPIF_VIDEO_INDEX];
 370
 371         /* release all active buffers */
 372         while (!list_empty(&common->dma_queue)) {
 373                 common->next_frm = list_entry(common->dma_queue.next,
 374                                                 struct vpif_cap_buffer, list);
 375                 list_del(&common->next_frm->list);
 376                 vb2_buffer_done(&common->next_frm->vb, VB2_BUF_STATE_ERROR);
 377         }
 378
 379         return 0;
 380 }
 381
 382 static struct vb2_ops video_qops = {
 383         .queue_setup            = vpif_buffer_queue_setup,
 384         .wait_prepare           = vpif_wait_prepare,
 385         .wait_finish            = vpif_wait_finish,
 386         .buf_init               = vpif_buffer_init,
 387         .buf_prepare            = vpif_buffer_prepare,
 388         .start_streaming        = vpif_start_streaming,
 389         .stop_streaming         = vpif_stop_streaming,
 390         .buf_cleanup            = vpif_buf_cleanup,
 391         .buf_queue              = vpif_buffer_queue,
 392 };
 393
 394 /**
 395  * vpif_process_buffer_complete: process a completed buffer
 396  * @common: ptr to common channel object
 397  *
 398  * This function time stamp the buffer and mark it as DONE. It also
 399  * wake up any process waiting on the QUEUE and set the next buffer
 400  * as current
 401  */
 402 static void vpif_process_buffer_complete(struct common_obj *common)
 403 {
 404         do_gettimeofday(&common->cur_frm->vb.v4l2_buf.timestamp);
 405         vb2_buffer_done(&common->cur_frm->vb,
 406                                             VB2_BUF_STATE_DONE);
 407         /* Make curFrm pointing to nextFrm */
 408         common->cur_frm = common->next_frm;
 409 }
 410
 411 /**
 412  * vpif_schedule_next_buffer: set next buffer address for capture
 413  * @common : ptr to common channel object
 414  *
 415  * This function will get next buffer from the dma queue and
 416  * set the buffer address in the vpif register for capture.
 417  * the buffer is marked active
 418  */
 419 static void vpif_schedule_next_buffer(struct common_obj *common)
 420 {
 421         unsigned long addr = 0;
 422
 423         common->next_frm = list_entry(common->dma_queue.next,
 424                                      struct vpif_cap_buffer, list);
 425         /* Remove that buffer from the buffer queue */
 426         list_del(&common->next_frm->list);
 427         common->next_frm->vb.state = VB2_BUF_STATE_ACTIVE;
 428         addr = vb2_dma_contig_plane_dma_addr(&common->next_frm->vb, 0);
 429
 430         /* Set top and bottom field addresses in VPIF registers */
 431         common->set_addr(addr + common->ytop_off,
 432                          addr + common->ybtm_off,
 433                          addr + common->ctop_off,
 434                          addr + common->cbtm_off);
 435 }
 436
 437 /**
 438  * vpif_channel_isr : ISR handler for vpif capture
 439  * @irq: irq number
 440  * @dev_id: dev_id ptr
 441  *
 442  * It changes status of the captured buffer, takes next buffer from the queue
 443  * and sets its address in VPIF registers
 444  */
 445 static irqreturn_t vpif_channel_isr(int irq, void *dev_id)
 446 {
 447         struct vpif_device *dev = &vpif_obj;
 448         struct common_obj *common;
 449         struct channel_obj *ch;
 450         enum v4l2_field field;
 451         int channel_id = 0;
 452         int fid = -1, i;
 453
 454         channel_id = *(int *)(dev_id);
 455         if (!vpif_intr_status(channel_id))
 456                 return IRQ_NONE;
 457
 458         ch = dev->dev[channel_id];
 459
 460         field = ch->common[VPIF_VIDEO_INDEX].fmt.fmt.pix.field;
 461
 462         for (i = 0; i < VPIF_NUMBER_OF_OBJECTS; i++) {
 463                 common = &ch->common[i];
 464                 /* skip If streaming is not started in this channel */
 465                 if (0 == common->started)
 466                         continue;
 467
 468                 /* Check the field format */
 469                 if (1 == ch->vpifparams.std_info.frm_fmt) {
 470                         /* Progressive mode */
 471                         if (list_empty(&common->dma_queue))
 472                                 continue;
 473
 474                         if (!channel_first_int[i][channel_id])
 475                                 vpif_process_buffer_complete(common);
 476
 477                         channel_first_int[i][channel_id] = 0;
 478
 479                         vpif_schedule_next_buffer(common);
 480
 481
 482                         channel_first_int[i][channel_id] = 0;
 483                 } else {
 484                         /**
 485                          * Interlaced mode. If it is first interrupt, ignore
 486                          * it
 487                          */
 488                         if (channel_first_int[i][channel_id]) {
 489                                 channel_first_int[i][channel_id] = 0;
 490                                 continue;
 491                         }
 492                         if (0 == i) {
 493                                 ch->field_id ^= 1;
 494                                 /* Get field id from VPIF registers */
 495                                 fid = vpif_channel_getfid(ch->channel_id);
 496                                 if (fid != ch->field_id) {
 497                                         /**
 498                                          * If field id does not match stored
 499                                          * field id, make them in sync
 500                                          */
 501                                         if (0 == fid)
 502                                                 ch->field_id = fid;
 503                                         return IRQ_HANDLED;
 504                                 }
 505                         }
 506                         /* device field id and local field id are in sync */
 507                         if (0 == fid) {
 508                                 /* this is even field */
 509                                 if (common->cur_frm == common->next_frm)
 510                                         continue;
 511
 512                                 /* mark the current buffer as done */
 513                                 vpif_process_buffer_complete(common);
 514                         } else if (1 == fid) {
 515                                 /* odd field */
 516                                 if (list_empty(&common->dma_queue) ||
 517                                     (common->cur_frm != common->next_frm))
 518                                         continue;
 519
 520                                 vpif_schedule_next_buffer(common);
 521                         }
 522                 }
 523         }
 524         return IRQ_HANDLED;
 525 }
 526
 527 /**
 528  * vpif_update_std_info() - update standard related info
 529  * @ch: ptr to channel object
 530  *
 531  * For a given standard selected by application, update values
 532  * in the device data structures
 533  */
 534 static int vpif_update_std_info(struct channel_obj *ch)
 535 {
 536         struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
 537         struct vpif_params *vpifparams = &ch->vpifparams;
 538         const struct vpif_channel_config_params *config;
 539         struct vpif_channel_config_params *std_info = &vpifparams->std_info;
 540         struct video_obj *vid_ch = &ch->video;
 541         int index;
 542
 543         vpif_dbg(2, debug, "vpif_update_std_info\n");
 544
 545         for (index = 0; index < vpif_ch_params_count; index++) {
 546                 config = &ch_params[index];
 547                 if (config->hd_sd == 0) {
 548                         vpif_dbg(2, debug, "SD format\n");
 549                         if (config->stdid & vid_ch->stdid) {
 550                                 memcpy(std_info, config, sizeof(*config));
 551                                 break;
 552                         }
 553                 } else {
 554                         vpif_dbg(2, debug, "HD format\n");
 555                         if (!memcmp(&config->dv_timings, &vid_ch->dv_timings,
 556                                 sizeof(vid_ch->dv_timings))) {
 557                                 memcpy(std_info, config, sizeof(*config));
 558                                 break;
 559                         }
 560                 }
 561         }
 562
 563         /* standard not found */
 564         if (index == vpif_ch_params_count)
 565                 return -EINVAL;
 566
 567         common->fmt.fmt.pix.width = std_info->width;
 568         common->width = std_info->width;
 569         common->fmt.fmt.pix.height = std_info->height;
 570         common->height = std_info->height;
 571         common->fmt.fmt.pix.bytesperline = std_info->width;
 572         vpifparams->video_params.hpitch = std_info->width;
 573         vpifparams->video_params.storage_mode = std_info->frm_fmt;
 574
 575         return 0;
 576 }
 577
 578 /**
 579  * vpif_calculate_offsets : This function calculates buffers offsets
 580  * @ch : ptr to channel object
 581  *
 582  * This function calculates buffer offsets for Y and C in the top and
 583  * bottom field
 584  */
 585 static void vpif_calculate_offsets(struct channel_obj *ch)
 586 {
 587         unsigned int hpitch, vpitch, sizeimage;
 588         struct video_obj *vid_ch = &(ch->video);
 589         struct vpif_params *vpifparams = &ch->vpifparams;
 590         struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
 591         enum v4l2_field field = common->fmt.fmt.pix.field;
 592
 593         vpif_dbg(2, debug, "vpif_calculate_offsets\n");
 594
 595         if (V4L2_FIELD_ANY == field) {
 596                 if (vpifparams->std_info.frm_fmt)
 597                         vid_ch->buf_field = V4L2_FIELD_NONE;
 598                 else
 599                         vid_ch->buf_field = V4L2_FIELD_INTERLACED;
 600         } else
 601                 vid_ch->buf_field = common->fmt.fmt.pix.field;
 602
 603         sizeimage = common->fmt.fmt.pix.sizeimage;
 604
 605         hpitch = common->fmt.fmt.pix.bytesperline;
 606         vpitch = sizeimage / (hpitch * 2);
 607
 608         if ((V4L2_FIELD_NONE == vid_ch->buf_field) ||
 609             (V4L2_FIELD_INTERLACED == vid_ch->buf_field)) {
 610                 /* Calculate offsets for Y top, Y Bottom, C top and C Bottom */
 611                 common->ytop_off = 0;
 612                 common->ybtm_off = hpitch;
 613                 common->ctop_off = sizeimage / 2;
 614                 common->cbtm_off = sizeimage / 2 + hpitch;
 615         } else if (V4L2_FIELD_SEQ_TB == vid_ch->buf_field) {
 616                 /* Calculate offsets for Y top, Y Bottom, C top and C Bottom */
 617                 common->ytop_off = 0;
 618                 common->ybtm_off = sizeimage / 4;
 619                 common->ctop_off = sizeimage / 2;
 620                 common->cbtm_off = common->ctop_off + sizeimage / 4;
 621         } else if (V4L2_FIELD_SEQ_BT == vid_ch->buf_field) {
 622                 /* Calculate offsets for Y top, Y Bottom, C top and C Bottom */
 623                 common->ybtm_off = 0;
 624                 common->ytop_off = sizeimage / 4;
 625                 common->cbtm_off = sizeimage / 2;
 626                 common->ctop_off = common->cbtm_off + sizeimage / 4;
 627         }
 628         if ((V4L2_FIELD_NONE == vid_ch->buf_field) ||
 629             (V4L2_FIELD_INTERLACED == vid_ch->buf_field))
 630                 vpifparams->video_params.storage_mode = 1;
 631         else
 632                 vpifparams->video_params.storage_mode = 0;
 633
 634         if (1 == vpifparams->std_info.frm_fmt)
 635                 vpifparams->video_params.hpitch =
 636                     common->fmt.fmt.pix.bytesperline;
 637         else {
 638                 if ((field == V4L2_FIELD_ANY)
 639                     || (field == V4L2_FIELD_INTERLACED))
 640                         vpifparams->video_params.hpitch =
 641                             common->fmt.fmt.pix.bytesperline * 2;
 642                 else
 643                         vpifparams->video_params.hpitch =
 644                             common->fmt.fmt.pix.bytesperline;
 645         }
 646
 647         ch->vpifparams.video_params.stdid = vpifparams->std_info.stdid;
 648 }
 649
 650 /**
 651  * vpif_config_format: configure default frame format in the device
 652  * ch : ptr to channel object
 653  */
 654 static void vpif_config_format(struct channel_obj *ch)
 655 {
 656         struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
 657
 658         vpif_dbg(2, debug, "vpif_config_format\n");
 659
 660         common->fmt.fmt.pix.field = V4L2_FIELD_ANY;
 661         if (config_params.numbuffers[ch->channel_id] == 0)
 662                 common->memory = V4L2_MEMORY_USERPTR;
 663         else
 664                 common->memory = V4L2_MEMORY_MMAP;
 665
 666         common->fmt.fmt.pix.sizeimage
 667             = config_params.channel_bufsize[ch->channel_id];
 668
 669         if (ch->vpifparams.iface.if_type == VPIF_IF_RAW_BAYER)
 670                 common->fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_SBGGR8;
 671         else
 672                 common->fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUV422P;
 673         common->fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 674 }
 675
 676 /**
 677  * vpif_get_default_field() - Get default field type based on interface
 678  * @vpif_params - ptr to vpif params
 679  */
 680 static inline enum v4l2_field vpif_get_default_field(
 681                                 struct vpif_interface *iface)
 682 {
 683         return (iface->if_type == VPIF_IF_RAW_BAYER) ? V4L2_FIELD_NONE :
 684                                                 V4L2_FIELD_INTERLACED;
 685 }
 686
 687 /**
 688  * vpif_check_format()  - check given pixel format for compatibility
 689  * @ch - channel  ptr
 690  * @pixfmt - Given pixel format
 691  * @update - update the values as per hardware requirement
 692  *
 693  * Check the application pixel format for S_FMT and update the input
 694  * values as per hardware limits for TRY_FMT. The default pixel and
 695  * field format is selected based on interface type.
 696  */
 697 static int vpif_check_format(struct channel_obj *ch,
 698                              struct v4l2_pix_format *pixfmt,
 699                              int update)
 700 {
 701         struct common_obj *common = &(ch->common[VPIF_VIDEO_INDEX]);
 702         struct vpif_params *vpif_params = &ch->vpifparams;
 703         enum v4l2_field field = pixfmt->field;
 704         u32 sizeimage, hpitch, vpitch;
 705         int ret = -EINVAL;
 706
 707         vpif_dbg(2, debug, "vpif_check_format\n");
 708         /**
 709          * first check for the pixel format. If if_type is Raw bayer,
 710          * only V4L2_PIX_FMT_SBGGR8 format is supported. Otherwise only
 711          * V4L2_PIX_FMT_YUV422P is supported
 712          */
 713         if (vpif_params->iface.if_type == VPIF_IF_RAW_BAYER) {
 714                 if (pixfmt->pixelformat != V4L2_PIX_FMT_SBGGR8) {
 715                         if (!update) {
 716                                 vpif_dbg(2, debug, "invalid pix format\n");
 717                                 goto exit;
 718                         }
 719                         pixfmt->pixelformat = V4L2_PIX_FMT_SBGGR8;
 720                 }
 721         } else {
 722                 if (pixfmt->pixelformat != V4L2_PIX_FMT_YUV422P) {
 723                         if (!update) {
 724                                 vpif_dbg(2, debug, "invalid pixel format\n");
 725                                 goto exit;
 726                         }
 727                         pixfmt->pixelformat = V4L2_PIX_FMT_YUV422P;
 728                 }
 729         }
 730
 731         if (!(VPIF_VALID_FIELD(field))) {
 732                 if (!update) {
 733                         vpif_dbg(2, debug, "invalid field format\n");
 734                         goto exit;
 735                 }
 736                 /**
 737                  * By default use FIELD_NONE for RAW Bayer capture
 738                  * and FIELD_INTERLACED for other interfaces
 739                  */
 740                 field = vpif_get_default_field(&vpif_params->iface);
 741         } else if (field == V4L2_FIELD_ANY)
 742                 /* unsupported field. Use default */
 743                 field = vpif_get_default_field(&vpif_params->iface);
 744
 745         /* validate the hpitch */
 746         hpitch = pixfmt->bytesperline;
 747         if (hpitch < vpif_params->std_info.width) {
 748                 if (!update) {
 749                         vpif_dbg(2, debug, "invalid hpitch\n");
 750                         goto exit;
 751                 }
 752                 hpitch = vpif_params->std_info.width;
 753         }
 754
 755         sizeimage = pixfmt->sizeimage;
 756
 757         vpitch = sizeimage / (hpitch * 2);
 758
 759         /* validate the vpitch */
 760         if (vpitch < vpif_params->std_info.height) {
 761                 if (!update) {
 762                         vpif_dbg(2, debug, "Invalid vpitch\n");
 763                         goto exit;
 764                 }
 765                 vpitch = vpif_params->std_info.height;
 766         }
 767
 768         /* Check for 8 byte alignment */
 769         if (!ALIGN(hpitch, 8)) {
 770                 if (!update) {
 771                         vpif_dbg(2, debug, "invalid pitch alignment\n");
 772                         goto exit;
 773                 }
 774                 /* adjust to next 8 byte boundary */
 775                 hpitch = (((hpitch + 7) / 8) * 8);
 776         }
 777         /* if update is set, modify the bytesperline and sizeimage */
 778         if (update) {
 779                 pixfmt->bytesperline = hpitch;
 780                 pixfmt->sizeimage = hpitch * vpitch * 2;
 781         }
 782         /**
 783          * Image width and height is always based on current standard width and
 784          * height
 785          */
 786         pixfmt->width = common->fmt.fmt.pix.width;
 787         pixfmt->height = common->fmt.fmt.pix.height;
 788         return 0;
 789 exit:
 790         return ret;
 791 }
 792
 793 /**
 794  * vpif_config_addr() - function to configure buffer address in vpif
 795  * @ch - channel ptr
 796  * @muxmode - channel mux mode
 797  */
 798 static void vpif_config_addr(struct channel_obj *ch, int muxmode)
 799 {
 800         struct common_obj *common;
 801
 802         vpif_dbg(2, debug, "vpif_config_addr\n");
 803
 804         common = &(ch->common[VPIF_VIDEO_INDEX]);
 805
 806         if (VPIF_CHANNEL1_VIDEO == ch->channel_id)
 807                 common->set_addr = ch1_set_videobuf_addr;
 808         else if (2 == muxmode)
 809                 common->set_addr = ch0_set_videobuf_addr_yc_nmux;
 810         else
 811                 common->set_addr = ch0_set_videobuf_addr;
 812 }
 813
 814 /**
 815  * vpif_mmap : It is used to map kernel space buffers into user spaces
 816  * @filep: file pointer
 817  * @vma: ptr to vm_area_struct
 818  */
 819 static int vpif_mmap(struct file *filep, struct vm_area_struct *vma)
 820 {
 821         /* Get the channel object and file handle object */
 822         struct vpif_fh *fh = filep->private_data;
 823         struct channel_obj *ch = fh->channel;
 824         struct common_obj *common = &(ch->common[VPIF_VIDEO_INDEX]);
 825         int ret;
 826
 827         vpif_dbg(2, debug, "vpif_mmap\n");
 828
 829         if (mutex_lock_interruptible(&common->lock))
 830                 return -ERESTARTSYS;
 831         ret = vb2_mmap(&common->buffer_queue, vma);
 832         mutex_unlock(&common->lock);
 833         return ret;
 834 }
 835
 836 /**
 837  * vpif_poll: It is used for select/poll system call
 838  * @filep: file pointer
 839  * @wait: poll table to wait
 840  */
 841 static unsigned int vpif_poll(struct file *filep, poll_table * wait)
 842 {
 843         struct vpif_fh *fh = filep->private_data;
 844         struct channel_obj *channel = fh->channel;
 845         struct common_obj *common = &(channel->common[VPIF_VIDEO_INDEX]);
 846         unsigned int res = 0;
 847
 848         vpif_dbg(2, debug, "vpif_poll\n");
 849
 850         if (common->started) {
 851                 mutex_lock(&common->lock);
 852                 res = vb2_poll(&common->buffer_queue, filep, wait);
 853                 mutex_unlock(&common->lock);
 854         }
 855         return res;
 856 }
 857
 858 /**
 859  * vpif_open : vpif open handler
 860  * @filep: file ptr
 861  *
 862  * It creates object of file handle structure and stores it in private_data
 863  * member of filepointer
 864  */
 865 static int vpif_open(struct file *filep)
 866 {
 867         struct video_device *vdev = video_devdata(filep);
 868         struct common_obj *common;
 869         struct video_obj *vid_ch;
 870         struct channel_obj *ch;
 871         struct vpif_fh *fh;
 872
 873         vpif_dbg(2, debug, "vpif_open\n");
 874
 875         ch = video_get_drvdata(vdev);
 876
 877         vid_ch = &ch->video;
 878         common = &ch->common[VPIF_VIDEO_INDEX];
 879
 880         /* Allocate memory for the file handle object */
 881         fh = kzalloc(sizeof(struct vpif_fh), GFP_KERNEL);
 882         if (NULL == fh) {
 883                 vpif_err("unable to allocate memory for file handle object\n");
 884                 return -ENOMEM;
 885         }
 886
 887         if (mutex_lock_interruptible(&common->lock)) {
 888                 kfree(fh);
 889                 return -ERESTARTSYS;
 890         }
 891         /* store pointer to fh in private_data member of filep */
 892         filep->private_data = fh;
 893         fh->channel = ch;
 894         fh->initialized = 0;
 895         /* If decoder is not initialized. initialize it */
 896         if (!ch->initialized) {
 897                 fh->initialized = 1;
 898                 ch->initialized = 1;
 899                 memset(&(ch->vpifparams), 0, sizeof(struct vpif_params));
 900         }
 901         /* Increment channel usrs counter */
 902         ch->usrs++;
 903         /* Set io_allowed member to false */
 904         fh->io_allowed[VPIF_VIDEO_INDEX] = 0;
 905         /* Initialize priority of this instance to default priority */
 906         fh->prio = V4L2_PRIORITY_UNSET;
 907         v4l2_prio_open(&ch->prio, &fh->prio);
 908         mutex_unlock(&common->lock);
 909         return 0;
 910 }
 911
 912 /**
 913  * vpif_release : function to clean up file close
 914  * @filep: file pointer
 915  *
 916  * This function deletes buffer queue, frees the buffers and the vpif file
 917  * handle
 918  */
 919 static int vpif_release(struct file *filep)
 920 {
 921         struct vpif_fh *fh = filep->private_data;
 922         struct channel_obj *ch = fh->channel;
 923         struct common_obj *common;
 924
 925         vpif_dbg(2, debug, "vpif_release\n");
 926
 927         common = &ch->common[VPIF_VIDEO_INDEX];
 928
 929         mutex_lock(&common->lock);
 930         /* if this instance is doing IO */
 931         if (fh->io_allowed[VPIF_VIDEO_INDEX]) {
 932                 /* Reset io_usrs member of channel object */
 933                 common->io_usrs = 0;
 934                 /* Disable channel as per its device type and channel id */
 935                 if (VPIF_CHANNEL0_VIDEO == ch->channel_id) {
 936                         enable_channel0(0);
 937                         channel0_intr_enable(0);
 938                 }
 939                 if ((VPIF_CHANNEL1_VIDEO == ch->channel_id) ||
 940                     (2 == common->started)) {
 941                         enable_channel1(0);
 942                         channel1_intr_enable(0);
 943                 }
 944                 common->started = 0;
 945                 /* Free buffers allocated */
 946                 vb2_queue_release(&common->buffer_queue);
 947                 vb2_dma_contig_cleanup_ctx(common->alloc_ctx);
 948         }
 949
 950         /* Decrement channel usrs counter */
 951         ch->usrs--;
 952
 953         /* Close the priority */
 954         v4l2_prio_close(&ch->prio, fh->prio);
 955
 956         if (fh->initialized)
 957                 ch->initialized = 0;
 958
 959         mutex_unlock(&common->lock);
 960         filep->private_data = NULL;
 961         kfree(fh);
 962         return 0;
 963 }
 964
 965 /**
 966  * vpif_reqbufs() - request buffer handler
 967  * @file: file ptr
 968  * @priv: file handle
 969  * @reqbuf: request buffer structure ptr
 970  */
 971 static int vpif_reqbufs(struct file *file, void *priv,
 972                         struct v4l2_requestbuffers *reqbuf)
 973 {
 974         struct vpif_fh *fh = priv;
 975         struct channel_obj *ch = fh->channel;
 976         struct common_obj *common;
 977         u8 index = 0;
 978         struct vb2_queue *q;
 979         int ret;
 980
 981         vpif_dbg(2, debug, "vpif_reqbufs\n");
 982
 983         /**
 984          * This file handle has not initialized the channel,
 985          * It is not allowed to do settings
 986          */
 987         if ((VPIF_CHANNEL0_VIDEO == ch->channel_id)
 988             || (VPIF_CHANNEL1_VIDEO == ch->channel_id)) {
 989                 if (!fh->initialized) {
 990                         vpif_dbg(1, debug, "Channel Busy\n");
 991                         return -EBUSY;
 992                 }
 993         }
 994
 995         if (V4L2_BUF_TYPE_VIDEO_CAPTURE != reqbuf->type || !vpif_dev)
 996                 return -EINVAL;
 997
 998         index = VPIF_VIDEO_INDEX;
 999
1000         common = &ch->common[index];
1001
1002         if (0 != common->io_usrs)
1003                 return -EBUSY;
1004
1005         /* Initialize videobuf2 queue as per the buffer type */
1006         common->alloc_ctx = vb2_dma_contig_init_ctx(vpif_dev);
1007         if (!common->alloc_ctx) {
1008                 vpif_err("Failed to get the context\n");
1009                 return -EINVAL;
1010         }
1011         q = &common->buffer_queue;
1012         q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1013         q->io_modes = VB2_MMAP | VB2_USERPTR;
1014         q->drv_priv = fh;
1015         q->ops = &video_qops;
1016         q->mem_ops = &vb2_dma_contig_memops;
1017         q->buf_struct_size = sizeof(struct vpif_cap_buffer);
1018
1019         ret = vb2_queue_init(q);
1020         if (ret) {
1021                 vpif_err("vpif_capture: vb2_queue_init() failed\n");
1022                 vb2_dma_contig_cleanup_ctx(common->alloc_ctx);
1023                 return ret;
1024         }
1025         /* Set io allowed member of file handle to TRUE */
1026         fh->io_allowed[index] = 1;
1027         /* Increment io usrs member of channel object to 1 */
1028         common->io_usrs = 1;
1029         /* Store type of memory requested in channel object */
1030         common->memory = reqbuf->memory;
1031         INIT_LIST_HEAD(&common->dma_queue);
1032
1033         /* Allocate buffers */
1034         return vb2_reqbufs(&common->buffer_queue, reqbuf);
1035 }
1036
1037 /**
1038  * vpif_querybuf() - query buffer handler
1039  * @file: file ptr
1040  * @priv: file handle
1041  * @buf: v4l2 buffer structure ptr
1042  */
1043 static int vpif_querybuf(struct file *file, void *priv,
1044                                 struct v4l2_buffer *buf)
1045 {
1046         struct vpif_fh *fh = priv;
1047         struct channel_obj *ch = fh->channel;
1048         struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
1049
1050         vpif_dbg(2, debug, "vpif_querybuf\n");
1051
1052         if (common->fmt.type != buf->type)
1053                 return -EINVAL;
1054
1055         if (common->memory != V4L2_MEMORY_MMAP) {
1056                 vpif_dbg(1, debug, "Invalid memory\n");
1057                 return -EINVAL;
1058         }
1059
1060         return vb2_querybuf(&common->buffer_queue, buf);
1061 }
1062
1063 /**
1064  * vpif_qbuf() - query buffer handler
1065  * @file: file ptr
1066  * @priv: file handle
1067  * @buf: v4l2 buffer structure ptr
1068  */
1069 static int vpif_qbuf(struct file *file, void *priv, struct v4l2_buffer *buf)
1070 {
1071
1072         struct vpif_fh *fh = priv;
1073         struct channel_obj *ch = fh->channel;
1074         struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
1075         struct v4l2_buffer tbuf = *buf;
1076
1077         vpif_dbg(2, debug, "vpif_qbuf\n");
1078
1079         if (common->fmt.type != tbuf.type) {
1080                 vpif_err("invalid buffer type\n");
1081                 return -EINVAL;
1082         }
1083
1084         if (!fh->io_allowed[VPIF_VIDEO_INDEX]) {
1085                 vpif_err("fh io not allowed\n");
1086                 return -EACCES;
1087         }
1088
1089         return vb2_qbuf(&common->buffer_queue, buf);
1090 }
1091
1092 /**
1093  * vpif_dqbuf() - query buffer handler
1094  * @file: file ptr
1095  * @priv: file handle
1096  * @buf: v4l2 buffer structure ptr
1097  */
1098 static int vpif_dqbuf(struct file *file, void *priv, struct v4l2_buffer *buf)
1099 {
1100         struct vpif_fh *fh = priv;
1101         struct channel_obj *ch = fh->channel;
1102         struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
1103
1104         vpif_dbg(2, debug, "vpif_dqbuf\n");
1105
1106         return vb2_dqbuf(&common->buffer_queue, buf,
1107                          (file->f_flags & O_NONBLOCK));
1108 }
1109
1110 /**
1111  * vpif_streamon() - streamon handler
1112  * @file: file ptr
1113  * @priv: file handle
1114  * @buftype: v4l2 buffer type
1115  */
1116 static int vpif_streamon(struct file *file, void *priv,
1117                                 enum v4l2_buf_type buftype)
1118 {
1119
1120         struct vpif_fh *fh = priv;
1121         struct channel_obj *ch = fh->channel;
1122         struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
1123         struct channel_obj *oth_ch = vpif_obj.dev[!ch->channel_id];
1124         struct vpif_params *vpif;
1125         int ret = 0;
1126
1127         vpif_dbg(2, debug, "vpif_streamon\n");
1128
1129         vpif = &ch->vpifparams;
1130
1131         if (buftype != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1132                 vpif_dbg(1, debug, "buffer type not supported\n");
1133                 return -EINVAL;
1134         }
1135
1136         /* If file handle is not allowed IO, return error */
1137         if (!fh->io_allowed[VPIF_VIDEO_INDEX]) {
1138                 vpif_dbg(1, debug, "io not allowed\n");
1139                 return -EACCES;
1140         }
1141
1142         /* If Streaming is already started, return error */
1143         if (common->started) {
1144                 vpif_dbg(1, debug, "channel->started\n");
1145                 return -EBUSY;
1146         }
1147
1148         if ((ch->channel_id == VPIF_CHANNEL0_VIDEO &&
1149             oth_ch->common[VPIF_VIDEO_INDEX].started &&
1150             vpif->std_info.ycmux_mode == 0) ||
1151            ((ch->channel_id == VPIF_CHANNEL1_VIDEO) &&
1152             (2 == oth_ch->common[VPIF_VIDEO_INDEX].started))) {
1153                 vpif_dbg(1, debug, "other channel is being used\n");
1154                 return -EBUSY;
1155         }
1156
1157         ret = vpif_check_format(ch, &common->fmt.fmt.pix, 0);
1158         if (ret)
1159                 return ret;
1160
1161         /* Enable streamon on the sub device */
1162         ret = v4l2_subdev_call(ch->sd, video, s_stream, 1);
1163
1164         if (ret && ret != -ENOIOCTLCMD && ret != -ENODEV) {
1165                 vpif_dbg(1, debug, "stream on failed in subdev\n");
1166                 return ret;
1167         }
1168
1169         /* Call vb2_streamon to start streaming in videobuf2 */
1170         ret = vb2_streamon(&common->buffer_queue, buftype);
1171         if (ret) {
1172                 vpif_dbg(1, debug, "vb2_streamon\n");
1173                 return ret;
1174         }
1175
1176         return ret;
1177 }
1178
1179 /**
1180  * vpif_streamoff() - streamoff handler
1181  * @file: file ptr
1182  * @priv: file handle
1183  * @buftype: v4l2 buffer type
1184  */
1185 static int vpif_streamoff(struct file *file, void *priv,
1186                                 enum v4l2_buf_type buftype)
1187 {
1188
1189         struct vpif_fh *fh = priv;
1190         struct channel_obj *ch = fh->channel;
1191         struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
1192         int ret;
1193
1194         vpif_dbg(2, debug, "vpif_streamoff\n");
1195
1196         if (buftype != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1197                 vpif_dbg(1, debug, "buffer type not supported\n");
1198                 return -EINVAL;
1199         }
1200
1201         /* If io is allowed for this file handle, return error */
1202         if (!fh->io_allowed[VPIF_VIDEO_INDEX]) {
1203                 vpif_dbg(1, debug, "io not allowed\n");
1204                 return -EACCES;
1205         }
1206
1207         /* If streaming is not started, return error */
1208         if (!common->started) {
1209                 vpif_dbg(1, debug, "channel->started\n");
1210                 return -EINVAL;
1211         }
1212
1213         /* disable channel */
1214         if (VPIF_CHANNEL0_VIDEO == ch->channel_id) {
1215                 enable_channel0(0);
1216                 channel0_intr_enable(0);
1217         } else {
1218                 enable_channel1(0);
1219                 channel1_intr_enable(0);
1220         }
1221
1222         common->started = 0;
1223
1224         ret = v4l2_subdev_call(ch->sd, video, s_stream, 0);
1225
1226         if (ret && ret != -ENOIOCTLCMD && ret != -ENODEV)
1227                 vpif_dbg(1, debug, "stream off failed in subdev\n");
1228
1229         return vb2_streamoff(&common->buffer_queue, buftype);
1230 }
1231
1232 /**
1233  * vpif_input_to_subdev() - Maps input to sub device
1234  * @vpif_cfg - global config ptr
1235  * @chan_cfg - channel config ptr
1236  * @input_index - Given input index from application
1237  *
1238  * lookup the sub device information for a given input index.
1239  * we report all the inputs to application. inputs table also
1240  * has sub device name for the each input
1241  */
1242 static int vpif_input_to_subdev(
1243                 struct vpif_capture_config *vpif_cfg,
1244                 struct vpif_capture_chan_config *chan_cfg,
1245                 int input_index)
1246 {
1247         struct vpif_subdev_info *subdev_info;
1248         const char *subdev_name;
1249         int i;
1250
1251         vpif_dbg(2, debug, "vpif_input_to_subdev\n");
1252
1253         subdev_name = chan_cfg->inputs[input_index].subdev_name;
1254         if (subdev_name == NULL)
1255                 return -1;
1256
1257         /* loop through the sub device list to get the sub device info */
1258         for (i = 0; i < vpif_cfg->subdev_count; i++) {
1259                 subdev_info = &vpif_cfg->subdev_info[i];
1260                 if (!strcmp(subdev_info->name, subdev_name))
1261                         return i;
1262         }
1263         return -1;
1264 }
1265
1266 /**
1267  * vpif_set_input() - Select an input
1268  * @vpif_cfg - global config ptr
1269  * @ch - channel
1270  * @_index - Given input index from application
1271  *
1272  * Select the given input.
1273  */
1274 static int vpif_set_input(
1275                 struct vpif_capture_config *vpif_cfg,
1276                 struct channel_obj *ch,
1277                 int index)
1278 {
1279         struct vpif_capture_chan_config *chan_cfg =
1280                         &vpif_cfg->chan_config[ch->channel_id];
1281         struct vpif_subdev_info *subdev_info = NULL;
1282         struct v4l2_subdev *sd = NULL;
1283         u32 input = 0, output = 0;
1284         int sd_index;
1285         int ret;
1286
1287         sd_index = vpif_input_to_subdev(vpif_cfg, chan_cfg, index);
1288         if (sd_index >= 0) {
1289                 sd = vpif_obj.sd[sd_index];
1290                 subdev_info = &vpif_cfg->subdev_info[sd_index];
1291         }
1292
1293         /* first setup input path from sub device to vpif */
1294         if (sd && vpif_cfg->setup_input_path) {
1295                 ret = vpif_cfg->setup_input_path(ch->channel_id,
1296                                        subdev_info->name);
1297                 if (ret < 0) {
1298                         vpif_dbg(1, debug, "couldn't setup input path for the" \
1299                         " sub device %s, for input index %d\n",
1300                         subdev_info->name, index);
1301                         return ret;
1302                 }
1303         }
1304
1305         if (sd) {
1306                 input = chan_cfg->inputs[index].input_route;
1307                 output = chan_cfg->inputs[index].output_route;
1308                 ret = v4l2_subdev_call(sd, video, s_routing,
1309                                 input, output, 0);
1310                 if (ret < 0 && ret != -ENOIOCTLCMD) {
1311                         vpif_dbg(1, debug, "Failed to set input\n");
1312                         return ret;
1313                 }
1314         }
1315         ch->input_idx = index;
1316         ch->sd = sd;
1317         /* copy interface parameters to vpif */
1318         ch->vpifparams.iface = chan_cfg->vpif_if;
1319
1320         /* update tvnorms from the sub device input info */
1321         ch->video_dev->tvnorms = chan_cfg->inputs[index].input.std;
1322         return 0;
1323 }
1324
1325 /**
1326  * vpif_querystd() - querystd handler
1327  * @file: file ptr
1328  * @priv: file handle
1329  * @std_id: ptr to std id
1330  *
1331  * This function is called to detect standard at the selected input
1332  */
1333 static int vpif_querystd(struct file *file, void *priv, v4l2_std_id *std_id)
1334 {
1335         struct vpif_fh *fh = priv;
1336         struct channel_obj *ch = fh->channel;
1337         int ret = 0;
1338
1339         vpif_dbg(2, debug, "vpif_querystd\n");
1340
1341         /* Call querystd function of decoder device */
1342         ret = v4l2_subdev_call(ch->sd, video, querystd, std_id);
1343
1344         if (ret == -ENOIOCTLCMD || ret == -ENODEV)
1345                 return -ENODATA;
1346         if (ret) {
1347                 vpif_dbg(1, debug, "Failed to query standard for sub devices\n");
1348                 return ret;
1349         }
1350
1351         return 0;
1352 }
1353
1354 /**
1355  * vpif_g_std() - get STD handler
1356  * @file: file ptr
1357  * @priv: file handle
1358  * @std_id: ptr to std id
1359  */
1360 static int vpif_g_std(struct file *file, void *priv, v4l2_std_id *std)
1361 {
1362         struct vpif_fh *fh = priv;
1363         struct channel_obj *ch = fh->channel;
1364
1365         vpif_dbg(2, debug, "vpif_g_std\n");
1366
1367         *std = ch->video.stdid;
1368         return 0;
1369 }
1370
1371 /**
1372  * vpif_s_std() - set STD handler
1373  * @file: file ptr
1374  * @priv: file handle
1375  * @std_id: ptr to std id
1376  */
1377 static int vpif_s_std(struct file *file, void *priv, v4l2_std_id *std_id)
1378 {
1379         struct vpif_fh *fh = priv;
1380         struct channel_obj *ch = fh->channel;
1381         struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
1382         int ret = 0;
1383
1384         vpif_dbg(2, debug, "vpif_s_std\n");
1385
1386         if (common->started) {
1387                 vpif_err("streaming in progress\n");
1388                 return -EBUSY;
1389         }
1390
1391         if ((VPIF_CHANNEL0_VIDEO == ch->channel_id) ||
1392             (VPIF_CHANNEL1_VIDEO == ch->channel_id)) {
1393                 if (!fh->initialized) {
1394                         vpif_dbg(1, debug, "Channel Busy\n");
1395                         return -EBUSY;
1396                 }
1397         }
1398
1399         ret = v4l2_prio_check(&ch->prio, fh->prio);
1400         if (0 != ret)
1401                 return ret;
1402
1403         fh->initialized = 1;
1404
1405         /* Call encoder subdevice function to set the standard */
1406         ch->video.stdid = *std_id;
1407         memset(&ch->video.dv_timings, 0, sizeof(ch->video.dv_timings));
1408
1409         /* Get the information about the standard */
1410         if (vpif_update_std_info(ch)) {
1411                 vpif_err("Error getting the standard info\n");
1412                 return -EINVAL;
1413         }
1414
1415         /* Configure the default format information */
1416         vpif_config_format(ch);
1417
1418         /* set standard in the sub device */
1419         ret = v4l2_subdev_call(ch->sd, core, s_std, *std_id);
1420         if (ret && ret != -ENOIOCTLCMD && ret != -ENODEV) {
1421                 vpif_dbg(1, debug, "Failed to set standard for sub devices\n");
1422                 return ret;
1423         }
1424         return 0;
1425 }
1426
1427 /**
1428  * vpif_enum_input() - ENUMINPUT handler
1429  * @file: file ptr
1430  * @priv: file handle
1431  * @input: ptr to input structure
1432  */
1433 static int vpif_enum_input(struct file *file, void *priv,
1434                                 struct v4l2_input *input)
1435 {
1436
1437         struct vpif_capture_config *config = vpif_dev->platform_data;
1438         struct vpif_capture_chan_config *chan_cfg;
1439         struct vpif_fh *fh = priv;
1440         struct channel_obj *ch = fh->channel;
1441
1442         chan_cfg = &config->chan_config[ch->channel_id];
1443
1444         if (input->index >= chan_cfg->input_count) {
1445                 vpif_dbg(1, debug, "Invalid input index\n");
1446                 return -EINVAL;
1447         }
1448
1449         memcpy(input, &chan_cfg->inputs[input->index].input,
1450                 sizeof(*input));
1451         return 0;
1452 }
1453
1454 /**
1455  * vpif_g_input() - Get INPUT handler
1456  * @file: file ptr
1457  * @priv: file handle
1458  * @index: ptr to input index
1459  */
1460 static int vpif_g_input(struct file *file, void *priv, unsigned int *index)
1461 {
1462         struct vpif_fh *fh = priv;
1463         struct channel_obj *ch = fh->channel;
1464
1465         *index = ch->input_idx;
1466         return 0;
1467 }
1468
1469 /**
1470  * vpif_s_input() - Set INPUT handler
1471  * @file: file ptr
1472  * @priv: file handle
1473  * @index: input index
1474  */
1475 static int vpif_s_input(struct file *file, void *priv, unsigned int index)
1476 {
1477         struct vpif_capture_config *config = vpif_dev->platform_data;
1478         struct vpif_capture_chan_config *chan_cfg;
1479         struct vpif_fh *fh = priv;
1480         struct channel_obj *ch = fh->channel;
1481         struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
1482         int ret;
1483
1484         chan_cfg = &config->chan_config[ch->channel_id];
1485
1486         if (index >= chan_cfg->input_count)
1487                 return -EINVAL;
1488
1489         if (common->started) {
1490                 vpif_err("Streaming in progress\n");
1491                 return -EBUSY;
1492         }
1493
1494         if ((VPIF_CHANNEL0_VIDEO == ch->channel_id) ||
1495             (VPIF_CHANNEL1_VIDEO == ch->channel_id)) {
1496                 if (!fh->initialized) {
1497                         vpif_dbg(1, debug, "Channel Busy\n");
1498                         return -EBUSY;
1499                 }
1500         }
1501
1502         ret = v4l2_prio_check(&ch->prio, fh->prio);
1503         if (0 != ret)
1504                 return ret;
1505
1506         fh->initialized = 1;
1507         return vpif_set_input(config, ch, index);
1508 }
1509
1510 /**
1511  * vpif_enum_fmt_vid_cap() - ENUM_FMT handler
1512  * @file: file ptr
1513  * @priv: file handle
1514  * @index: input index
1515  */
1516 static int vpif_enum_fmt_vid_cap(struct file *file, void  *priv,
1517                                         struct v4l2_fmtdesc *fmt)
1518 {
1519         struct vpif_fh *fh = priv;
1520         struct channel_obj *ch = fh->channel;
1521
1522         if (fmt->index != 0) {
1523                 vpif_dbg(1, debug, "Invalid format index\n");
1524                 return -EINVAL;
1525         }
1526
1527         /* Fill in the information about format */
1528         if (ch->vpifparams.iface.if_type == VPIF_IF_RAW_BAYER) {
1529                 fmt->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1530                 strcpy(fmt->description, "Raw Mode -Bayer Pattern GrRBGb");
1531                 fmt->pixelformat = V4L2_PIX_FMT_SBGGR8;
1532         } else {
1533                 fmt->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1534                 strcpy(fmt->description, "YCbCr4:2:2 YC Planar");
1535                 fmt->pixelformat = V4L2_PIX_FMT_YUV422P;
1536         }
1537         return 0;
1538 }
1539
1540 /**
1541  * vpif_try_fmt_vid_cap() - TRY_FMT handler
1542  * @file: file ptr
1543  * @priv: file handle
1544  * @fmt: ptr to v4l2 format structure
1545  */
1546 static int vpif_try_fmt_vid_cap(struct file *file, void *priv,
1547                                 struct v4l2_format *fmt)
1548 {
1549         struct vpif_fh *fh = priv;
1550         struct channel_obj *ch = fh->channel;
1551         struct v4l2_pix_format *pixfmt = &fmt->fmt.pix;
1552
1553         return vpif_check_format(ch, pixfmt, 1);
1554 }
1555
1556
1557 /**
1558  * vpif_g_fmt_vid_cap() - Set INPUT handler
1559  * @file: file ptr
1560  * @priv: file handle
1561  * @fmt: ptr to v4l2 format structure
1562  */
1563 static int vpif_g_fmt_vid_cap(struct file *file, void *priv,
1564                                 struct v4l2_format *fmt)
1565 {
1566         struct vpif_fh *fh = priv;
1567         struct channel_obj *ch = fh->channel;
1568         struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
1569
1570         /* Check the validity of the buffer type */
1571         if (common->fmt.type != fmt->type)
1572                 return -EINVAL;
1573
1574         /* Fill in the information about format */
1575         *fmt = common->fmt;
1576         return 0;
1577 }
1578
1579 /**
1580  * vpif_s_fmt_vid_cap() - Set FMT handler
1581  * @file: file ptr
1582  * @priv: file handle
1583  * @fmt: ptr to v4l2 format structure
1584  */
1585 static int vpif_s_fmt_vid_cap(struct file *file, void *priv,
1586                                 struct v4l2_format *fmt)
1587 {
1588         struct vpif_fh *fh = priv;
1589         struct channel_obj *ch = fh->channel;
1590         struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
1591         struct v4l2_pix_format *pixfmt;
1592         int ret = 0;
1593
1594         vpif_dbg(2, debug, "%s\n", __func__);
1595
1596         /* If streaming is started, return error */
1597         if (common->started) {
1598                 vpif_dbg(1, debug, "Streaming is started\n");
1599                 return -EBUSY;
1600         }
1601
1602         if ((VPIF_CHANNEL0_VIDEO == ch->channel_id) ||
1603             (VPIF_CHANNEL1_VIDEO == ch->channel_id)) {
1604                 if (!fh->initialized) {
1605                         vpif_dbg(1, debug, "Channel Busy\n");
1606                         return -EBUSY;
1607                 }
1608         }
1609
1610         ret = v4l2_prio_check(&ch->prio, fh->prio);
1611         if (0 != ret)
1612                 return ret;
1613
1614         fh->initialized = 1;
1615
1616         pixfmt = &fmt->fmt.pix;
1617         /* Check for valid field format */
1618         ret = vpif_check_format(ch, pixfmt, 0);
1619
1620         if (ret)
1621                 return ret;
1622         /* store the format in the channel object */
1623         common->fmt = *fmt;
1624         return 0;
1625 }
1626
1627 /**
1628  * vpif_querycap() - QUERYCAP handler
1629  * @file: file ptr
1630  * @priv: file handle
1631  * @cap: ptr to v4l2_capability structure
1632  */
1633 static int vpif_querycap(struct file *file, void  *priv,
1634                                 struct v4l2_capability *cap)
1635 {
1636         struct vpif_capture_config *config = vpif_dev->platform_data;
1637
1638         cap->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
1639         cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
1640         snprintf(cap->driver, sizeof(cap->driver), "%s", dev_name(vpif_dev));
1641         snprintf(cap->bus_info, sizeof(cap->bus_info), "platform:%s",
1642                  dev_name(vpif_dev));
1643         strlcpy(cap->card, config->card_name, sizeof(cap->card));
1644
1645         return 0;
1646 }
1647
1648 /**
1649  * vpif_g_priority() - get priority handler
1650  * @file: file ptr
1651  * @priv: file handle
1652  * @prio: ptr to v4l2_priority structure
1653  */
1654 static int vpif_g_priority(struct file *file, void *priv,
1655                            enum v4l2_priority *prio)
1656 {
1657         struct vpif_fh *fh = priv;
1658         struct channel_obj *ch = fh->channel;
1659
1660         *prio = v4l2_prio_max(&ch->prio);
1661
1662         return 0;
1663 }
1664
1665 /**
1666  * vpif_s_priority() - set priority handler
1667  * @file: file ptr
1668  * @priv: file handle
1669  * @prio: ptr to v4l2_priority structure
1670  */
1671 static int vpif_s_priority(struct file *file, void *priv, enum v4l2_priority p)
1672 {
1673         struct vpif_fh *fh = priv;
1674         struct channel_obj *ch = fh->channel;
1675
1676         return v4l2_prio_change(&ch->prio, &fh->prio, p);
1677 }
1678
1679 /**
1680  * vpif_cropcap() - cropcap handler
1681  * @file: file ptr
1682  * @priv: file handle
1683  * @crop: ptr to v4l2_cropcap structure
1684  */
1685 static int vpif_cropcap(struct file *file, void *priv,
1686                         struct v4l2_cropcap *crop)
1687 {
1688         struct vpif_fh *fh = priv;
1689         struct channel_obj *ch = fh->channel;
1690         struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX];
1691
1692         if (V4L2_BUF_TYPE_VIDEO_CAPTURE != crop->type)
1693                 return -EINVAL;
1694
1695         crop->bounds.left = 0;
1696         crop->bounds.top = 0;
1697         crop->bounds.height = common->height;
1698         crop->bounds.width = common->width;
1699         crop->defrect = crop->bounds;
1700         return 0;
1701 }
1702
1703 /**
1704  * vpif_enum_dv_timings() - ENUM_DV_TIMINGS handler
1705  * @file: file ptr
1706  * @priv: file handle
1707  * @timings: input timings
1708  */
1709 static int
1710 vpif_enum_dv_timings(struct file *file, void *priv,
1711                      struct v4l2_enum_dv_timings *timings)
1712 {
1713         struct vpif_fh *fh = priv;
1714         struct channel_obj *ch = fh->channel;
1715         int ret;
1716
1717         ret = v4l2_subdev_call(ch->sd, video, enum_dv_timings, timings);
1718         if (ret == -ENOIOCTLCMD && ret == -ENODEV)
1719                 return -EINVAL;
1720         return ret;
1721 }
1722
1723 /**
1724  * vpif_query_dv_timings() - QUERY_DV_TIMINGS handler
1725  * @file: file ptr
1726  * @priv: file handle
1727  * @timings: input timings
1728  */
1729 static int
1730 vpif_query_dv_timings(struct file *file, void *priv,
1731                       struct v4l2_dv_timings *timings)
1732 {
1733         struct vpif_fh *fh = priv;
1734         struct channel_obj *ch = fh->channel;
1735         int ret;
1736
1737         ret = v4l2_subdev_call(ch->sd, video, query_dv_timings, timings);
1738         if (ret == -ENOIOCTLCMD && ret == -ENODEV)
1739                 return -ENODATA;
1740         return ret;
1741 }
1742
1743 /**
1744  * vpif_s_dv_timings() - S_DV_TIMINGS handler
1745  * @file: file ptr
1746  * @priv: file handle
1747  * @timings: digital video timings
1748  */
1749 static int vpif_s_dv_timings(struct file *file, void *priv,
1750                 struct v4l2_dv_timings *timings)
1751 {
1752         struct vpif_fh *fh = priv;
1753         struct channel_obj *ch = fh->channel;
1754         struct vpif_params *vpifparams = &ch->vpifparams;
1755         struct vpif_channel_config_params *std_info = &vpifparams->std_info;
1756         struct video_obj *vid_ch = &ch->video;
1757         struct v4l2_bt_timings *bt = &vid_ch->dv_timings.bt;
1758         int ret;
1759
1760         if (timings->type != V4L2_DV_BT_656_1120) {
1761                 vpif_dbg(2, debug, "Timing type not defined\n");
1762                 return -EINVAL;
1763         }
1764
1765         /* Configure subdevice timings, if any */
1766         ret = v4l2_subdev_call(ch->sd, video, s_dv_timings, timings);
1767         if (ret == -ENOIOCTLCMD || ret == -ENODEV)
1768                 ret = 0;
1769         if (ret < 0) {
1770                 vpif_dbg(2, debug, "Error setting custom DV timings\n");
1771                 return ret;
1772         }
1773
1774         if (!(timings->bt.width && timings->bt.height &&
1775                                 (timings->bt.hbackporch ||
1776                                  timings->bt.hfrontporch ||
1777                                  timings->bt.hsync) &&
1778                                 timings->bt.vfrontporch &&
1779                                 (timings->bt.vbackporch ||
1780                                  timings->bt.vsync))) {
1781                 vpif_dbg(2, debug, "Timings for width, height, "
1782                                 "horizontal back porch, horizontal sync, "
1783                                 "horizontal front porch, vertical back porch, "
1784                                 "vertical sync and vertical back porch "
1785                                 "must be defined\n");
1786                 return -EINVAL;
1787         }
1788
1789         vid_ch->dv_timings = *timings;
1790
1791         /* Configure video port timings */
1792
1793         std_info->eav2sav = bt->hbackporch + bt->hfrontporch +
1794                 bt->hsync - 8;
1795         std_info->sav2eav = bt->width;
1796
1797         std_info->l1 = 1;
1798         std_info->l3 = bt->vsync + bt->vbackporch + 1;
1799
1800         if (bt->interlaced) {
1801                 if (bt->il_vbackporch || bt->il_vfrontporch || bt->il_vsync) {
1802                         std_info->vsize = bt->height * 2 +
1803                                 bt->vfrontporch + bt->vsync + bt->vbackporch +
1804                                 bt->il_vfrontporch + bt->il_vsync +
1805                                 bt->il_vbackporch;
1806                         std_info->l5 = std_info->vsize/2 -
1807                                 (bt->vfrontporch - 1);
1808                         std_info->l7 = std_info->vsize/2 + 1;
1809                         std_info->l9 = std_info->l7 + bt->il_vsync +
1810                                 bt->il_vbackporch + 1;
1811                         std_info->l11 = std_info->vsize -
1812                                 (bt->il_vfrontporch - 1);
1813                 } else {
1814                         vpif_dbg(2, debug, "Required timing values for "
1815                                         "interlaced BT format missing\n");
1816                         return -EINVAL;
1817                 }
1818         } else {
1819                 std_info->vsize = bt->height + bt->vfrontporch +
1820                         bt->vsync + bt->vbackporch;
1821                 std_info->l5 = std_info->vsize - (bt->vfrontporch - 1);
1822         }
1823         strncpy(std_info->name, "Custom timings BT656/1120", VPIF_MAX_NAME);
1824         std_info->width = bt->width;
1825         std_info->height = bt->height;
1826         std_info->frm_fmt = bt->interlaced ? 0 : 1;
1827         std_info->ycmux_mode = 0;
1828         std_info->capture_format = 0;
1829         std_info->vbi_supported = 0;
1830         std_info->hd_sd = 1;
1831         std_info->stdid = 0;
1832
1833         vid_ch->stdid = 0;
1834         return 0;
1835 }
1836
1837 /**
1838  * vpif_g_dv_timings() - G_DV_TIMINGS handler
1839  * @file: file ptr
1840  * @priv: file handle
1841  * @timings: digital video timings
1842  */
1843 static int vpif_g_dv_timings(struct file *file, void *priv,
1844                 struct v4l2_dv_timings *timings)
1845 {
1846         struct vpif_fh *fh = priv;
1847         struct channel_obj *ch = fh->channel;
1848         struct video_obj *vid_ch = &ch->video;
1849
1850         *timings = vid_ch->dv_timings;
1851
1852         return 0;
1853 }
1854
1855 /*
1856  * vpif_g_chip_ident() - Identify the chip
1857  * @file: file ptr
1858  * @priv: file handle
1859  * @chip: chip identity
1860  *
1861  * Returns zero or -EINVAL if read operations fails.
1862  */
1863 static int vpif_g_chip_ident(struct file *file, void *priv,
1864                 struct v4l2_dbg_chip_ident *chip)
1865 {
1866         chip->ident = V4L2_IDENT_NONE;
1867         chip->revision = 0;
1868         if (chip->match.type != V4L2_CHIP_MATCH_I2C_DRIVER &&
1869                         chip->match.type != V4L2_CHIP_MATCH_I2C_ADDR) {
1870                 vpif_dbg(2, debug, "match_type is invalid.\n");
1871                 return -EINVAL;
1872         }
1873
1874         return v4l2_device_call_until_err(&vpif_obj.v4l2_dev, 0, core,
1875                         g_chip_ident, chip);
1876 }
1877
1878 #ifdef CONFIG_VIDEO_ADV_DEBUG
1879 /*
1880  * vpif_dbg_g_register() - Read register
1881  * @file: file ptr
1882  * @priv: file handle
1883  * @reg: register to be read
1884  *
1885  * Debugging only
1886  * Returns zero or -EINVAL if read operations fails.
1887  */
1888 static int vpif_dbg_g_register(struct file *file, void *priv,
1889                 struct v4l2_dbg_register *reg){
1890         struct vpif_fh *fh = priv;
1891         struct channel_obj *ch = fh->channel;
1892
1893         return v4l2_subdev_call(ch->sd, core, g_register, reg);
1894 }
1895
1896 /*
1897  * vpif_dbg_s_register() - Write to register
1898  * @file: file ptr
1899  * @priv: file handle
1900  * @reg: register to be modified
1901  *
1902  * Debugging only
1903  * Returns zero or -EINVAL if write operations fails.
1904  */
1905 static int vpif_dbg_s_register(struct file *file, void *priv,
1906                 struct v4l2_dbg_register *reg){
1907         struct vpif_fh *fh = priv;
1908         struct channel_obj *ch = fh->channel;
1909
1910         return v4l2_subdev_call(ch->sd, core, s_register, reg);
1911 }
1912 #endif
1913
1914 /*
1915  * vpif_log_status() - Status information
1916  * @file: file ptr
1917  * @priv: file handle
1918  *
1919  * Returns zero.
1920  */
1921 static int vpif_log_status(struct file *filep, void *priv)
1922 {
1923         /* status for sub devices */
1924         v4l2_device_call_all(&vpif_obj.v4l2_dev, 0, core, log_status);
1925
1926         return 0;
1927 }
1928
1929 /* vpif capture ioctl operations */
1930 static const struct v4l2_ioctl_ops vpif_ioctl_ops = {
1931         .vidioc_querycap                = vpif_querycap,
1932         .vidioc_g_priority              = vpif_g_priority,
1933         .vidioc_s_priority              = vpif_s_priority,
1934         .vidioc_enum_fmt_vid_cap        = vpif_enum_fmt_vid_cap,
1935         .vidioc_g_fmt_vid_cap           = vpif_g_fmt_vid_cap,
1936         .vidioc_s_fmt_vid_cap           = vpif_s_fmt_vid_cap,
1937         .vidioc_try_fmt_vid_cap         = vpif_try_fmt_vid_cap,
1938         .vidioc_enum_input              = vpif_enum_input,
1939         .vidioc_s_input                 = vpif_s_input,
1940         .vidioc_g_input                 = vpif_g_input,
1941         .vidioc_reqbufs                 = vpif_reqbufs,
1942         .vidioc_querybuf                = vpif_querybuf,
1943         .vidioc_querystd                = vpif_querystd,
1944         .vidioc_s_std                   = vpif_s_std,
1945         .vidioc_g_std                   = vpif_g_std,
1946         .vidioc_qbuf                    = vpif_qbuf,
1947         .vidioc_dqbuf                   = vpif_dqbuf,
1948         .vidioc_streamon                = vpif_streamon,
1949         .vidioc_streamoff               = vpif_streamoff,
1950         .vidioc_cropcap                 = vpif_cropcap,
1951         .vidioc_enum_dv_timings         = vpif_enum_dv_timings,
1952         .vidioc_query_dv_timings        = vpif_query_dv_timings,
1953         .vidioc_s_dv_timings            = vpif_s_dv_timings,
1954         .vidioc_g_dv_timings            = vpif_g_dv_timings,
1955         .vidioc_g_chip_ident            = vpif_g_chip_ident,
1956 #ifdef CONFIG_VIDEO_ADV_DEBUG
1957         .vidioc_g_register              = vpif_dbg_g_register,
1958         .vidioc_s_register              = vpif_dbg_s_register,
1959 #endif
1960         .vidioc_log_status              = vpif_log_status,
1961 };
1962
1963 /* vpif file operations */
1964 static struct v4l2_file_operations vpif_fops = {
1965         .owner = THIS_MODULE,
1966         .open = vpif_open,
1967         .release = vpif_release,
1968         .unlocked_ioctl = video_ioctl2,
1969         .mmap = vpif_mmap,
1970         .poll = vpif_poll
1971 };
1972
1973 /* vpif video template */
1974 static struct video_device vpif_video_template = {
1975         .name           = "vpif",
1976         .fops           = &vpif_fops,
1977         .minor          = -1,
1978         .ioctl_ops      = &vpif_ioctl_ops,
1979 };
1980
1981 /**
1982  * initialize_vpif() - Initialize vpif data structures
1983  *
1984  * Allocate memory for data structures and initialize them
1985  */
1986 static int initialize_vpif(void)
1987 {
1988         int err = 0, i, j;
1989         int free_channel_objects_index;
1990
1991         /* Default number of buffers should be 3 */
1992         if ((ch0_numbuffers > 0) &&
1993             (ch0_numbuffers < config_params.min_numbuffers))
1994                 ch0_numbuffers = config_params.min_numbuffers;
1995         if ((ch1_numbuffers > 0) &&
1996             (ch1_numbuffers < config_params.min_numbuffers))
1997                 ch1_numbuffers = config_params.min_numbuffers;
1998
1999         /* Set buffer size to min buffers size if it is invalid */
2000         if (ch0_bufsize < config_params.min_bufsize[VPIF_CHANNEL0_VIDEO])
2001                 ch0_bufsize =
2002                     config_params.min_bufsize[VPIF_CHANNEL0_VIDEO];
2003         if (ch1_bufsize < config_params.min_bufsize[VPIF_CHANNEL1_VIDEO])
2004                 ch1_bufsize =
2005                     config_params.min_bufsize[VPIF_CHANNEL1_VIDEO];
2006
2007         config_params.numbuffers[VPIF_CHANNEL0_VIDEO] = ch0_numbuffers;
2008         config_params.numbuffers[VPIF_CHANNEL1_VIDEO] = ch1_numbuffers;
2009         if (ch0_numbuffers) {
2010                 config_params.channel_bufsize[VPIF_CHANNEL0_VIDEO]
2011                     = ch0_bufsize;
2012         }
2013         if (ch1_numbuffers) {
2014                 config_params.channel_bufsize[VPIF_CHANNEL1_VIDEO]
2015                     = ch1_bufsize;
2016         }
2017
2018         /* Allocate memory for six channel objects */
2019         for (i = 0; i < VPIF_CAPTURE_MAX_DEVICES; i++) {
2020                 vpif_obj.dev[i] =
2021                     kzalloc(sizeof(*vpif_obj.dev[i]), GFP_KERNEL);
2022                 /* If memory allocation fails, return error */
2023                 if (!vpif_obj.dev[i]) {
2024                         free_channel_objects_index = i;
2025                         err = -ENOMEM;
2026                         goto vpif_init_free_channel_objects;
2027                 }
2028         }
2029         return 0;
2030
2031 vpif_init_free_channel_objects:
2032         for (j = 0; j < free_channel_objects_index; j++)
2033                 kfree(vpif_obj.dev[j]);
2034         return err;
2035 }
2036
2037 /**
2038  * vpif_probe : This function probes the vpif capture driver
2039  * @pdev: platform device pointer
2040  *
2041  * This creates device entries by register itself to the V4L2 driver and
2042  * initializes fields of each channel objects
2043  */
2044 static __init int vpif_probe(struct platform_device *pdev)
2045 {
2046         struct vpif_subdev_info *subdevdata;
2047         struct vpif_capture_config *config;
2048         int i, j, k, err;
2049         int res_idx = 0;
2050         struct i2c_adapter *i2c_adap;
2051         struct channel_obj *ch;
2052         struct common_obj *common;
2053         struct video_device *vfd;
2054         struct resource *res;
2055         int subdev_count;
2056         size_t size;
2057
2058         vpif_dev = &pdev->dev;
2059
2060         err = initialize_vpif();
2061         if (err) {
2062                 v4l2_err(vpif_dev->driver, "Error initializing vpif\n");
2063                 return err;
2064         }
2065
2066         err = v4l2_device_register(vpif_dev, &vpif_obj.v4l2_dev);
2067         if (err) {
2068                 v4l2_err(vpif_dev->driver, "Error registering v4l2 device\n");
2069                 return err;
2070         }
2071
2072         while ((res = platform_get_resource(pdev, IORESOURCE_IRQ, res_idx))) {
2073                 for (i = res->start; i <= res->end; i++) {
2074                         if (request_irq(i, vpif_channel_isr, IRQF_SHARED,
2075                                         "VPIF_Capture", (void *)
2076                                         (&vpif_obj.dev[res_idx]->channel_id))) {
2077                                 err = -EBUSY;
2078                                 for (j = 0; j < i; j++)
2079                                         free_irq(j, (void *)
2080                                         (&vpif_obj.dev[res_idx]->channel_id));
2081                                 goto vpif_int_err;
2082                         }
2083                 }
2084                 res_idx++;
2085         }
2086
2087         for (i = 0; i < VPIF_CAPTURE_MAX_DEVICES; i++) {
2088                 /* Get the pointer to the channel object */
2089                 ch = vpif_obj.dev[i];
2090                 /* Allocate memory for video device */
2091                 vfd = video_device_alloc();
2092                 if (NULL == vfd) {
2093                         for (j = 0; j < i; j++) {
2094                                 ch = vpif_obj.dev[j];
2095                                 video_device_release(ch->video_dev);
2096                         }
2097                         err = -ENOMEM;
2098                         goto vpif_int_err;
2099                 }
2100
2101                 /* Initialize field of video device */
2102                 *vfd = vpif_video_template;
2103                 vfd->v4l2_dev = &vpif_obj.v4l2_dev;
2104                 vfd->release = video_device_release;
2105                 snprintf(vfd->name, sizeof(vfd->name),
2106                          "VPIF_Capture_DRIVER_V%s",
2107                          VPIF_CAPTURE_VERSION);
2108                 /* Set video_dev to the video device */
2109                 ch->video_dev = vfd;
2110         }
2111
2112         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
2113         if (res) {
2114                 size = resource_size(res);
2115                 /* The resources are divided into two equal memory and when we
2116                  * have HD output we can add them together
2117                  */
2118                 for (j = 0; j < VPIF_CAPTURE_MAX_DEVICES; j++) {
2119                         ch = vpif_obj.dev[j];
2120                         ch->channel_id = j;
2121                         /* only enabled if second resource exists */
2122                         config_params.video_limit[ch->channel_id] = 0;
2123                         if (size)
2124                                 config_params.video_limit[ch->channel_id] =
2125                                                                         size/2;
2126                 }
2127         }
2128
2129         i2c_adap = i2c_get_adapter(1);
2130         config = pdev->dev.platform_data;
2131
2132         subdev_count = config->subdev_count;
2133         vpif_obj.sd = kzalloc(sizeof(struct v4l2_subdev *) * subdev_count,
2134                                 GFP_KERNEL);
2135         if (vpif_obj.sd == NULL) {
2136                 vpif_err("unable to allocate memory for subdevice pointers\n");
2137                 err = -ENOMEM;
2138                 goto vpif_sd_error;
2139         }
2140
2141         for (i = 0; i < subdev_count; i++) {
2142                 subdevdata = &config->subdev_info[i];
2143                 vpif_obj.sd[i] =
2144                         v4l2_i2c_new_subdev_board(&vpif_obj.v4l2_dev,
2145                                                   i2c_adap,
2146                                                   &subdevdata->board_info,
2147                                                   NULL);
2148
2149                 if (!vpif_obj.sd[i]) {
2150                         vpif_err("Error registering v4l2 subdevice\n");
2151                         goto probe_subdev_out;
2152                 }
2153                 v4l2_info(&vpif_obj.v4l2_dev, "registered sub device %s\n",
2154                           subdevdata->name);
2155         }
2156
2157         for (j = 0; j < VPIF_CAPTURE_MAX_DEVICES; j++) {
2158                 ch = vpif_obj.dev[j];
2159                 ch->channel_id = j;
2160                 common = &(ch->common[VPIF_VIDEO_INDEX]);
2161                 spin_lock_init(&common->irqlock);
2162                 mutex_init(&common->lock);
2163                 ch->video_dev->lock = &common->lock;
2164                 /* Initialize prio member of channel object */
2165                 v4l2_prio_init(&ch->prio);
2166                 video_set_drvdata(ch->video_dev, ch);
2167
2168                 /* select input 0 */
2169                 err = vpif_set_input(config, ch, 0);
2170                 if (err)
2171                         goto probe_out;
2172
2173                 err = video_register_device(ch->video_dev,
2174                                             VFL_TYPE_GRABBER, (j ? 1 : 0));
2175                 if (err)
2176                         goto probe_out;
2177         }
2178         v4l2_info(&vpif_obj.v4l2_dev, "VPIF capture driver initialized\n");
2179         return 0;
2180
2181 probe_out:
2182         for (k = 0; k < j; k++) {
2183                 /* Get the pointer to the channel object */
2184                 ch = vpif_obj.dev[k];
2185                 /* Unregister video device */
2186                 video_unregister_device(ch->video_dev);
2187         }
2188 probe_subdev_out:
2189         /* free sub devices memory */
2190         kfree(vpif_obj.sd);
2191
2192 vpif_sd_error:
2193         for (i = 0; i < VPIF_CAPTURE_MAX_DEVICES; i++) {
2194                 ch = vpif_obj.dev[i];
2195                 /* Note: does nothing if ch->video_dev == NULL */
2196                 video_device_release(ch->video_dev);
2197         }
2198 vpif_int_err:
2199         v4l2_device_unregister(&vpif_obj.v4l2_dev);
2200         for (i = 0; i < res_idx; i++) {
2201                 res = platform_get_resource(pdev, IORESOURCE_IRQ, i);
2202                 for (j = res->start; j <= res->end; j++)
2203                         free_irq(j, (void *)(&vpif_obj.dev[i]->channel_id));
2204         }
2205         return err;
2206 }
2207
2208 /**
2209  * vpif_remove() - driver remove handler
2210  * @device: ptr to platform device structure
2211  *
2212  * The vidoe device is unregistered
2213  */
2214 static int vpif_remove(struct platform_device *device)
2215 {
2216         int i;
2217         struct channel_obj *ch;
2218
2219         v4l2_device_unregister(&vpif_obj.v4l2_dev);
2220
2221         /* un-register device */
2222         for (i = 0; i < VPIF_CAPTURE_MAX_DEVICES; i++) {
2223                 /* Get the pointer to the channel object */
2224                 ch = vpif_obj.dev[i];
2225                 /* Unregister video device */
2226                 video_unregister_device(ch->video_dev);
2227         }
2228         return 0;
2229 }
2230
2231 #ifdef CONFIG_PM
2232 /**
2233  * vpif_suspend: vpif device suspend
2234  */
2235 static int vpif_suspend(struct device *dev)
2236 {
2237
2238         struct common_obj *common;
2239         struct channel_obj *ch;
2240         int i;
2241
2242         for (i = 0; i < VPIF_CAPTURE_MAX_DEVICES; i++) {
2243                 /* Get the pointer to the channel object */
2244                 ch = vpif_obj.dev[i];
2245                 common = &ch->common[VPIF_VIDEO_INDEX];
2246                 mutex_lock(&common->lock);
2247                 if (ch->usrs && common->io_usrs) {
2248                         /* Disable channel */
2249                         if (ch->channel_id == VPIF_CHANNEL0_VIDEO) {
2250                                 enable_channel0(0);
2251                                 channel0_intr_enable(0);
2252                         }
2253                         if (ch->channel_id == VPIF_CHANNEL1_VIDEO ||
2254                             common->started == 2) {
2255                                 enable_channel1(0);
2256                                 channel1_intr_enable(0);
2257                         }
2258                 }
2259                 mutex_unlock(&common->lock);
2260         }
2261
2262         return 0;
2263 }
2264
2265 /*
2266  * vpif_resume: vpif device suspend
2267  */
2268 static int vpif_resume(struct device *dev)
2269 {
2270         struct common_obj *common;
2271         struct channel_obj *ch;
2272         int i;
2273
2274         for (i = 0; i < VPIF_CAPTURE_MAX_DEVICES; i++) {
2275                 /* Get the pointer to the channel object */
2276                 ch = vpif_obj.dev[i];
2277                 common = &ch->common[VPIF_VIDEO_INDEX];
2278                 mutex_lock(&common->lock);
2279                 if (ch->usrs && common->io_usrs) {
2280                         /* Disable channel */
2281                         if (ch->channel_id == VPIF_CHANNEL0_VIDEO) {
2282                                 enable_channel0(1);
2283                                 channel0_intr_enable(1);
2284                         }
2285                         if (ch->channel_id == VPIF_CHANNEL1_VIDEO ||
2286                             common->started == 2) {
2287                                 enable_channel1(1);
2288                                 channel1_intr_enable(1);
2289                         }
2290                 }
2291                 mutex_unlock(&common->lock);
2292         }
2293
2294         return 0;
2295 }
2296
2297 static const struct dev_pm_ops vpif_dev_pm_ops = {
2298         .suspend = vpif_suspend,
2299         .resume = vpif_resume,
2300 };
2301
2302 #define vpif_pm_ops (&vpif_dev_pm_ops)
2303 #else
2304 #define vpif_pm_ops NULL
2305 #endif
2306
2307 static __refdata struct platform_driver vpif_driver = {
2308         .driver = {
2309                 .name   = "vpif_capture",
2310                 .owner  = THIS_MODULE,
2311                 .pm     = vpif_pm_ops,
2312         },
2313         .probe = vpif_probe,
2314         .remove = vpif_remove,
2315 };
2316
2317 /**
2318  * vpif_init: initialize the vpif driver
2319  *
2320  * This function registers device and driver to the kernel, requests irq
2321  * handler and allocates memory
2322  * for channel objects
2323  */
2324 static __init int vpif_init(void)
2325 {
2326         return platform_driver_register(&vpif_driver);
2327 }
2328
2329 /**
2330  * vpif_cleanup : This function clean up the vpif capture resources
2331  *
2332  * This will un-registers device and driver to the kernel, frees
2333  * requested irq handler and de-allocates memory allocated for channel
2334  * objects.
2335  */
2336 static void vpif_cleanup(void)
2337 {
2338         struct platform_device *pdev;
2339         struct resource *res;
2340         int irq_num;
2341         int i = 0;
2342
2343         pdev = container_of(vpif_dev, struct platform_device, dev);
2344         while ((res = platform_get_resource(pdev, IORESOURCE_IRQ, i))) {
2345                 for (irq_num = res->start; irq_num <= res->end; irq_num++)
2346                         free_irq(irq_num,
2347                                  (void *)(&vpif_obj.dev[i]->channel_id));
2348                 i++;
2349         }
2350
2351         platform_driver_unregister(&vpif_driver);
2352
2353         kfree(vpif_obj.sd);
2354         for (i = 0; i < VPIF_CAPTURE_MAX_DEVICES; i++)
2355                 kfree(vpif_obj.dev[i]);
2356 }
2357
2358 /* Function for module initialization and cleanup */
2359 module_init(vpif_init);
2360 module_exit(vpif_cleanup);