1/* 2 * Copyright (C) 2009 Texas Instruments Inc 3 * Copyright (C) 2014 Lad, Prabhakar <prabhakar.csengg@gmail.com> 4 * 5 * This program is free software; you can redistribute it and/or modify 6 * it under the terms of the GNU General Public License as published by 7 * the Free Software Foundation; either version 2 of the License, or 8 * (at your option) any later version. 9 * 10 * This program is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * GNU General Public License for more details. 14 * 15 * You should have received a copy of the GNU General Public License 16 * along with this program; if not, write to the Free Software 17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 18 * 19 * TODO : add support for VBI & HBI data service 20 * add static buffer allocation 21 */ 22 23#include <linux/module.h> 24#include <linux/interrupt.h> 25#include <linux/platform_device.h> 26#include <linux/slab.h> 27 28#include <media/v4l2-ioctl.h> 29 30#include "vpif.h" 31#include "vpif_capture.h" 32 33MODULE_DESCRIPTION("TI DaVinci VPIF Capture driver"); 34MODULE_LICENSE("GPL"); 35MODULE_VERSION(VPIF_CAPTURE_VERSION); 36 37#define vpif_err(fmt, arg...) v4l2_err(&vpif_obj.v4l2_dev, fmt, ## arg) 38#define vpif_dbg(level, debug, fmt, arg...) \ 39 v4l2_dbg(level, debug, &vpif_obj.v4l2_dev, fmt, ## arg) 40 41static int debug = 1; 42 43module_param(debug, int, 0644); 44 45MODULE_PARM_DESC(debug, "Debug level 0-1"); 46 47#define VPIF_DRIVER_NAME "vpif_capture" 48 49/* global variables */ 50static struct vpif_device vpif_obj = { {NULL} }; 51static struct device *vpif_dev; 52static void vpif_calculate_offsets(struct channel_obj *ch); 53static void vpif_config_addr(struct channel_obj *ch, int muxmode); 54 55static u8 channel_first_int[VPIF_NUMBER_OF_OBJECTS][2] = { {1, 1} }; 56 57/* Is set to 1 in case of SDTV formats, 2 in case of HDTV formats. */ 58static int ycmux_mode; 59 60static inline struct vpif_cap_buffer *to_vpif_buffer(struct vb2_buffer *vb) 61{ 62 return container_of(vb, struct vpif_cap_buffer, vb); 63} 64 65/** 66 * vpif_buffer_prepare : callback function for buffer prepare 67 * @vb: ptr to vb2_buffer 68 * 69 * This is the callback function for buffer prepare when vb2_qbuf() 70 * function is called. The buffer is prepared and user space virtual address 71 * or user address is converted into physical address 72 */ 73static int vpif_buffer_prepare(struct vb2_buffer *vb) 74{ 75 struct vb2_queue *q = vb->vb2_queue; 76 struct channel_obj *ch = vb2_get_drv_priv(q); 77 struct common_obj *common; 78 unsigned long addr; 79 80 vpif_dbg(2, debug, "vpif_buffer_prepare\n"); 81 82 common = &ch->common[VPIF_VIDEO_INDEX]; 83 84 vb2_set_plane_payload(vb, 0, common->fmt.fmt.pix.sizeimage); 85 if (vb2_get_plane_payload(vb, 0) > vb2_plane_size(vb, 0)) 86 return -EINVAL; 87 88 vb->v4l2_buf.field = common->fmt.fmt.pix.field; 89 90 addr = vb2_dma_contig_plane_dma_addr(vb, 0); 91 if (!IS_ALIGNED((addr + common->ytop_off), 8) || 92 !IS_ALIGNED((addr + common->ybtm_off), 8) || 93 !IS_ALIGNED((addr + common->ctop_off), 8) || 94 !IS_ALIGNED((addr + common->cbtm_off), 8)) { 95 vpif_dbg(1, debug, "offset is not aligned\n"); 96 return -EINVAL; 97 } 98 99 return 0; 100} 101 102/** 103 * vpif_buffer_queue_setup : Callback function for buffer setup. 104 * @vq: vb2_queue ptr 105 * @fmt: v4l2 format 106 * @nbuffers: ptr to number of buffers requested by application 107 * @nplanes:: contains number of distinct video planes needed to hold a frame 108 * @sizes[]: contains the size (in bytes) of each plane. 109 * @alloc_ctxs: ptr to allocation context 110 * 111 * This callback function is called when reqbuf() is called to adjust 112 * the buffer count and buffer size 113 */ 114static int vpif_buffer_queue_setup(struct vb2_queue *vq, 115 const struct v4l2_format *fmt, 116 unsigned int *nbuffers, unsigned int *nplanes, 117 unsigned int sizes[], void *alloc_ctxs[]) 118{ 119 struct channel_obj *ch = vb2_get_drv_priv(vq); 120 struct common_obj *common; 121 122 common = &ch->common[VPIF_VIDEO_INDEX]; 123 124 vpif_dbg(2, debug, "vpif_buffer_setup\n"); 125 126 if (fmt && fmt->fmt.pix.sizeimage < common->fmt.fmt.pix.sizeimage) 127 return -EINVAL; 128 129 if (vq->num_buffers + *nbuffers < 3) 130 *nbuffers = 3 - vq->num_buffers; 131 132 *nplanes = 1; 133 sizes[0] = fmt ? fmt->fmt.pix.sizeimage : common->fmt.fmt.pix.sizeimage; 134 alloc_ctxs[0] = common->alloc_ctx; 135 136 /* Calculate the offset for Y and C data in the buffer */ 137 vpif_calculate_offsets(ch); 138 139 return 0; 140} 141 142/** 143 * vpif_buffer_queue : Callback function to add buffer to DMA queue 144 * @vb: ptr to vb2_buffer 145 */ 146static void vpif_buffer_queue(struct vb2_buffer *vb) 147{ 148 struct channel_obj *ch = vb2_get_drv_priv(vb->vb2_queue); 149 struct vpif_cap_buffer *buf = to_vpif_buffer(vb); 150 struct common_obj *common; 151 unsigned long flags; 152 153 common = &ch->common[VPIF_VIDEO_INDEX]; 154 155 vpif_dbg(2, debug, "vpif_buffer_queue\n"); 156 157 spin_lock_irqsave(&common->irqlock, flags); 158 /* add the buffer to the DMA queue */ 159 list_add_tail(&buf->list, &common->dma_queue); 160 spin_unlock_irqrestore(&common->irqlock, flags); 161} 162 163/** 164 * vpif_start_streaming : Starts the DMA engine for streaming 165 * @vb: ptr to vb2_buffer 166 * @count: number of buffers 167 */ 168static int vpif_start_streaming(struct vb2_queue *vq, unsigned int count) 169{ 170 struct vpif_capture_config *vpif_config_data = 171 vpif_dev->platform_data; 172 struct channel_obj *ch = vb2_get_drv_priv(vq); 173 struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX]; 174 struct vpif_params *vpif = &ch->vpifparams; 175 struct vpif_cap_buffer *buf, *tmp; 176 unsigned long addr, flags; 177 int ret; 178 179 spin_lock_irqsave(&common->irqlock, flags); 180 181 /* Initialize field_id */ 182 ch->field_id = 0; 183 184 /* configure 1 or 2 channel mode */ 185 if (vpif_config_data->setup_input_channel_mode) { 186 ret = vpif_config_data-> 187 setup_input_channel_mode(vpif->std_info.ycmux_mode); 188 if (ret < 0) { 189 vpif_dbg(1, debug, "can't set vpif channel mode\n"); 190 goto err; 191 } 192 } 193 194 ret = v4l2_subdev_call(ch->sd, video, s_stream, 1); 195 if (ret && ret != -ENOIOCTLCMD && ret != -ENODEV) { 196 vpif_dbg(1, debug, "stream on failed in subdev\n"); 197 goto err; 198 } 199 200 /* Call vpif_set_params function to set the parameters and addresses */ 201 ret = vpif_set_video_params(vpif, ch->channel_id); 202 if (ret < 0) { 203 vpif_dbg(1, debug, "can't set video params\n"); 204 goto err; 205 } 206 207 ycmux_mode = ret; 208 vpif_config_addr(ch, ret); 209 210 /* Get the next frame from the buffer queue */ 211 common->cur_frm = common->next_frm = list_entry(common->dma_queue.next, 212 struct vpif_cap_buffer, list); 213 /* Remove buffer from the buffer queue */ 214 list_del(&common->cur_frm->list); 215 spin_unlock_irqrestore(&common->irqlock, flags); 216 217 addr = vb2_dma_contig_plane_dma_addr(&common->cur_frm->vb, 0); 218 219 common->set_addr(addr + common->ytop_off, 220 addr + common->ybtm_off, 221 addr + common->ctop_off, 222 addr + common->cbtm_off); 223 224 /** 225 * Set interrupt for both the fields in VPIF Register enable channel in 226 * VPIF register 227 */ 228 channel_first_int[VPIF_VIDEO_INDEX][ch->channel_id] = 1; 229 if (VPIF_CHANNEL0_VIDEO == ch->channel_id) { 230 channel0_intr_assert(); 231 channel0_intr_enable(1); 232 enable_channel0(1); 233 } 234 if (VPIF_CHANNEL1_VIDEO == ch->channel_id || 235 ycmux_mode == 2) { 236 channel1_intr_assert(); 237 channel1_intr_enable(1); 238 enable_channel1(1); 239 } 240 241 return 0; 242 243err: 244 list_for_each_entry_safe(buf, tmp, &common->dma_queue, list) { 245 list_del(&buf->list); 246 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_QUEUED); 247 } 248 spin_unlock_irqrestore(&common->irqlock, flags); 249 250 return ret; 251} 252 253/** 254 * vpif_stop_streaming : Stop the DMA engine 255 * @vq: ptr to vb2_queue 256 * 257 * This callback stops the DMA engine and any remaining buffers 258 * in the DMA queue are released. 259 */ 260static void vpif_stop_streaming(struct vb2_queue *vq) 261{ 262 struct channel_obj *ch = vb2_get_drv_priv(vq); 263 struct common_obj *common; 264 unsigned long flags; 265 int ret; 266 267 common = &ch->common[VPIF_VIDEO_INDEX]; 268 269 /* Disable channel as per its device type and channel id */ 270 if (VPIF_CHANNEL0_VIDEO == ch->channel_id) { 271 enable_channel0(0); 272 channel0_intr_enable(0); 273 } 274 if (VPIF_CHANNEL1_VIDEO == ch->channel_id || 275 ycmux_mode == 2) { 276 enable_channel1(0); 277 channel1_intr_enable(0); 278 } 279 280 ycmux_mode = 0; 281 282 ret = v4l2_subdev_call(ch->sd, video, s_stream, 0); 283 if (ret && ret != -ENOIOCTLCMD && ret != -ENODEV) 284 vpif_dbg(1, debug, "stream off failed in subdev\n"); 285 286 /* release all active buffers */ 287 spin_lock_irqsave(&common->irqlock, flags); 288 if (common->cur_frm == common->next_frm) { 289 vb2_buffer_done(&common->cur_frm->vb, VB2_BUF_STATE_ERROR); 290 } else { 291 if (common->cur_frm != NULL) 292 vb2_buffer_done(&common->cur_frm->vb, 293 VB2_BUF_STATE_ERROR); 294 if (common->next_frm != NULL) 295 vb2_buffer_done(&common->next_frm->vb, 296 VB2_BUF_STATE_ERROR); 297 } 298 299 while (!list_empty(&common->dma_queue)) { 300 common->next_frm = list_entry(common->dma_queue.next, 301 struct vpif_cap_buffer, list); 302 list_del(&common->next_frm->list); 303 vb2_buffer_done(&common->next_frm->vb, VB2_BUF_STATE_ERROR); 304 } 305 spin_unlock_irqrestore(&common->irqlock, flags); 306} 307 308static struct vb2_ops video_qops = { 309 .queue_setup = vpif_buffer_queue_setup, 310 .buf_prepare = vpif_buffer_prepare, 311 .start_streaming = vpif_start_streaming, 312 .stop_streaming = vpif_stop_streaming, 313 .buf_queue = vpif_buffer_queue, 314 .wait_prepare = vb2_ops_wait_prepare, 315 .wait_finish = vb2_ops_wait_finish, 316}; 317 318/** 319 * vpif_process_buffer_complete: process a completed buffer 320 * @common: ptr to common channel object 321 * 322 * This function time stamp the buffer and mark it as DONE. It also 323 * wake up any process waiting on the QUEUE and set the next buffer 324 * as current 325 */ 326static void vpif_process_buffer_complete(struct common_obj *common) 327{ 328 v4l2_get_timestamp(&common->cur_frm->vb.v4l2_buf.timestamp); 329 vb2_buffer_done(&common->cur_frm->vb, 330 VB2_BUF_STATE_DONE); 331 /* Make curFrm pointing to nextFrm */ 332 common->cur_frm = common->next_frm; 333} 334 335/** 336 * vpif_schedule_next_buffer: set next buffer address for capture 337 * @common : ptr to common channel object 338 * 339 * This function will get next buffer from the dma queue and 340 * set the buffer address in the vpif register for capture. 341 * the buffer is marked active 342 */ 343static void vpif_schedule_next_buffer(struct common_obj *common) 344{ 345 unsigned long addr = 0; 346 347 spin_lock(&common->irqlock); 348 common->next_frm = list_entry(common->dma_queue.next, 349 struct vpif_cap_buffer, list); 350 /* Remove that buffer from the buffer queue */ 351 list_del(&common->next_frm->list); 352 spin_unlock(&common->irqlock); 353 addr = vb2_dma_contig_plane_dma_addr(&common->next_frm->vb, 0); 354 355 /* Set top and bottom field addresses in VPIF registers */ 356 common->set_addr(addr + common->ytop_off, 357 addr + common->ybtm_off, 358 addr + common->ctop_off, 359 addr + common->cbtm_off); 360} 361 362/** 363 * vpif_channel_isr : ISR handler for vpif capture 364 * @irq: irq number 365 * @dev_id: dev_id ptr 366 * 367 * It changes status of the captured buffer, takes next buffer from the queue 368 * and sets its address in VPIF registers 369 */ 370static irqreturn_t vpif_channel_isr(int irq, void *dev_id) 371{ 372 struct vpif_device *dev = &vpif_obj; 373 struct common_obj *common; 374 struct channel_obj *ch; 375 int channel_id = 0; 376 int fid = -1, i; 377 378 channel_id = *(int *)(dev_id); 379 if (!vpif_intr_status(channel_id)) 380 return IRQ_NONE; 381 382 ch = dev->dev[channel_id]; 383 384 for (i = 0; i < VPIF_NUMBER_OF_OBJECTS; i++) { 385 common = &ch->common[i]; 386 /* skip If streaming is not started in this channel */ 387 /* Check the field format */ 388 if (1 == ch->vpifparams.std_info.frm_fmt) { 389 /* Progressive mode */ 390 spin_lock(&common->irqlock); 391 if (list_empty(&common->dma_queue)) { 392 spin_unlock(&common->irqlock); 393 continue; 394 } 395 spin_unlock(&common->irqlock); 396 397 if (!channel_first_int[i][channel_id]) 398 vpif_process_buffer_complete(common); 399 400 channel_first_int[i][channel_id] = 0; 401 402 vpif_schedule_next_buffer(common); 403 404 405 channel_first_int[i][channel_id] = 0; 406 } else { 407 /** 408 * Interlaced mode. If it is first interrupt, ignore 409 * it 410 */ 411 if (channel_first_int[i][channel_id]) { 412 channel_first_int[i][channel_id] = 0; 413 continue; 414 } 415 if (0 == i) { 416 ch->field_id ^= 1; 417 /* Get field id from VPIF registers */ 418 fid = vpif_channel_getfid(ch->channel_id); 419 if (fid != ch->field_id) { 420 /** 421 * If field id does not match stored 422 * field id, make them in sync 423 */ 424 if (0 == fid) 425 ch->field_id = fid; 426 return IRQ_HANDLED; 427 } 428 } 429 /* device field id and local field id are in sync */ 430 if (0 == fid) { 431 /* this is even field */ 432 if (common->cur_frm == common->next_frm) 433 continue; 434 435 /* mark the current buffer as done */ 436 vpif_process_buffer_complete(common); 437 } else if (1 == fid) { 438 /* odd field */ 439 spin_lock(&common->irqlock); 440 if (list_empty(&common->dma_queue) || 441 (common->cur_frm != common->next_frm)) { 442 spin_unlock(&common->irqlock); 443 continue; 444 } 445 spin_unlock(&common->irqlock); 446 447 vpif_schedule_next_buffer(common); 448 } 449 } 450 } 451 return IRQ_HANDLED; 452} 453 454/** 455 * vpif_update_std_info() - update standard related info 456 * @ch: ptr to channel object 457 * 458 * For a given standard selected by application, update values 459 * in the device data structures 460 */ 461static int vpif_update_std_info(struct channel_obj *ch) 462{ 463 struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX]; 464 struct vpif_params *vpifparams = &ch->vpifparams; 465 const struct vpif_channel_config_params *config; 466 struct vpif_channel_config_params *std_info = &vpifparams->std_info; 467 struct video_obj *vid_ch = &ch->video; 468 int index; 469 470 vpif_dbg(2, debug, "vpif_update_std_info\n"); 471 472 for (index = 0; index < vpif_ch_params_count; index++) { 473 config = &vpif_ch_params[index]; 474 if (config->hd_sd == 0) { 475 vpif_dbg(2, debug, "SD format\n"); 476 if (config->stdid & vid_ch->stdid) { 477 memcpy(std_info, config, sizeof(*config)); 478 break; 479 } 480 } else { 481 vpif_dbg(2, debug, "HD format\n"); 482 if (!memcmp(&config->dv_timings, &vid_ch->dv_timings, 483 sizeof(vid_ch->dv_timings))) { 484 memcpy(std_info, config, sizeof(*config)); 485 break; 486 } 487 } 488 } 489 490 /* standard not found */ 491 if (index == vpif_ch_params_count) 492 return -EINVAL; 493 494 common->fmt.fmt.pix.width = std_info->width; 495 common->width = std_info->width; 496 common->fmt.fmt.pix.height = std_info->height; 497 common->height = std_info->height; 498 common->fmt.fmt.pix.sizeimage = common->height * common->width * 2; 499 common->fmt.fmt.pix.bytesperline = std_info->width; 500 vpifparams->video_params.hpitch = std_info->width; 501 vpifparams->video_params.storage_mode = std_info->frm_fmt; 502 503 if (vid_ch->stdid) 504 common->fmt.fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; 505 else 506 common->fmt.fmt.pix.colorspace = V4L2_COLORSPACE_REC709; 507 508 if (ch->vpifparams.std_info.frm_fmt) 509 common->fmt.fmt.pix.field = V4L2_FIELD_NONE; 510 else 511 common->fmt.fmt.pix.field = V4L2_FIELD_INTERLACED; 512 513 if (ch->vpifparams.iface.if_type == VPIF_IF_RAW_BAYER) 514 common->fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_SBGGR8; 515 else 516 common->fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUV422P; 517 518 common->fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 519 520 return 0; 521} 522 523/** 524 * vpif_calculate_offsets : This function calculates buffers offsets 525 * @ch : ptr to channel object 526 * 527 * This function calculates buffer offsets for Y and C in the top and 528 * bottom field 529 */ 530static void vpif_calculate_offsets(struct channel_obj *ch) 531{ 532 unsigned int hpitch, sizeimage; 533 struct video_obj *vid_ch = &(ch->video); 534 struct vpif_params *vpifparams = &ch->vpifparams; 535 struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX]; 536 enum v4l2_field field = common->fmt.fmt.pix.field; 537 538 vpif_dbg(2, debug, "vpif_calculate_offsets\n"); 539 540 if (V4L2_FIELD_ANY == field) { 541 if (vpifparams->std_info.frm_fmt) 542 vid_ch->buf_field = V4L2_FIELD_NONE; 543 else 544 vid_ch->buf_field = V4L2_FIELD_INTERLACED; 545 } else 546 vid_ch->buf_field = common->fmt.fmt.pix.field; 547 548 sizeimage = common->fmt.fmt.pix.sizeimage; 549 550 hpitch = common->fmt.fmt.pix.bytesperline; 551 552 if ((V4L2_FIELD_NONE == vid_ch->buf_field) || 553 (V4L2_FIELD_INTERLACED == vid_ch->buf_field)) { 554 /* Calculate offsets for Y top, Y Bottom, C top and C Bottom */ 555 common->ytop_off = 0; 556 common->ybtm_off = hpitch; 557 common->ctop_off = sizeimage / 2; 558 common->cbtm_off = sizeimage / 2 + hpitch; 559 } else if (V4L2_FIELD_SEQ_TB == vid_ch->buf_field) { 560 /* Calculate offsets for Y top, Y Bottom, C top and C Bottom */ 561 common->ytop_off = 0; 562 common->ybtm_off = sizeimage / 4; 563 common->ctop_off = sizeimage / 2; 564 common->cbtm_off = common->ctop_off + sizeimage / 4; 565 } else if (V4L2_FIELD_SEQ_BT == vid_ch->buf_field) { 566 /* Calculate offsets for Y top, Y Bottom, C top and C Bottom */ 567 common->ybtm_off = 0; 568 common->ytop_off = sizeimage / 4; 569 common->cbtm_off = sizeimage / 2; 570 common->ctop_off = common->cbtm_off + sizeimage / 4; 571 } 572 if ((V4L2_FIELD_NONE == vid_ch->buf_field) || 573 (V4L2_FIELD_INTERLACED == vid_ch->buf_field)) 574 vpifparams->video_params.storage_mode = 1; 575 else 576 vpifparams->video_params.storage_mode = 0; 577 578 if (1 == vpifparams->std_info.frm_fmt) 579 vpifparams->video_params.hpitch = 580 common->fmt.fmt.pix.bytesperline; 581 else { 582 if ((field == V4L2_FIELD_ANY) 583 || (field == V4L2_FIELD_INTERLACED)) 584 vpifparams->video_params.hpitch = 585 common->fmt.fmt.pix.bytesperline * 2; 586 else 587 vpifparams->video_params.hpitch = 588 common->fmt.fmt.pix.bytesperline; 589 } 590 591 ch->vpifparams.video_params.stdid = vpifparams->std_info.stdid; 592} 593 594/** 595 * vpif_get_default_field() - Get default field type based on interface 596 * @vpif_params - ptr to vpif params 597 */ 598static inline enum v4l2_field vpif_get_default_field( 599 struct vpif_interface *iface) 600{ 601 return (iface->if_type == VPIF_IF_RAW_BAYER) ? V4L2_FIELD_NONE : 602 V4L2_FIELD_INTERLACED; 603} 604 605/** 606 * vpif_config_addr() - function to configure buffer address in vpif 607 * @ch - channel ptr 608 * @muxmode - channel mux mode 609 */ 610static void vpif_config_addr(struct channel_obj *ch, int muxmode) 611{ 612 struct common_obj *common; 613 614 vpif_dbg(2, debug, "vpif_config_addr\n"); 615 616 common = &(ch->common[VPIF_VIDEO_INDEX]); 617 618 if (VPIF_CHANNEL1_VIDEO == ch->channel_id) 619 common->set_addr = ch1_set_videobuf_addr; 620 else if (2 == muxmode) 621 common->set_addr = ch0_set_videobuf_addr_yc_nmux; 622 else 623 common->set_addr = ch0_set_videobuf_addr; 624} 625 626/** 627 * vpif_input_to_subdev() - Maps input to sub device 628 * @vpif_cfg - global config ptr 629 * @chan_cfg - channel config ptr 630 * @input_index - Given input index from application 631 * 632 * lookup the sub device information for a given input index. 633 * we report all the inputs to application. inputs table also 634 * has sub device name for the each input 635 */ 636static int vpif_input_to_subdev( 637 struct vpif_capture_config *vpif_cfg, 638 struct vpif_capture_chan_config *chan_cfg, 639 int input_index) 640{ 641 struct vpif_subdev_info *subdev_info; 642 const char *subdev_name; 643 int i; 644 645 vpif_dbg(2, debug, "vpif_input_to_subdev\n"); 646 647 subdev_name = chan_cfg->inputs[input_index].subdev_name; 648 if (subdev_name == NULL) 649 return -1; 650 651 /* loop through the sub device list to get the sub device info */ 652 for (i = 0; i < vpif_cfg->subdev_count; i++) { 653 subdev_info = &vpif_cfg->subdev_info[i]; 654 if (!strcmp(subdev_info->name, subdev_name)) 655 return i; 656 } 657 return -1; 658} 659 660/** 661 * vpif_set_input() - Select an input 662 * @vpif_cfg - global config ptr 663 * @ch - channel 664 * @_index - Given input index from application 665 * 666 * Select the given input. 667 */ 668static int vpif_set_input( 669 struct vpif_capture_config *vpif_cfg, 670 struct channel_obj *ch, 671 int index) 672{ 673 struct vpif_capture_chan_config *chan_cfg = 674 &vpif_cfg->chan_config[ch->channel_id]; 675 struct vpif_subdev_info *subdev_info = NULL; 676 struct v4l2_subdev *sd = NULL; 677 u32 input = 0, output = 0; 678 int sd_index; 679 int ret; 680 681 sd_index = vpif_input_to_subdev(vpif_cfg, chan_cfg, index); 682 if (sd_index >= 0) { 683 sd = vpif_obj.sd[sd_index]; 684 subdev_info = &vpif_cfg->subdev_info[sd_index]; 685 } 686 687 /* first setup input path from sub device to vpif */ 688 if (sd && vpif_cfg->setup_input_path) { 689 ret = vpif_cfg->setup_input_path(ch->channel_id, 690 subdev_info->name); 691 if (ret < 0) { 692 vpif_dbg(1, debug, "couldn't setup input path for the" \ 693 " sub device %s, for input index %d\n", 694 subdev_info->name, index); 695 return ret; 696 } 697 } 698 699 if (sd) { 700 input = chan_cfg->inputs[index].input_route; 701 output = chan_cfg->inputs[index].output_route; 702 ret = v4l2_subdev_call(sd, video, s_routing, 703 input, output, 0); 704 if (ret < 0 && ret != -ENOIOCTLCMD) { 705 vpif_dbg(1, debug, "Failed to set input\n"); 706 return ret; 707 } 708 } 709 ch->input_idx = index; 710 ch->sd = sd; 711 /* copy interface parameters to vpif */ 712 ch->vpifparams.iface = chan_cfg->vpif_if; 713 714 /* update tvnorms from the sub device input info */ 715 ch->video_dev.tvnorms = chan_cfg->inputs[index].input.std; 716 return 0; 717} 718 719/** 720 * vpif_querystd() - querystd handler 721 * @file: file ptr 722 * @priv: file handle 723 * @std_id: ptr to std id 724 * 725 * This function is called to detect standard at the selected input 726 */ 727static int vpif_querystd(struct file *file, void *priv, v4l2_std_id *std_id) 728{ 729 struct video_device *vdev = video_devdata(file); 730 struct channel_obj *ch = video_get_drvdata(vdev); 731 int ret = 0; 732 733 vpif_dbg(2, debug, "vpif_querystd\n"); 734 735 /* Call querystd function of decoder device */ 736 ret = v4l2_subdev_call(ch->sd, video, querystd, std_id); 737 738 if (ret == -ENOIOCTLCMD || ret == -ENODEV) 739 return -ENODATA; 740 if (ret) { 741 vpif_dbg(1, debug, "Failed to query standard for sub devices\n"); 742 return ret; 743 } 744 745 return 0; 746} 747 748/** 749 * vpif_g_std() - get STD handler 750 * @file: file ptr 751 * @priv: file handle 752 * @std_id: ptr to std id 753 */ 754static int vpif_g_std(struct file *file, void *priv, v4l2_std_id *std) 755{ 756 struct vpif_capture_config *config = vpif_dev->platform_data; 757 struct video_device *vdev = video_devdata(file); 758 struct channel_obj *ch = video_get_drvdata(vdev); 759 struct vpif_capture_chan_config *chan_cfg; 760 struct v4l2_input input; 761 762 vpif_dbg(2, debug, "vpif_g_std\n"); 763 764 if (config->chan_config[ch->channel_id].inputs == NULL) 765 return -ENODATA; 766 767 chan_cfg = &config->chan_config[ch->channel_id]; 768 input = chan_cfg->inputs[ch->input_idx].input; 769 if (input.capabilities != V4L2_IN_CAP_STD) 770 return -ENODATA; 771 772 *std = ch->video.stdid; 773 return 0; 774} 775 776/** 777 * vpif_s_std() - set STD handler 778 * @file: file ptr 779 * @priv: file handle 780 * @std_id: ptr to std id 781 */ 782static int vpif_s_std(struct file *file, void *priv, v4l2_std_id std_id) 783{ 784 struct vpif_capture_config *config = vpif_dev->platform_data; 785 struct video_device *vdev = video_devdata(file); 786 struct channel_obj *ch = video_get_drvdata(vdev); 787 struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX]; 788 struct vpif_capture_chan_config *chan_cfg; 789 struct v4l2_input input; 790 int ret; 791 792 vpif_dbg(2, debug, "vpif_s_std\n"); 793 794 if (config->chan_config[ch->channel_id].inputs == NULL) 795 return -ENODATA; 796 797 chan_cfg = &config->chan_config[ch->channel_id]; 798 input = chan_cfg->inputs[ch->input_idx].input; 799 if (input.capabilities != V4L2_IN_CAP_STD) 800 return -ENODATA; 801 802 if (vb2_is_busy(&common->buffer_queue)) 803 return -EBUSY; 804 805 /* Call encoder subdevice function to set the standard */ 806 ch->video.stdid = std_id; 807 memset(&ch->video.dv_timings, 0, sizeof(ch->video.dv_timings)); 808 809 /* Get the information about the standard */ 810 if (vpif_update_std_info(ch)) { 811 vpif_err("Error getting the standard info\n"); 812 return -EINVAL; 813 } 814 815 /* set standard in the sub device */ 816 ret = v4l2_subdev_call(ch->sd, video, s_std, std_id); 817 if (ret && ret != -ENOIOCTLCMD && ret != -ENODEV) { 818 vpif_dbg(1, debug, "Failed to set standard for sub devices\n"); 819 return ret; 820 } 821 return 0; 822} 823 824/** 825 * vpif_enum_input() - ENUMINPUT handler 826 * @file: file ptr 827 * @priv: file handle 828 * @input: ptr to input structure 829 */ 830static int vpif_enum_input(struct file *file, void *priv, 831 struct v4l2_input *input) 832{ 833 834 struct vpif_capture_config *config = vpif_dev->platform_data; 835 struct video_device *vdev = video_devdata(file); 836 struct channel_obj *ch = video_get_drvdata(vdev); 837 struct vpif_capture_chan_config *chan_cfg; 838 839 chan_cfg = &config->chan_config[ch->channel_id]; 840 841 if (input->index >= chan_cfg->input_count) 842 return -EINVAL; 843 844 memcpy(input, &chan_cfg->inputs[input->index].input, 845 sizeof(*input)); 846 return 0; 847} 848 849/** 850 * vpif_g_input() - Get INPUT handler 851 * @file: file ptr 852 * @priv: file handle 853 * @index: ptr to input index 854 */ 855static int vpif_g_input(struct file *file, void *priv, unsigned int *index) 856{ 857 struct video_device *vdev = video_devdata(file); 858 struct channel_obj *ch = video_get_drvdata(vdev); 859 860 *index = ch->input_idx; 861 return 0; 862} 863 864/** 865 * vpif_s_input() - Set INPUT handler 866 * @file: file ptr 867 * @priv: file handle 868 * @index: input index 869 */ 870static int vpif_s_input(struct file *file, void *priv, unsigned int index) 871{ 872 struct vpif_capture_config *config = vpif_dev->platform_data; 873 struct video_device *vdev = video_devdata(file); 874 struct channel_obj *ch = video_get_drvdata(vdev); 875 struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX]; 876 struct vpif_capture_chan_config *chan_cfg; 877 878 chan_cfg = &config->chan_config[ch->channel_id]; 879 880 if (index >= chan_cfg->input_count) 881 return -EINVAL; 882 883 if (vb2_is_busy(&common->buffer_queue)) 884 return -EBUSY; 885 886 return vpif_set_input(config, ch, index); 887} 888 889/** 890 * vpif_enum_fmt_vid_cap() - ENUM_FMT handler 891 * @file: file ptr 892 * @priv: file handle 893 * @index: input index 894 */ 895static int vpif_enum_fmt_vid_cap(struct file *file, void *priv, 896 struct v4l2_fmtdesc *fmt) 897{ 898 struct video_device *vdev = video_devdata(file); 899 struct channel_obj *ch = video_get_drvdata(vdev); 900 901 if (fmt->index != 0) { 902 vpif_dbg(1, debug, "Invalid format index\n"); 903 return -EINVAL; 904 } 905 906 /* Fill in the information about format */ 907 if (ch->vpifparams.iface.if_type == VPIF_IF_RAW_BAYER) { 908 fmt->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 909 strcpy(fmt->description, "Raw Mode -Bayer Pattern GrRBGb"); 910 fmt->pixelformat = V4L2_PIX_FMT_SBGGR8; 911 } else { 912 fmt->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 913 strcpy(fmt->description, "YCbCr4:2:2 YC Planar"); 914 fmt->pixelformat = V4L2_PIX_FMT_YUV422P; 915 } 916 return 0; 917} 918 919/** 920 * vpif_try_fmt_vid_cap() - TRY_FMT handler 921 * @file: file ptr 922 * @priv: file handle 923 * @fmt: ptr to v4l2 format structure 924 */ 925static int vpif_try_fmt_vid_cap(struct file *file, void *priv, 926 struct v4l2_format *fmt) 927{ 928 struct video_device *vdev = video_devdata(file); 929 struct channel_obj *ch = video_get_drvdata(vdev); 930 struct v4l2_pix_format *pixfmt = &fmt->fmt.pix; 931 struct common_obj *common = &(ch->common[VPIF_VIDEO_INDEX]); 932 struct vpif_params *vpif_params = &ch->vpifparams; 933 934 /* 935 * to supress v4l-compliance warnings silently correct 936 * the pixelformat 937 */ 938 if (vpif_params->iface.if_type == VPIF_IF_RAW_BAYER) { 939 if (pixfmt->pixelformat != V4L2_PIX_FMT_SBGGR8) 940 pixfmt->pixelformat = V4L2_PIX_FMT_SBGGR8; 941 } else { 942 if (pixfmt->pixelformat != V4L2_PIX_FMT_YUV422P) 943 pixfmt->pixelformat = V4L2_PIX_FMT_YUV422P; 944 } 945 946 common->fmt.fmt.pix.pixelformat = pixfmt->pixelformat; 947 948 vpif_update_std_info(ch); 949 950 pixfmt->field = common->fmt.fmt.pix.field; 951 pixfmt->colorspace = common->fmt.fmt.pix.colorspace; 952 pixfmt->bytesperline = common->fmt.fmt.pix.width; 953 pixfmt->width = common->fmt.fmt.pix.width; 954 pixfmt->height = common->fmt.fmt.pix.height; 955 pixfmt->sizeimage = pixfmt->bytesperline * pixfmt->height * 2; 956 pixfmt->priv = 0; 957 958 return 0; 959} 960 961 962/** 963 * vpif_g_fmt_vid_cap() - Set INPUT handler 964 * @file: file ptr 965 * @priv: file handle 966 * @fmt: ptr to v4l2 format structure 967 */ 968static int vpif_g_fmt_vid_cap(struct file *file, void *priv, 969 struct v4l2_format *fmt) 970{ 971 struct video_device *vdev = video_devdata(file); 972 struct channel_obj *ch = video_get_drvdata(vdev); 973 struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX]; 974 975 /* Check the validity of the buffer type */ 976 if (common->fmt.type != fmt->type) 977 return -EINVAL; 978 979 /* Fill in the information about format */ 980 *fmt = common->fmt; 981 return 0; 982} 983 984/** 985 * vpif_s_fmt_vid_cap() - Set FMT handler 986 * @file: file ptr 987 * @priv: file handle 988 * @fmt: ptr to v4l2 format structure 989 */ 990static int vpif_s_fmt_vid_cap(struct file *file, void *priv, 991 struct v4l2_format *fmt) 992{ 993 struct video_device *vdev = video_devdata(file); 994 struct channel_obj *ch = video_get_drvdata(vdev); 995 struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX]; 996 int ret; 997 998 vpif_dbg(2, debug, "%s\n", __func__); 999 1000 if (vb2_is_busy(&common->buffer_queue)) 1001 return -EBUSY; 1002 1003 ret = vpif_try_fmt_vid_cap(file, priv, fmt); 1004 if (ret) 1005 return ret; 1006 1007 /* store the format in the channel object */ 1008 common->fmt = *fmt; 1009 return 0; 1010} 1011 1012/** 1013 * vpif_querycap() - QUERYCAP handler 1014 * @file: file ptr 1015 * @priv: file handle 1016 * @cap: ptr to v4l2_capability structure 1017 */ 1018static int vpif_querycap(struct file *file, void *priv, 1019 struct v4l2_capability *cap) 1020{ 1021 struct vpif_capture_config *config = vpif_dev->platform_data; 1022 1023 cap->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING; 1024 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS; 1025 strlcpy(cap->driver, VPIF_DRIVER_NAME, sizeof(cap->driver)); 1026 snprintf(cap->bus_info, sizeof(cap->bus_info), "platform:%s", 1027 dev_name(vpif_dev)); 1028 strlcpy(cap->card, config->card_name, sizeof(cap->card)); 1029 1030 return 0; 1031} 1032 1033/** 1034 * vpif_enum_dv_timings() - ENUM_DV_TIMINGS handler 1035 * @file: file ptr 1036 * @priv: file handle 1037 * @timings: input timings 1038 */ 1039static int 1040vpif_enum_dv_timings(struct file *file, void *priv, 1041 struct v4l2_enum_dv_timings *timings) 1042{ 1043 struct vpif_capture_config *config = vpif_dev->platform_data; 1044 struct video_device *vdev = video_devdata(file); 1045 struct channel_obj *ch = video_get_drvdata(vdev); 1046 struct vpif_capture_chan_config *chan_cfg; 1047 struct v4l2_input input; 1048 int ret; 1049 1050 if (config->chan_config[ch->channel_id].inputs == NULL) 1051 return -ENODATA; 1052 1053 chan_cfg = &config->chan_config[ch->channel_id]; 1054 input = chan_cfg->inputs[ch->input_idx].input; 1055 if (input.capabilities != V4L2_IN_CAP_DV_TIMINGS) 1056 return -ENODATA; 1057 1058 timings->pad = 0; 1059 1060 ret = v4l2_subdev_call(ch->sd, pad, enum_dv_timings, timings); 1061 if (ret == -ENOIOCTLCMD || ret == -ENODEV) 1062 return -EINVAL; 1063 1064 return ret; 1065} 1066 1067/** 1068 * vpif_query_dv_timings() - QUERY_DV_TIMINGS handler 1069 * @file: file ptr 1070 * @priv: file handle 1071 * @timings: input timings 1072 */ 1073static int 1074vpif_query_dv_timings(struct file *file, void *priv, 1075 struct v4l2_dv_timings *timings) 1076{ 1077 struct vpif_capture_config *config = vpif_dev->platform_data; 1078 struct video_device *vdev = video_devdata(file); 1079 struct channel_obj *ch = video_get_drvdata(vdev); 1080 struct vpif_capture_chan_config *chan_cfg; 1081 struct v4l2_input input; 1082 int ret; 1083 1084 if (config->chan_config[ch->channel_id].inputs == NULL) 1085 return -ENODATA; 1086 1087 chan_cfg = &config->chan_config[ch->channel_id]; 1088 input = chan_cfg->inputs[ch->input_idx].input; 1089 if (input.capabilities != V4L2_IN_CAP_DV_TIMINGS) 1090 return -ENODATA; 1091 1092 ret = v4l2_subdev_call(ch->sd, video, query_dv_timings, timings); 1093 if (ret == -ENOIOCTLCMD || ret == -ENODEV) 1094 return -ENODATA; 1095 1096 return ret; 1097} 1098 1099/** 1100 * vpif_s_dv_timings() - S_DV_TIMINGS handler 1101 * @file: file ptr 1102 * @priv: file handle 1103 * @timings: digital video timings 1104 */ 1105static int vpif_s_dv_timings(struct file *file, void *priv, 1106 struct v4l2_dv_timings *timings) 1107{ 1108 struct vpif_capture_config *config = vpif_dev->platform_data; 1109 struct video_device *vdev = video_devdata(file); 1110 struct channel_obj *ch = video_get_drvdata(vdev); 1111 struct vpif_params *vpifparams = &ch->vpifparams; 1112 struct vpif_channel_config_params *std_info = &vpifparams->std_info; 1113 struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX]; 1114 struct video_obj *vid_ch = &ch->video; 1115 struct v4l2_bt_timings *bt = &vid_ch->dv_timings.bt; 1116 struct vpif_capture_chan_config *chan_cfg; 1117 struct v4l2_input input; 1118 int ret; 1119 1120 if (config->chan_config[ch->channel_id].inputs == NULL) 1121 return -ENODATA; 1122 1123 chan_cfg = &config->chan_config[ch->channel_id]; 1124 input = chan_cfg->inputs[ch->input_idx].input; 1125 if (input.capabilities != V4L2_IN_CAP_DV_TIMINGS) 1126 return -ENODATA; 1127 1128 if (timings->type != V4L2_DV_BT_656_1120) { 1129 vpif_dbg(2, debug, "Timing type not defined\n"); 1130 return -EINVAL; 1131 } 1132 1133 if (vb2_is_busy(&common->buffer_queue)) 1134 return -EBUSY; 1135 1136 /* Configure subdevice timings, if any */ 1137 ret = v4l2_subdev_call(ch->sd, video, s_dv_timings, timings); 1138 if (ret == -ENOIOCTLCMD || ret == -ENODEV) 1139 ret = 0; 1140 if (ret < 0) { 1141 vpif_dbg(2, debug, "Error setting custom DV timings\n"); 1142 return ret; 1143 } 1144 1145 if (!(timings->bt.width && timings->bt.height && 1146 (timings->bt.hbackporch || 1147 timings->bt.hfrontporch || 1148 timings->bt.hsync) && 1149 timings->bt.vfrontporch && 1150 (timings->bt.vbackporch || 1151 timings->bt.vsync))) { 1152 vpif_dbg(2, debug, "Timings for width, height, " 1153 "horizontal back porch, horizontal sync, " 1154 "horizontal front porch, vertical back porch, " 1155 "vertical sync and vertical back porch " 1156 "must be defined\n"); 1157 return -EINVAL; 1158 } 1159 1160 vid_ch->dv_timings = *timings; 1161 1162 /* Configure video port timings */ 1163 1164 std_info->eav2sav = V4L2_DV_BT_BLANKING_WIDTH(bt) - 8; 1165 std_info->sav2eav = bt->width; 1166 1167 std_info->l1 = 1; 1168 std_info->l3 = bt->vsync + bt->vbackporch + 1; 1169 1170 std_info->vsize = V4L2_DV_BT_FRAME_HEIGHT(bt); 1171 if (bt->interlaced) { 1172 if (bt->il_vbackporch || bt->il_vfrontporch || bt->il_vsync) { 1173 std_info->l5 = std_info->vsize/2 - 1174 (bt->vfrontporch - 1); 1175 std_info->l7 = std_info->vsize/2 + 1; 1176 std_info->l9 = std_info->l7 + bt->il_vsync + 1177 bt->il_vbackporch + 1; 1178 std_info->l11 = std_info->vsize - 1179 (bt->il_vfrontporch - 1); 1180 } else { 1181 vpif_dbg(2, debug, "Required timing values for " 1182 "interlaced BT format missing\n"); 1183 return -EINVAL; 1184 } 1185 } else { 1186 std_info->l5 = std_info->vsize - (bt->vfrontporch - 1); 1187 } 1188 strncpy(std_info->name, "Custom timings BT656/1120", VPIF_MAX_NAME); 1189 std_info->width = bt->width; 1190 std_info->height = bt->height; 1191 std_info->frm_fmt = bt->interlaced ? 0 : 1; 1192 std_info->ycmux_mode = 0; 1193 std_info->capture_format = 0; 1194 std_info->vbi_supported = 0; 1195 std_info->hd_sd = 1; 1196 std_info->stdid = 0; 1197 1198 vid_ch->stdid = 0; 1199 return 0; 1200} 1201 1202/** 1203 * vpif_g_dv_timings() - G_DV_TIMINGS handler 1204 * @file: file ptr 1205 * @priv: file handle 1206 * @timings: digital video timings 1207 */ 1208static int vpif_g_dv_timings(struct file *file, void *priv, 1209 struct v4l2_dv_timings *timings) 1210{ 1211 struct vpif_capture_config *config = vpif_dev->platform_data; 1212 struct video_device *vdev = video_devdata(file); 1213 struct channel_obj *ch = video_get_drvdata(vdev); 1214 struct video_obj *vid_ch = &ch->video; 1215 struct vpif_capture_chan_config *chan_cfg; 1216 struct v4l2_input input; 1217 1218 if (config->chan_config[ch->channel_id].inputs == NULL) 1219 return -ENODATA; 1220 1221 chan_cfg = &config->chan_config[ch->channel_id]; 1222 input = chan_cfg->inputs[ch->input_idx].input; 1223 if (input.capabilities != V4L2_IN_CAP_DV_TIMINGS) 1224 return -ENODATA; 1225 1226 *timings = vid_ch->dv_timings; 1227 1228 return 0; 1229} 1230 1231/* 1232 * vpif_log_status() - Status information 1233 * @file: file ptr 1234 * @priv: file handle 1235 * 1236 * Returns zero. 1237 */ 1238static int vpif_log_status(struct file *filep, void *priv) 1239{ 1240 /* status for sub devices */ 1241 v4l2_device_call_all(&vpif_obj.v4l2_dev, 0, core, log_status); 1242 1243 return 0; 1244} 1245 1246/* vpif capture ioctl operations */ 1247static const struct v4l2_ioctl_ops vpif_ioctl_ops = { 1248 .vidioc_querycap = vpif_querycap, 1249 .vidioc_enum_fmt_vid_cap = vpif_enum_fmt_vid_cap, 1250 .vidioc_g_fmt_vid_cap = vpif_g_fmt_vid_cap, 1251 .vidioc_s_fmt_vid_cap = vpif_s_fmt_vid_cap, 1252 .vidioc_try_fmt_vid_cap = vpif_try_fmt_vid_cap, 1253 1254 .vidioc_enum_input = vpif_enum_input, 1255 .vidioc_s_input = vpif_s_input, 1256 .vidioc_g_input = vpif_g_input, 1257 1258 .vidioc_reqbufs = vb2_ioctl_reqbufs, 1259 .vidioc_create_bufs = vb2_ioctl_create_bufs, 1260 .vidioc_querybuf = vb2_ioctl_querybuf, 1261 .vidioc_qbuf = vb2_ioctl_qbuf, 1262 .vidioc_dqbuf = vb2_ioctl_dqbuf, 1263 .vidioc_expbuf = vb2_ioctl_expbuf, 1264 .vidioc_streamon = vb2_ioctl_streamon, 1265 .vidioc_streamoff = vb2_ioctl_streamoff, 1266 1267 .vidioc_querystd = vpif_querystd, 1268 .vidioc_s_std = vpif_s_std, 1269 .vidioc_g_std = vpif_g_std, 1270 1271 .vidioc_enum_dv_timings = vpif_enum_dv_timings, 1272 .vidioc_query_dv_timings = vpif_query_dv_timings, 1273 .vidioc_s_dv_timings = vpif_s_dv_timings, 1274 .vidioc_g_dv_timings = vpif_g_dv_timings, 1275 1276 .vidioc_log_status = vpif_log_status, 1277}; 1278 1279/* vpif file operations */ 1280static struct v4l2_file_operations vpif_fops = { 1281 .owner = THIS_MODULE, 1282 .open = v4l2_fh_open, 1283 .release = vb2_fop_release, 1284 .unlocked_ioctl = video_ioctl2, 1285 .mmap = vb2_fop_mmap, 1286 .poll = vb2_fop_poll 1287}; 1288 1289/** 1290 * initialize_vpif() - Initialize vpif data structures 1291 * 1292 * Allocate memory for data structures and initialize them 1293 */ 1294static int initialize_vpif(void) 1295{ 1296 int err, i, j; 1297 int free_channel_objects_index; 1298 1299 /* Allocate memory for six channel objects */ 1300 for (i = 0; i < VPIF_CAPTURE_MAX_DEVICES; i++) { 1301 vpif_obj.dev[i] = 1302 kzalloc(sizeof(*vpif_obj.dev[i]), GFP_KERNEL); 1303 /* If memory allocation fails, return error */ 1304 if (!vpif_obj.dev[i]) { 1305 free_channel_objects_index = i; 1306 err = -ENOMEM; 1307 goto vpif_init_free_channel_objects; 1308 } 1309 } 1310 return 0; 1311 1312vpif_init_free_channel_objects: 1313 for (j = 0; j < free_channel_objects_index; j++) 1314 kfree(vpif_obj.dev[j]); 1315 return err; 1316} 1317 1318static int vpif_async_bound(struct v4l2_async_notifier *notifier, 1319 struct v4l2_subdev *subdev, 1320 struct v4l2_async_subdev *asd) 1321{ 1322 int i; 1323 1324 for (i = 0; i < vpif_obj.config->subdev_count; i++) 1325 if (!strcmp(vpif_obj.config->subdev_info[i].name, 1326 subdev->name)) { 1327 vpif_obj.sd[i] = subdev; 1328 return 0; 1329 } 1330 1331 return -EINVAL; 1332} 1333 1334static int vpif_probe_complete(void) 1335{ 1336 struct common_obj *common; 1337 struct video_device *vdev; 1338 struct channel_obj *ch; 1339 struct vb2_queue *q; 1340 int j, err, k; 1341 1342 for (j = 0; j < VPIF_CAPTURE_MAX_DEVICES; j++) { 1343 ch = vpif_obj.dev[j]; 1344 ch->channel_id = j; 1345 common = &(ch->common[VPIF_VIDEO_INDEX]); 1346 spin_lock_init(&common->irqlock); 1347 mutex_init(&common->lock); 1348 1349 /* select input 0 */ 1350 err = vpif_set_input(vpif_obj.config, ch, 0); 1351 if (err) 1352 goto probe_out; 1353 1354 /* set initial format */ 1355 ch->video.stdid = V4L2_STD_525_60; 1356 memset(&ch->video.dv_timings, 0, sizeof(ch->video.dv_timings)); 1357 vpif_update_std_info(ch); 1358 1359 /* Initialize vb2 queue */ 1360 q = &common->buffer_queue; 1361 q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 1362 q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF; 1363 q->drv_priv = ch; 1364 q->ops = &video_qops; 1365 q->mem_ops = &vb2_dma_contig_memops; 1366 q->buf_struct_size = sizeof(struct vpif_cap_buffer); 1367 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1368 q->min_buffers_needed = 1; 1369 q->lock = &common->lock; 1370 1371 err = vb2_queue_init(q); 1372 if (err) { 1373 vpif_err("vpif_capture: vb2_queue_init() failed\n"); 1374 goto probe_out; 1375 } 1376 1377 common->alloc_ctx = vb2_dma_contig_init_ctx(vpif_dev); 1378 if (IS_ERR(common->alloc_ctx)) { 1379 vpif_err("Failed to get the context\n"); 1380 err = PTR_ERR(common->alloc_ctx); 1381 goto probe_out; 1382 } 1383 1384 INIT_LIST_HEAD(&common->dma_queue); 1385 1386 /* Initialize the video_device structure */ 1387 vdev = &ch->video_dev; 1388 strlcpy(vdev->name, VPIF_DRIVER_NAME, sizeof(vdev->name)); 1389 vdev->release = video_device_release_empty; 1390 vdev->fops = &vpif_fops; 1391 vdev->ioctl_ops = &vpif_ioctl_ops; 1392 vdev->v4l2_dev = &vpif_obj.v4l2_dev; 1393 vdev->vfl_dir = VFL_DIR_RX; 1394 vdev->queue = q; 1395 vdev->lock = &common->lock; 1396 video_set_drvdata(&ch->video_dev, ch); 1397 err = video_register_device(vdev, 1398 VFL_TYPE_GRABBER, (j ? 1 : 0)); 1399 if (err) 1400 goto probe_out; 1401 } 1402 1403 v4l2_info(&vpif_obj.v4l2_dev, "VPIF capture driver initialized\n"); 1404 return 0; 1405 1406probe_out: 1407 for (k = 0; k < j; k++) { 1408 /* Get the pointer to the channel object */ 1409 ch = vpif_obj.dev[k]; 1410 common = &ch->common[k]; 1411 vb2_dma_contig_cleanup_ctx(common->alloc_ctx); 1412 /* Unregister video device */ 1413 video_unregister_device(&ch->video_dev); 1414 } 1415 kfree(vpif_obj.sd); 1416 v4l2_device_unregister(&vpif_obj.v4l2_dev); 1417 1418 return err; 1419} 1420 1421static int vpif_async_complete(struct v4l2_async_notifier *notifier) 1422{ 1423 return vpif_probe_complete(); 1424} 1425 1426/** 1427 * vpif_probe : This function probes the vpif capture driver 1428 * @pdev: platform device pointer 1429 * 1430 * This creates device entries by register itself to the V4L2 driver and 1431 * initializes fields of each channel objects 1432 */ 1433static __init int vpif_probe(struct platform_device *pdev) 1434{ 1435 struct vpif_subdev_info *subdevdata; 1436 struct i2c_adapter *i2c_adap; 1437 struct resource *res; 1438 int subdev_count; 1439 int res_idx = 0; 1440 int i, err; 1441 1442 vpif_dev = &pdev->dev; 1443 1444 err = initialize_vpif(); 1445 if (err) { 1446 v4l2_err(vpif_dev->driver, "Error initializing vpif\n"); 1447 return err; 1448 } 1449 1450 err = v4l2_device_register(vpif_dev, &vpif_obj.v4l2_dev); 1451 if (err) { 1452 v4l2_err(vpif_dev->driver, "Error registering v4l2 device\n"); 1453 return err; 1454 } 1455 1456 while ((res = platform_get_resource(pdev, IORESOURCE_IRQ, res_idx))) { 1457 err = devm_request_irq(&pdev->dev, res->start, vpif_channel_isr, 1458 IRQF_SHARED, VPIF_DRIVER_NAME, 1459 (void *)(&vpif_obj.dev[res_idx]-> 1460 channel_id)); 1461 if (err) { 1462 err = -EINVAL; 1463 goto vpif_unregister; 1464 } 1465 res_idx++; 1466 } 1467 1468 vpif_obj.config = pdev->dev.platform_data; 1469 1470 subdev_count = vpif_obj.config->subdev_count; 1471 vpif_obj.sd = kzalloc(sizeof(struct v4l2_subdev *) * subdev_count, 1472 GFP_KERNEL); 1473 if (vpif_obj.sd == NULL) { 1474 vpif_err("unable to allocate memory for subdevice pointers\n"); 1475 err = -ENOMEM; 1476 goto vpif_unregister; 1477 } 1478 1479 if (!vpif_obj.config->asd_sizes) { 1480 i2c_adap = i2c_get_adapter(1); 1481 for (i = 0; i < subdev_count; i++) { 1482 subdevdata = &vpif_obj.config->subdev_info[i]; 1483 vpif_obj.sd[i] = 1484 v4l2_i2c_new_subdev_board(&vpif_obj.v4l2_dev, 1485 i2c_adap, 1486 &subdevdata-> 1487 board_info, 1488 NULL); 1489 1490 if (!vpif_obj.sd[i]) { 1491 vpif_err("Error registering v4l2 subdevice\n"); 1492 err = -ENODEV; 1493 goto probe_subdev_out; 1494 } 1495 v4l2_info(&vpif_obj.v4l2_dev, 1496 "registered sub device %s\n", 1497 subdevdata->name); 1498 } 1499 vpif_probe_complete(); 1500 } else { 1501 vpif_obj.notifier.subdevs = vpif_obj.config->asd; 1502 vpif_obj.notifier.num_subdevs = vpif_obj.config->asd_sizes[0]; 1503 vpif_obj.notifier.bound = vpif_async_bound; 1504 vpif_obj.notifier.complete = vpif_async_complete; 1505 err = v4l2_async_notifier_register(&vpif_obj.v4l2_dev, 1506 &vpif_obj.notifier); 1507 if (err) { 1508 vpif_err("Error registering async notifier\n"); 1509 err = -EINVAL; 1510 goto probe_subdev_out; 1511 } 1512 } 1513 1514 return 0; 1515 1516probe_subdev_out: 1517 /* free sub devices memory */ 1518 kfree(vpif_obj.sd); 1519vpif_unregister: 1520 v4l2_device_unregister(&vpif_obj.v4l2_dev); 1521 1522 return err; 1523} 1524 1525/** 1526 * vpif_remove() - driver remove handler 1527 * @device: ptr to platform device structure 1528 * 1529 * The vidoe device is unregistered 1530 */ 1531static int vpif_remove(struct platform_device *device) 1532{ 1533 struct common_obj *common; 1534 struct channel_obj *ch; 1535 int i; 1536 1537 v4l2_device_unregister(&vpif_obj.v4l2_dev); 1538 1539 kfree(vpif_obj.sd); 1540 /* un-register device */ 1541 for (i = 0; i < VPIF_CAPTURE_MAX_DEVICES; i++) { 1542 /* Get the pointer to the channel object */ 1543 ch = vpif_obj.dev[i]; 1544 common = &ch->common[VPIF_VIDEO_INDEX]; 1545 vb2_dma_contig_cleanup_ctx(common->alloc_ctx); 1546 /* Unregister video device */ 1547 video_unregister_device(&ch->video_dev); 1548 kfree(vpif_obj.dev[i]); 1549 } 1550 return 0; 1551} 1552 1553#ifdef CONFIG_PM_SLEEP 1554/** 1555 * vpif_suspend: vpif device suspend 1556 */ 1557static int vpif_suspend(struct device *dev) 1558{ 1559 1560 struct common_obj *common; 1561 struct channel_obj *ch; 1562 int i; 1563 1564 for (i = 0; i < VPIF_CAPTURE_MAX_DEVICES; i++) { 1565 /* Get the pointer to the channel object */ 1566 ch = vpif_obj.dev[i]; 1567 common = &ch->common[VPIF_VIDEO_INDEX]; 1568 1569 if (!vb2_start_streaming_called(&common->buffer_queue)) 1570 continue; 1571 1572 mutex_lock(&common->lock); 1573 /* Disable channel */ 1574 if (ch->channel_id == VPIF_CHANNEL0_VIDEO) { 1575 enable_channel0(0); 1576 channel0_intr_enable(0); 1577 } 1578 if (ch->channel_id == VPIF_CHANNEL1_VIDEO || 1579 ycmux_mode == 2) { 1580 enable_channel1(0); 1581 channel1_intr_enable(0); 1582 } 1583 mutex_unlock(&common->lock); 1584 } 1585 1586 return 0; 1587} 1588 1589/* 1590 * vpif_resume: vpif device suspend 1591 */ 1592static int vpif_resume(struct device *dev) 1593{ 1594 struct common_obj *common; 1595 struct channel_obj *ch; 1596 int i; 1597 1598 for (i = 0; i < VPIF_CAPTURE_MAX_DEVICES; i++) { 1599 /* Get the pointer to the channel object */ 1600 ch = vpif_obj.dev[i]; 1601 common = &ch->common[VPIF_VIDEO_INDEX]; 1602 1603 if (!vb2_start_streaming_called(&common->buffer_queue)) 1604 continue; 1605 1606 mutex_lock(&common->lock); 1607 /* Enable channel */ 1608 if (ch->channel_id == VPIF_CHANNEL0_VIDEO) { 1609 enable_channel0(1); 1610 channel0_intr_enable(1); 1611 } 1612 if (ch->channel_id == VPIF_CHANNEL1_VIDEO || 1613 ycmux_mode == 2) { 1614 enable_channel1(1); 1615 channel1_intr_enable(1); 1616 } 1617 mutex_unlock(&common->lock); 1618 } 1619 1620 return 0; 1621} 1622#endif 1623 1624static SIMPLE_DEV_PM_OPS(vpif_pm_ops, vpif_suspend, vpif_resume); 1625 1626static __refdata struct platform_driver vpif_driver = { 1627 .driver = { 1628 .name = VPIF_DRIVER_NAME, 1629 .pm = &vpif_pm_ops, 1630 }, 1631 .probe = vpif_probe, 1632 .remove = vpif_remove, 1633}; 1634 1635module_platform_driver(vpif_driver); 1636