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