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 26 MODULE_DESCRIPTION("TI DaVinci VPIF Capture driver"); 27 MODULE_LICENSE("GPL"); 28 MODULE_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 34 static int debug = 1; 35 36 module_param(debug, int, 0644); 37 38 MODULE_PARM_DESC(debug, "Debug level 0-1"); 39 40 #define VPIF_DRIVER_NAME "vpif_capture" 41 MODULE_ALIAS("platform:" VPIF_DRIVER_NAME); 42 43 /* global variables */ 44 static struct vpif_device vpif_obj = { {NULL} }; 45 static struct device *vpif_dev; 46 static void vpif_calculate_offsets(struct channel_obj *ch); 47 static void vpif_config_addr(struct channel_obj *ch, int muxmode); 48 49 static 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. */ 52 static int ycmux_mode; 53 54 static inline 55 struct 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 */ 68 static 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 */ 109 static 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 */ 141 static 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 */ 164 static 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 238 err: 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 */ 256 static 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 306 static 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 */ 324 static 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 */ 340 static 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 */ 367 static 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 */ 459 static 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 */ 557 static 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_config_addr() - function to configure buffer address in vpif 623 * @ch: channel ptr 624 * @muxmode: channel mux mode 625 */ 626 static void vpif_config_addr(struct channel_obj *ch, int muxmode) 627 { 628 struct common_obj *common; 629 630 vpif_dbg(2, debug, "vpif_config_addr\n"); 631 632 common = &(ch->common[VPIF_VIDEO_INDEX]); 633 634 if (VPIF_CHANNEL1_VIDEO == ch->channel_id) 635 common->set_addr = ch1_set_video_buf_addr; 636 else if (2 == muxmode) 637 common->set_addr = ch0_set_video_buf_addr_yc_nmux; 638 else 639 common->set_addr = ch0_set_video_buf_addr; 640 } 641 642 /** 643 * vpif_input_to_subdev() - Maps input to sub device 644 * @vpif_cfg: global config ptr 645 * @chan_cfg: channel config ptr 646 * @input_index: Given input index from application 647 * 648 * lookup the sub device information for a given input index. 649 * we report all the inputs to application. inputs table also 650 * has sub device name for the each input 651 */ 652 static int vpif_input_to_subdev( 653 struct vpif_capture_config *vpif_cfg, 654 struct vpif_capture_chan_config *chan_cfg, 655 int input_index) 656 { 657 struct vpif_subdev_info *subdev_info; 658 const char *subdev_name; 659 int i; 660 661 vpif_dbg(2, debug, "vpif_input_to_subdev\n"); 662 663 if (!chan_cfg) 664 return -1; 665 if (input_index >= chan_cfg->input_count) 666 return -1; 667 subdev_name = chan_cfg->inputs[input_index].subdev_name; 668 if (!subdev_name) 669 return -1; 670 671 /* loop through the sub device list to get the sub device info */ 672 for (i = 0; i < vpif_cfg->subdev_count; i++) { 673 subdev_info = &vpif_cfg->subdev_info[i]; 674 if (subdev_info && !strcmp(subdev_info->name, subdev_name)) 675 return i; 676 } 677 return -1; 678 } 679 680 /** 681 * vpif_set_input() - Select an input 682 * @vpif_cfg: global config ptr 683 * @ch: channel 684 * @index: Given input index from application 685 * 686 * Select the given input. 687 */ 688 static int vpif_set_input( 689 struct vpif_capture_config *vpif_cfg, 690 struct channel_obj *ch, 691 int index) 692 { 693 struct vpif_capture_chan_config *chan_cfg = 694 &vpif_cfg->chan_config[ch->channel_id]; 695 struct vpif_subdev_info *subdev_info = NULL; 696 struct v4l2_subdev *sd = NULL; 697 u32 input = 0, output = 0; 698 int sd_index; 699 int ret; 700 701 sd_index = vpif_input_to_subdev(vpif_cfg, chan_cfg, index); 702 if (sd_index >= 0) { 703 sd = vpif_obj.sd[sd_index]; 704 subdev_info = &vpif_cfg->subdev_info[sd_index]; 705 } else { 706 /* no subdevice, no input to setup */ 707 return 0; 708 } 709 710 /* first setup input path from sub device to vpif */ 711 if (sd && vpif_cfg->setup_input_path) { 712 ret = vpif_cfg->setup_input_path(ch->channel_id, 713 subdev_info->name); 714 if (ret < 0) { 715 vpif_dbg(1, debug, "couldn't setup input path for the" \ 716 " sub device %s, for input index %d\n", 717 subdev_info->name, index); 718 return ret; 719 } 720 } 721 722 if (sd) { 723 input = chan_cfg->inputs[index].input_route; 724 output = chan_cfg->inputs[index].output_route; 725 ret = v4l2_subdev_call(sd, video, s_routing, 726 input, output, 0); 727 if (ret < 0 && ret != -ENOIOCTLCMD) { 728 vpif_dbg(1, debug, "Failed to set input\n"); 729 return ret; 730 } 731 } 732 ch->input_idx = index; 733 ch->sd = sd; 734 /* copy interface parameters to vpif */ 735 ch->vpifparams.iface = chan_cfg->vpif_if; 736 737 /* update tvnorms from the sub device input info */ 738 ch->video_dev.tvnorms = chan_cfg->inputs[index].input.std; 739 return 0; 740 } 741 742 /** 743 * vpif_querystd() - querystd handler 744 * @file: file ptr 745 * @priv: file handle 746 * @std_id: ptr to std id 747 * 748 * This function is called to detect standard at the selected input 749 */ 750 static int vpif_querystd(struct file *file, void *priv, v4l2_std_id *std_id) 751 { 752 struct video_device *vdev = video_devdata(file); 753 struct channel_obj *ch = video_get_drvdata(vdev); 754 int ret; 755 756 vpif_dbg(2, debug, "vpif_querystd\n"); 757 758 /* Call querystd function of decoder device */ 759 ret = v4l2_subdev_call(ch->sd, video, querystd, std_id); 760 761 if (ret == -ENOIOCTLCMD || ret == -ENODEV) 762 return -ENODATA; 763 if (ret) { 764 vpif_dbg(1, debug, "Failed to query standard for sub devices\n"); 765 return ret; 766 } 767 768 return 0; 769 } 770 771 /** 772 * vpif_g_std() - get STD handler 773 * @file: file ptr 774 * @priv: file handle 775 * @std: ptr to std id 776 */ 777 static int vpif_g_std(struct file *file, void *priv, v4l2_std_id *std) 778 { 779 struct vpif_capture_config *config = vpif_dev->platform_data; 780 struct video_device *vdev = video_devdata(file); 781 struct channel_obj *ch = video_get_drvdata(vdev); 782 struct vpif_capture_chan_config *chan_cfg; 783 struct v4l2_input input; 784 785 vpif_dbg(2, debug, "vpif_g_std\n"); 786 787 if (!config->chan_config[ch->channel_id].inputs) 788 return -ENODATA; 789 790 chan_cfg = &config->chan_config[ch->channel_id]; 791 input = chan_cfg->inputs[ch->input_idx].input; 792 if (input.capabilities != V4L2_IN_CAP_STD) 793 return -ENODATA; 794 795 *std = ch->video.stdid; 796 return 0; 797 } 798 799 /** 800 * vpif_s_std() - set STD handler 801 * @file: file ptr 802 * @priv: file handle 803 * @std_id: ptr to std id 804 */ 805 static int vpif_s_std(struct file *file, void *priv, v4l2_std_id std_id) 806 { 807 struct vpif_capture_config *config = vpif_dev->platform_data; 808 struct video_device *vdev = video_devdata(file); 809 struct channel_obj *ch = video_get_drvdata(vdev); 810 struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX]; 811 struct vpif_capture_chan_config *chan_cfg; 812 struct v4l2_input input; 813 int ret; 814 815 vpif_dbg(2, debug, "vpif_s_std\n"); 816 817 if (!config->chan_config[ch->channel_id].inputs) 818 return -ENODATA; 819 820 chan_cfg = &config->chan_config[ch->channel_id]; 821 input = chan_cfg->inputs[ch->input_idx].input; 822 if (input.capabilities != V4L2_IN_CAP_STD) 823 return -ENODATA; 824 825 if (vb2_is_busy(&common->buffer_queue)) 826 return -EBUSY; 827 828 /* Call encoder subdevice function to set the standard */ 829 ch->video.stdid = std_id; 830 memset(&ch->video.dv_timings, 0, sizeof(ch->video.dv_timings)); 831 832 /* Get the information about the standard */ 833 if (vpif_update_std_info(ch)) { 834 vpif_err("Error getting the standard info\n"); 835 return -EINVAL; 836 } 837 838 /* set standard in the sub device */ 839 ret = v4l2_subdev_call(ch->sd, video, s_std, std_id); 840 if (ret && ret != -ENOIOCTLCMD && ret != -ENODEV) { 841 vpif_dbg(1, debug, "Failed to set standard for sub devices\n"); 842 return ret; 843 } 844 return 0; 845 } 846 847 /** 848 * vpif_enum_input() - ENUMINPUT handler 849 * @file: file ptr 850 * @priv: file handle 851 * @input: ptr to input structure 852 */ 853 static int vpif_enum_input(struct file *file, void *priv, 854 struct v4l2_input *input) 855 { 856 857 struct vpif_capture_config *config = vpif_dev->platform_data; 858 struct video_device *vdev = video_devdata(file); 859 struct channel_obj *ch = video_get_drvdata(vdev); 860 struct vpif_capture_chan_config *chan_cfg; 861 862 chan_cfg = &config->chan_config[ch->channel_id]; 863 864 if (input->index >= chan_cfg->input_count) 865 return -EINVAL; 866 867 memcpy(input, &chan_cfg->inputs[input->index].input, 868 sizeof(*input)); 869 return 0; 870 } 871 872 /** 873 * vpif_g_input() - Get INPUT handler 874 * @file: file ptr 875 * @priv: file handle 876 * @index: ptr to input index 877 */ 878 static int vpif_g_input(struct file *file, void *priv, unsigned int *index) 879 { 880 struct video_device *vdev = video_devdata(file); 881 struct channel_obj *ch = video_get_drvdata(vdev); 882 883 *index = ch->input_idx; 884 return 0; 885 } 886 887 /** 888 * vpif_s_input() - Set INPUT handler 889 * @file: file ptr 890 * @priv: file handle 891 * @index: input index 892 */ 893 static int vpif_s_input(struct file *file, void *priv, unsigned int index) 894 { 895 struct vpif_capture_config *config = vpif_dev->platform_data; 896 struct video_device *vdev = video_devdata(file); 897 struct channel_obj *ch = video_get_drvdata(vdev); 898 struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX]; 899 struct vpif_capture_chan_config *chan_cfg; 900 901 chan_cfg = &config->chan_config[ch->channel_id]; 902 903 if (index >= chan_cfg->input_count) 904 return -EINVAL; 905 906 if (vb2_is_busy(&common->buffer_queue)) 907 return -EBUSY; 908 909 return vpif_set_input(config, ch, index); 910 } 911 912 /** 913 * vpif_enum_fmt_vid_cap() - ENUM_FMT handler 914 * @file: file ptr 915 * @priv: file handle 916 * @fmt: ptr to V4L2 format descriptor 917 */ 918 static int vpif_enum_fmt_vid_cap(struct file *file, void *priv, 919 struct v4l2_fmtdesc *fmt) 920 { 921 struct video_device *vdev = video_devdata(file); 922 struct channel_obj *ch = video_get_drvdata(vdev); 923 924 if (fmt->index != 0) { 925 vpif_dbg(1, debug, "Invalid format index\n"); 926 return -EINVAL; 927 } 928 929 /* Fill in the information about format */ 930 if (ch->vpifparams.iface.if_type == VPIF_IF_RAW_BAYER) 931 fmt->pixelformat = V4L2_PIX_FMT_SBGGR8; 932 else 933 fmt->pixelformat = V4L2_PIX_FMT_NV16; 934 return 0; 935 } 936 937 /** 938 * vpif_try_fmt_vid_cap() - TRY_FMT handler 939 * @file: file ptr 940 * @priv: file handle 941 * @fmt: ptr to v4l2 format structure 942 */ 943 static int vpif_try_fmt_vid_cap(struct file *file, void *priv, 944 struct v4l2_format *fmt) 945 { 946 struct video_device *vdev = video_devdata(file); 947 struct channel_obj *ch = video_get_drvdata(vdev); 948 struct v4l2_pix_format *pixfmt = &fmt->fmt.pix; 949 struct common_obj *common = &(ch->common[VPIF_VIDEO_INDEX]); 950 951 common->fmt = *fmt; 952 vpif_update_std_info(ch); 953 954 pixfmt->field = common->fmt.fmt.pix.field; 955 pixfmt->colorspace = common->fmt.fmt.pix.colorspace; 956 pixfmt->bytesperline = common->fmt.fmt.pix.width; 957 pixfmt->width = common->fmt.fmt.pix.width; 958 pixfmt->height = common->fmt.fmt.pix.height; 959 pixfmt->sizeimage = pixfmt->bytesperline * pixfmt->height * 2; 960 if (pixfmt->pixelformat == V4L2_PIX_FMT_SGRBG10) { 961 pixfmt->bytesperline = common->fmt.fmt.pix.width * 2; 962 pixfmt->sizeimage = pixfmt->bytesperline * pixfmt->height; 963 } 964 965 dev_dbg(vpif_dev, "%s: %d x %d; pitch=%d pixelformat=0x%08x, field=%d, size=%d\n", __func__, 966 pixfmt->width, pixfmt->height, 967 pixfmt->bytesperline, pixfmt->pixelformat, 968 pixfmt->field, pixfmt->sizeimage); 969 970 return 0; 971 } 972 973 974 /** 975 * vpif_g_fmt_vid_cap() - Set INPUT handler 976 * @file: file ptr 977 * @priv: file handle 978 * @fmt: ptr to v4l2 format structure 979 */ 980 static int vpif_g_fmt_vid_cap(struct file *file, void *priv, 981 struct v4l2_format *fmt) 982 { 983 struct video_device *vdev = video_devdata(file); 984 struct channel_obj *ch = video_get_drvdata(vdev); 985 struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX]; 986 struct v4l2_pix_format *pix_fmt = &fmt->fmt.pix; 987 struct v4l2_subdev_format format = { 988 .which = V4L2_SUBDEV_FORMAT_ACTIVE, 989 }; 990 struct v4l2_mbus_framefmt *mbus_fmt = &format.format; 991 int ret; 992 993 /* Check the validity of the buffer type */ 994 if (common->fmt.type != fmt->type) 995 return -EINVAL; 996 997 /* By default, use currently set fmt */ 998 *fmt = common->fmt; 999 1000 /* If subdev has get_fmt, use that to override */ 1001 ret = v4l2_subdev_call(ch->sd, pad, get_fmt, NULL, &format); 1002 if (!ret && mbus_fmt->code) { 1003 v4l2_fill_pix_format(pix_fmt, mbus_fmt); 1004 pix_fmt->bytesperline = pix_fmt->width; 1005 if (mbus_fmt->code == MEDIA_BUS_FMT_SGRBG10_1X10) { 1006 /* e.g. mt9v032 */ 1007 pix_fmt->pixelformat = V4L2_PIX_FMT_SGRBG10; 1008 pix_fmt->bytesperline = pix_fmt->width * 2; 1009 } else if (mbus_fmt->code == MEDIA_BUS_FMT_UYVY8_2X8) { 1010 /* e.g. tvp514x */ 1011 pix_fmt->pixelformat = V4L2_PIX_FMT_NV16; 1012 pix_fmt->bytesperline = pix_fmt->width * 2; 1013 } else { 1014 dev_warn(vpif_dev, "%s: Unhandled media-bus format 0x%x\n", 1015 __func__, mbus_fmt->code); 1016 } 1017 pix_fmt->sizeimage = pix_fmt->bytesperline * pix_fmt->height; 1018 dev_dbg(vpif_dev, "%s: %d x %d; pitch=%d, pixelformat=0x%08x, code=0x%x, field=%d, size=%d\n", __func__, 1019 pix_fmt->width, pix_fmt->height, 1020 pix_fmt->bytesperline, pix_fmt->pixelformat, 1021 mbus_fmt->code, pix_fmt->field, pix_fmt->sizeimage); 1022 1023 common->fmt = *fmt; 1024 vpif_update_std_info(ch); 1025 } 1026 1027 return 0; 1028 } 1029 1030 /** 1031 * vpif_s_fmt_vid_cap() - Set FMT handler 1032 * @file: file ptr 1033 * @priv: file handle 1034 * @fmt: ptr to v4l2 format structure 1035 */ 1036 static int vpif_s_fmt_vid_cap(struct file *file, void *priv, 1037 struct v4l2_format *fmt) 1038 { 1039 struct video_device *vdev = video_devdata(file); 1040 struct channel_obj *ch = video_get_drvdata(vdev); 1041 struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX]; 1042 int ret; 1043 1044 vpif_dbg(2, debug, "%s\n", __func__); 1045 1046 if (vb2_is_busy(&common->buffer_queue)) 1047 return -EBUSY; 1048 1049 ret = vpif_try_fmt_vid_cap(file, priv, fmt); 1050 if (ret) 1051 return ret; 1052 1053 /* store the format in the channel object */ 1054 common->fmt = *fmt; 1055 return 0; 1056 } 1057 1058 /** 1059 * vpif_querycap() - QUERYCAP handler 1060 * @file: file ptr 1061 * @priv: file handle 1062 * @cap: ptr to v4l2_capability structure 1063 */ 1064 static int vpif_querycap(struct file *file, void *priv, 1065 struct v4l2_capability *cap) 1066 { 1067 struct vpif_capture_config *config = vpif_dev->platform_data; 1068 1069 strscpy(cap->driver, VPIF_DRIVER_NAME, sizeof(cap->driver)); 1070 strscpy(cap->card, config->card_name, sizeof(cap->card)); 1071 1072 return 0; 1073 } 1074 1075 /** 1076 * vpif_enum_dv_timings() - ENUM_DV_TIMINGS handler 1077 * @file: file ptr 1078 * @priv: file handle 1079 * @timings: input timings 1080 */ 1081 static int 1082 vpif_enum_dv_timings(struct file *file, void *priv, 1083 struct v4l2_enum_dv_timings *timings) 1084 { 1085 struct vpif_capture_config *config = vpif_dev->platform_data; 1086 struct video_device *vdev = video_devdata(file); 1087 struct channel_obj *ch = video_get_drvdata(vdev); 1088 struct vpif_capture_chan_config *chan_cfg; 1089 struct v4l2_input input; 1090 int ret; 1091 1092 if (!config->chan_config[ch->channel_id].inputs) 1093 return -ENODATA; 1094 1095 chan_cfg = &config->chan_config[ch->channel_id]; 1096 input = chan_cfg->inputs[ch->input_idx].input; 1097 if (input.capabilities != V4L2_IN_CAP_DV_TIMINGS) 1098 return -ENODATA; 1099 1100 timings->pad = 0; 1101 1102 ret = v4l2_subdev_call(ch->sd, pad, enum_dv_timings, timings); 1103 if (ret == -ENOIOCTLCMD || ret == -ENODEV) 1104 return -EINVAL; 1105 1106 return ret; 1107 } 1108 1109 /** 1110 * vpif_query_dv_timings() - QUERY_DV_TIMINGS handler 1111 * @file: file ptr 1112 * @priv: file handle 1113 * @timings: input timings 1114 */ 1115 static int 1116 vpif_query_dv_timings(struct file *file, void *priv, 1117 struct v4l2_dv_timings *timings) 1118 { 1119 struct vpif_capture_config *config = vpif_dev->platform_data; 1120 struct video_device *vdev = video_devdata(file); 1121 struct channel_obj *ch = video_get_drvdata(vdev); 1122 struct vpif_capture_chan_config *chan_cfg; 1123 struct v4l2_input input; 1124 int ret; 1125 1126 if (!config->chan_config[ch->channel_id].inputs) 1127 return -ENODATA; 1128 1129 chan_cfg = &config->chan_config[ch->channel_id]; 1130 input = chan_cfg->inputs[ch->input_idx].input; 1131 if (input.capabilities != V4L2_IN_CAP_DV_TIMINGS) 1132 return -ENODATA; 1133 1134 ret = v4l2_subdev_call(ch->sd, video, query_dv_timings, timings); 1135 if (ret == -ENOIOCTLCMD || ret == -ENODEV) 1136 return -ENODATA; 1137 1138 return ret; 1139 } 1140 1141 /** 1142 * vpif_s_dv_timings() - S_DV_TIMINGS handler 1143 * @file: file ptr 1144 * @priv: file handle 1145 * @timings: digital video timings 1146 */ 1147 static int vpif_s_dv_timings(struct file *file, void *priv, 1148 struct v4l2_dv_timings *timings) 1149 { 1150 struct vpif_capture_config *config = vpif_dev->platform_data; 1151 struct video_device *vdev = video_devdata(file); 1152 struct channel_obj *ch = video_get_drvdata(vdev); 1153 struct vpif_params *vpifparams = &ch->vpifparams; 1154 struct vpif_channel_config_params *std_info = &vpifparams->std_info; 1155 struct common_obj *common = &ch->common[VPIF_VIDEO_INDEX]; 1156 struct video_obj *vid_ch = &ch->video; 1157 struct v4l2_bt_timings *bt = &vid_ch->dv_timings.bt; 1158 struct vpif_capture_chan_config *chan_cfg; 1159 struct v4l2_input input; 1160 int ret; 1161 1162 if (!config->chan_config[ch->channel_id].inputs) 1163 return -ENODATA; 1164 1165 chan_cfg = &config->chan_config[ch->channel_id]; 1166 input = chan_cfg->inputs[ch->input_idx].input; 1167 if (input.capabilities != V4L2_IN_CAP_DV_TIMINGS) 1168 return -ENODATA; 1169 1170 if (timings->type != V4L2_DV_BT_656_1120) { 1171 vpif_dbg(2, debug, "Timing type not defined\n"); 1172 return -EINVAL; 1173 } 1174 1175 if (vb2_is_busy(&common->buffer_queue)) 1176 return -EBUSY; 1177 1178 /* Configure subdevice timings, if any */ 1179 ret = v4l2_subdev_call(ch->sd, video, s_dv_timings, timings); 1180 if (ret == -ENOIOCTLCMD || ret == -ENODEV) 1181 ret = 0; 1182 if (ret < 0) { 1183 vpif_dbg(2, debug, "Error setting custom DV timings\n"); 1184 return ret; 1185 } 1186 1187 if (!(timings->bt.width && timings->bt.height && 1188 (timings->bt.hbackporch || 1189 timings->bt.hfrontporch || 1190 timings->bt.hsync) && 1191 timings->bt.vfrontporch && 1192 (timings->bt.vbackporch || 1193 timings->bt.vsync))) { 1194 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"); 1195 return -EINVAL; 1196 } 1197 1198 vid_ch->dv_timings = *timings; 1199 1200 /* Configure video port timings */ 1201 1202 std_info->eav2sav = V4L2_DV_BT_BLANKING_WIDTH(bt) - 8; 1203 std_info->sav2eav = bt->width; 1204 1205 std_info->l1 = 1; 1206 std_info->l3 = bt->vsync + bt->vbackporch + 1; 1207 1208 std_info->vsize = V4L2_DV_BT_FRAME_HEIGHT(bt); 1209 if (bt->interlaced) { 1210 if (bt->il_vbackporch || bt->il_vfrontporch || bt->il_vsync) { 1211 std_info->l5 = std_info->vsize/2 - 1212 (bt->vfrontporch - 1); 1213 std_info->l7 = std_info->vsize/2 + 1; 1214 std_info->l9 = std_info->l7 + bt->il_vsync + 1215 bt->il_vbackporch + 1; 1216 std_info->l11 = std_info->vsize - 1217 (bt->il_vfrontporch - 1); 1218 } else { 1219 vpif_dbg(2, debug, "Required timing values for interlaced BT format missing\n"); 1220 return -EINVAL; 1221 } 1222 } else { 1223 std_info->l5 = std_info->vsize - (bt->vfrontporch - 1); 1224 } 1225 strscpy(std_info->name, "Custom timings BT656/1120", 1226 sizeof(std_info->name)); 1227 std_info->width = bt->width; 1228 std_info->height = bt->height; 1229 std_info->frm_fmt = bt->interlaced ? 0 : 1; 1230 std_info->ycmux_mode = 0; 1231 std_info->capture_format = 0; 1232 std_info->vbi_supported = 0; 1233 std_info->hd_sd = 1; 1234 std_info->stdid = 0; 1235 1236 vid_ch->stdid = 0; 1237 return 0; 1238 } 1239 1240 /** 1241 * vpif_g_dv_timings() - G_DV_TIMINGS handler 1242 * @file: file ptr 1243 * @priv: file handle 1244 * @timings: digital video timings 1245 */ 1246 static int vpif_g_dv_timings(struct file *file, void *priv, 1247 struct v4l2_dv_timings *timings) 1248 { 1249 struct vpif_capture_config *config = vpif_dev->platform_data; 1250 struct video_device *vdev = video_devdata(file); 1251 struct channel_obj *ch = video_get_drvdata(vdev); 1252 struct video_obj *vid_ch = &ch->video; 1253 struct vpif_capture_chan_config *chan_cfg; 1254 struct v4l2_input input; 1255 1256 if (!config->chan_config[ch->channel_id].inputs) 1257 return -ENODATA; 1258 1259 chan_cfg = &config->chan_config[ch->channel_id]; 1260 input = chan_cfg->inputs[ch->input_idx].input; 1261 if (input.capabilities != V4L2_IN_CAP_DV_TIMINGS) 1262 return -ENODATA; 1263 1264 *timings = vid_ch->dv_timings; 1265 1266 return 0; 1267 } 1268 1269 /* 1270 * vpif_log_status() - Status information 1271 * @file: file ptr 1272 * @priv: file handle 1273 * 1274 * Returns zero. 1275 */ 1276 static int vpif_log_status(struct file *filep, void *priv) 1277 { 1278 /* status for sub devices */ 1279 v4l2_device_call_all(&vpif_obj.v4l2_dev, 0, core, log_status); 1280 1281 return 0; 1282 } 1283 1284 /* vpif capture ioctl operations */ 1285 static const struct v4l2_ioctl_ops vpif_ioctl_ops = { 1286 .vidioc_querycap = vpif_querycap, 1287 .vidioc_enum_fmt_vid_cap = vpif_enum_fmt_vid_cap, 1288 .vidioc_g_fmt_vid_cap = vpif_g_fmt_vid_cap, 1289 .vidioc_s_fmt_vid_cap = vpif_s_fmt_vid_cap, 1290 .vidioc_try_fmt_vid_cap = vpif_try_fmt_vid_cap, 1291 1292 .vidioc_enum_input = vpif_enum_input, 1293 .vidioc_s_input = vpif_s_input, 1294 .vidioc_g_input = vpif_g_input, 1295 1296 .vidioc_reqbufs = vb2_ioctl_reqbufs, 1297 .vidioc_create_bufs = vb2_ioctl_create_bufs, 1298 .vidioc_querybuf = vb2_ioctl_querybuf, 1299 .vidioc_qbuf = vb2_ioctl_qbuf, 1300 .vidioc_dqbuf = vb2_ioctl_dqbuf, 1301 .vidioc_expbuf = vb2_ioctl_expbuf, 1302 .vidioc_streamon = vb2_ioctl_streamon, 1303 .vidioc_streamoff = vb2_ioctl_streamoff, 1304 1305 .vidioc_querystd = vpif_querystd, 1306 .vidioc_s_std = vpif_s_std, 1307 .vidioc_g_std = vpif_g_std, 1308 1309 .vidioc_enum_dv_timings = vpif_enum_dv_timings, 1310 .vidioc_query_dv_timings = vpif_query_dv_timings, 1311 .vidioc_s_dv_timings = vpif_s_dv_timings, 1312 .vidioc_g_dv_timings = vpif_g_dv_timings, 1313 1314 .vidioc_log_status = vpif_log_status, 1315 }; 1316 1317 /* vpif file operations */ 1318 static const struct v4l2_file_operations vpif_fops = { 1319 .owner = THIS_MODULE, 1320 .open = v4l2_fh_open, 1321 .release = vb2_fop_release, 1322 .unlocked_ioctl = video_ioctl2, 1323 .mmap = vb2_fop_mmap, 1324 .poll = vb2_fop_poll 1325 }; 1326 1327 /** 1328 * initialize_vpif() - Initialize vpif data structures 1329 * 1330 * Allocate memory for data structures and initialize them 1331 */ 1332 static int initialize_vpif(void) 1333 { 1334 int err, i, j; 1335 int free_channel_objects_index; 1336 1337 /* Allocate memory for six channel objects */ 1338 for (i = 0; i < VPIF_CAPTURE_MAX_DEVICES; i++) { 1339 vpif_obj.dev[i] = 1340 kzalloc(sizeof(*vpif_obj.dev[i]), GFP_KERNEL); 1341 /* If memory allocation fails, return error */ 1342 if (!vpif_obj.dev[i]) { 1343 free_channel_objects_index = i; 1344 err = -ENOMEM; 1345 goto vpif_init_free_channel_objects; 1346 } 1347 } 1348 return 0; 1349 1350 vpif_init_free_channel_objects: 1351 for (j = 0; j < free_channel_objects_index; j++) 1352 kfree(vpif_obj.dev[j]); 1353 return err; 1354 } 1355 1356 static inline void free_vpif_objs(void) 1357 { 1358 int i; 1359 1360 for (i = 0; i < VPIF_CAPTURE_MAX_DEVICES; i++) 1361 kfree(vpif_obj.dev[i]); 1362 } 1363 1364 static int vpif_async_bound(struct v4l2_async_notifier *notifier, 1365 struct v4l2_subdev *subdev, 1366 struct v4l2_async_subdev *asd) 1367 { 1368 int i; 1369 1370 for (i = 0; i < vpif_obj.config->asd_sizes[0]; i++) { 1371 struct v4l2_async_subdev *_asd = vpif_obj.config->asd[i]; 1372 const struct fwnode_handle *fwnode = _asd->match.fwnode; 1373 1374 if (fwnode == subdev->fwnode) { 1375 vpif_obj.sd[i] = subdev; 1376 vpif_obj.config->chan_config->inputs[i].subdev_name = 1377 (char *)to_of_node(subdev->fwnode)->full_name; 1378 vpif_dbg(2, debug, 1379 "%s: setting input %d subdev_name = %s\n", 1380 __func__, i, 1381 vpif_obj.config->chan_config->inputs[i].subdev_name); 1382 return 0; 1383 } 1384 } 1385 1386 for (i = 0; i < vpif_obj.config->subdev_count; i++) 1387 if (!strcmp(vpif_obj.config->subdev_info[i].name, 1388 subdev->name)) { 1389 vpif_obj.sd[i] = subdev; 1390 return 0; 1391 } 1392 1393 return -EINVAL; 1394 } 1395 1396 static int vpif_probe_complete(void) 1397 { 1398 struct common_obj *common; 1399 struct video_device *vdev; 1400 struct channel_obj *ch; 1401 struct vb2_queue *q; 1402 int j, err, k; 1403 1404 for (j = 0; j < VPIF_CAPTURE_MAX_DEVICES; j++) { 1405 ch = vpif_obj.dev[j]; 1406 ch->channel_id = j; 1407 common = &(ch->common[VPIF_VIDEO_INDEX]); 1408 spin_lock_init(&common->irqlock); 1409 mutex_init(&common->lock); 1410 1411 /* select input 0 */ 1412 err = vpif_set_input(vpif_obj.config, ch, 0); 1413 if (err) 1414 goto probe_out; 1415 1416 /* set initial format */ 1417 ch->video.stdid = V4L2_STD_525_60; 1418 memset(&ch->video.dv_timings, 0, sizeof(ch->video.dv_timings)); 1419 common->fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 1420 vpif_update_std_info(ch); 1421 1422 /* Initialize vb2 queue */ 1423 q = &common->buffer_queue; 1424 q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 1425 q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF; 1426 q->drv_priv = ch; 1427 q->ops = &video_qops; 1428 q->mem_ops = &vb2_dma_contig_memops; 1429 q->buf_struct_size = sizeof(struct vpif_cap_buffer); 1430 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1431 q->min_buffers_needed = 1; 1432 q->lock = &common->lock; 1433 q->dev = vpif_dev; 1434 1435 err = vb2_queue_init(q); 1436 if (err) { 1437 vpif_err("vpif_capture: vb2_queue_init() failed\n"); 1438 goto probe_out; 1439 } 1440 1441 INIT_LIST_HEAD(&common->dma_queue); 1442 1443 /* Initialize the video_device structure */ 1444 vdev = &ch->video_dev; 1445 strscpy(vdev->name, VPIF_DRIVER_NAME, sizeof(vdev->name)); 1446 vdev->release = video_device_release_empty; 1447 vdev->fops = &vpif_fops; 1448 vdev->ioctl_ops = &vpif_ioctl_ops; 1449 vdev->v4l2_dev = &vpif_obj.v4l2_dev; 1450 vdev->vfl_dir = VFL_DIR_RX; 1451 vdev->queue = q; 1452 vdev->lock = &common->lock; 1453 vdev->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING; 1454 video_set_drvdata(&ch->video_dev, ch); 1455 err = video_register_device(vdev, 1456 VFL_TYPE_VIDEO, (j ? 1 : 0)); 1457 if (err) 1458 goto probe_out; 1459 } 1460 1461 v4l2_info(&vpif_obj.v4l2_dev, "VPIF capture driver initialized\n"); 1462 return 0; 1463 1464 probe_out: 1465 for (k = 0; k < j; k++) { 1466 /* Get the pointer to the channel object */ 1467 ch = vpif_obj.dev[k]; 1468 /* Unregister video device */ 1469 video_unregister_device(&ch->video_dev); 1470 } 1471 1472 return err; 1473 } 1474 1475 static int vpif_async_complete(struct v4l2_async_notifier *notifier) 1476 { 1477 return vpif_probe_complete(); 1478 } 1479 1480 static const struct v4l2_async_notifier_operations vpif_async_ops = { 1481 .bound = vpif_async_bound, 1482 .complete = vpif_async_complete, 1483 }; 1484 1485 static struct vpif_capture_config * 1486 vpif_capture_get_pdata(struct platform_device *pdev) 1487 { 1488 struct device_node *endpoint = NULL; 1489 struct device_node *rem = NULL; 1490 struct vpif_capture_config *pdata; 1491 struct vpif_subdev_info *sdinfo; 1492 struct vpif_capture_chan_config *chan; 1493 unsigned int i; 1494 1495 v4l2_async_nf_init(&vpif_obj.notifier); 1496 1497 /* 1498 * DT boot: OF node from parent device contains 1499 * video ports & endpoints data. 1500 */ 1501 if (pdev->dev.parent && pdev->dev.parent->of_node) 1502 pdev->dev.of_node = pdev->dev.parent->of_node; 1503 if (!IS_ENABLED(CONFIG_OF) || !pdev->dev.of_node) 1504 return pdev->dev.platform_data; 1505 1506 pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL); 1507 if (!pdata) 1508 return NULL; 1509 pdata->subdev_info = 1510 devm_kcalloc(&pdev->dev, 1511 VPIF_CAPTURE_NUM_CHANNELS, 1512 sizeof(*pdata->subdev_info), 1513 GFP_KERNEL); 1514 1515 if (!pdata->subdev_info) 1516 return NULL; 1517 1518 for (i = 0; i < VPIF_CAPTURE_NUM_CHANNELS; i++) { 1519 struct v4l2_fwnode_endpoint bus_cfg = { .bus_type = 0 }; 1520 unsigned int flags; 1521 int err; 1522 1523 endpoint = of_graph_get_next_endpoint(pdev->dev.of_node, 1524 endpoint); 1525 if (!endpoint) 1526 break; 1527 1528 rem = of_graph_get_remote_port_parent(endpoint); 1529 if (!rem) { 1530 dev_dbg(&pdev->dev, "Remote device at %pOF not found\n", 1531 endpoint); 1532 goto done; 1533 } 1534 1535 sdinfo = &pdata->subdev_info[i]; 1536 chan = &pdata->chan_config[i]; 1537 chan->inputs = devm_kcalloc(&pdev->dev, 1538 VPIF_CAPTURE_NUM_CHANNELS, 1539 sizeof(*chan->inputs), 1540 GFP_KERNEL); 1541 if (!chan->inputs) 1542 goto err_cleanup; 1543 1544 chan->input_count++; 1545 chan->inputs[i].input.type = V4L2_INPUT_TYPE_CAMERA; 1546 chan->inputs[i].input.std = V4L2_STD_ALL; 1547 chan->inputs[i].input.capabilities = V4L2_IN_CAP_STD; 1548 1549 err = v4l2_fwnode_endpoint_parse(of_fwnode_handle(endpoint), 1550 &bus_cfg); 1551 if (err) { 1552 dev_err(&pdev->dev, "Could not parse the endpoint\n"); 1553 of_node_put(rem); 1554 goto done; 1555 } 1556 1557 dev_dbg(&pdev->dev, "Endpoint %pOF, bus_width = %d\n", 1558 endpoint, bus_cfg.bus.parallel.bus_width); 1559 1560 flags = bus_cfg.bus.parallel.flags; 1561 1562 if (flags & V4L2_MBUS_HSYNC_ACTIVE_HIGH) 1563 chan->vpif_if.hd_pol = 1; 1564 1565 if (flags & V4L2_MBUS_VSYNC_ACTIVE_HIGH) 1566 chan->vpif_if.vd_pol = 1; 1567 1568 dev_dbg(&pdev->dev, "Remote device %pOF found\n", rem); 1569 sdinfo->name = rem->full_name; 1570 1571 pdata->asd[i] = v4l2_async_nf_add_fwnode(&vpif_obj.notifier, 1572 of_fwnode_handle(rem), 1573 struct 1574 v4l2_async_subdev); 1575 if (IS_ERR(pdata->asd[i])) 1576 goto err_cleanup; 1577 1578 of_node_put(rem); 1579 } 1580 1581 done: 1582 of_node_put(endpoint); 1583 pdata->asd_sizes[0] = i; 1584 pdata->subdev_count = i; 1585 pdata->card_name = "DA850/OMAP-L138 Video Capture"; 1586 1587 return pdata; 1588 1589 err_cleanup: 1590 of_node_put(rem); 1591 of_node_put(endpoint); 1592 v4l2_async_nf_cleanup(&vpif_obj.notifier); 1593 1594 return NULL; 1595 } 1596 1597 /** 1598 * vpif_probe : This function probes the vpif capture driver 1599 * @pdev: platform device pointer 1600 * 1601 * This creates device entries by register itself to the V4L2 driver and 1602 * initializes fields of each channel objects 1603 */ 1604 static __init int vpif_probe(struct platform_device *pdev) 1605 { 1606 struct vpif_subdev_info *subdevdata; 1607 struct i2c_adapter *i2c_adap; 1608 int subdev_count; 1609 int res_idx = 0; 1610 int i, err; 1611 1612 pdev->dev.platform_data = vpif_capture_get_pdata(pdev); 1613 if (!pdev->dev.platform_data) { 1614 dev_warn(&pdev->dev, "Missing platform data. Giving up.\n"); 1615 return -EINVAL; 1616 } 1617 1618 vpif_dev = &pdev->dev; 1619 1620 err = initialize_vpif(); 1621 if (err) { 1622 v4l2_err(vpif_dev->driver, "Error initializing vpif\n"); 1623 goto cleanup; 1624 } 1625 1626 err = v4l2_device_register(vpif_dev, &vpif_obj.v4l2_dev); 1627 if (err) { 1628 v4l2_err(vpif_dev->driver, "Error registering v4l2 device\n"); 1629 goto vpif_free; 1630 } 1631 1632 do { 1633 int irq; 1634 1635 err = platform_get_irq_optional(pdev, res_idx); 1636 if (err < 0 && err != -ENXIO) 1637 goto vpif_unregister; 1638 if (err > 0) 1639 irq = err; 1640 else 1641 break; 1642 1643 err = devm_request_irq(&pdev->dev, irq, vpif_channel_isr, 1644 IRQF_SHARED, VPIF_DRIVER_NAME, 1645 (void *)(&vpif_obj.dev[res_idx]->channel_id)); 1646 if (err) 1647 goto vpif_unregister; 1648 } while (++res_idx); 1649 1650 vpif_obj.config = pdev->dev.platform_data; 1651 1652 subdev_count = vpif_obj.config->subdev_count; 1653 vpif_obj.sd = kcalloc(subdev_count, sizeof(*vpif_obj.sd), GFP_KERNEL); 1654 if (!vpif_obj.sd) { 1655 err = -ENOMEM; 1656 goto vpif_unregister; 1657 } 1658 1659 if (!vpif_obj.config->asd_sizes[0]) { 1660 int i2c_id = vpif_obj.config->i2c_adapter_id; 1661 1662 i2c_adap = i2c_get_adapter(i2c_id); 1663 WARN_ON(!i2c_adap); 1664 for (i = 0; i < subdev_count; i++) { 1665 subdevdata = &vpif_obj.config->subdev_info[i]; 1666 vpif_obj.sd[i] = 1667 v4l2_i2c_new_subdev_board(&vpif_obj.v4l2_dev, 1668 i2c_adap, 1669 &subdevdata-> 1670 board_info, 1671 NULL); 1672 1673 if (!vpif_obj.sd[i]) { 1674 vpif_err("Error registering v4l2 subdevice\n"); 1675 err = -ENODEV; 1676 goto probe_subdev_out; 1677 } 1678 v4l2_info(&vpif_obj.v4l2_dev, 1679 "registered sub device %s\n", 1680 subdevdata->name); 1681 } 1682 err = vpif_probe_complete(); 1683 if (err) 1684 goto probe_subdev_out; 1685 } else { 1686 vpif_obj.notifier.ops = &vpif_async_ops; 1687 err = v4l2_async_nf_register(&vpif_obj.v4l2_dev, 1688 &vpif_obj.notifier); 1689 if (err) { 1690 vpif_err("Error registering async notifier\n"); 1691 err = -EINVAL; 1692 goto probe_subdev_out; 1693 } 1694 } 1695 1696 return 0; 1697 1698 probe_subdev_out: 1699 /* free sub devices memory */ 1700 kfree(vpif_obj.sd); 1701 vpif_unregister: 1702 v4l2_device_unregister(&vpif_obj.v4l2_dev); 1703 vpif_free: 1704 free_vpif_objs(); 1705 cleanup: 1706 v4l2_async_nf_cleanup(&vpif_obj.notifier); 1707 1708 return err; 1709 } 1710 1711 /** 1712 * vpif_remove() - driver remove handler 1713 * @device: ptr to platform device structure 1714 * 1715 * The vidoe device is unregistered 1716 */ 1717 static void vpif_remove(struct platform_device *device) 1718 { 1719 struct channel_obj *ch; 1720 int i; 1721 1722 v4l2_async_nf_unregister(&vpif_obj.notifier); 1723 v4l2_async_nf_cleanup(&vpif_obj.notifier); 1724 v4l2_device_unregister(&vpif_obj.v4l2_dev); 1725 1726 kfree(vpif_obj.sd); 1727 /* un-register device */ 1728 for (i = 0; i < VPIF_CAPTURE_MAX_DEVICES; i++) { 1729 /* Get the pointer to the channel object */ 1730 ch = vpif_obj.dev[i]; 1731 /* Unregister video device */ 1732 video_unregister_device(&ch->video_dev); 1733 kfree(vpif_obj.dev[i]); 1734 } 1735 } 1736 1737 #ifdef CONFIG_PM_SLEEP 1738 /** 1739 * vpif_suspend: vpif device suspend 1740 * @dev: pointer to &struct device 1741 */ 1742 static int vpif_suspend(struct device *dev) 1743 { 1744 1745 struct common_obj *common; 1746 struct channel_obj *ch; 1747 int i; 1748 1749 for (i = 0; i < VPIF_CAPTURE_MAX_DEVICES; i++) { 1750 /* Get the pointer to the channel object */ 1751 ch = vpif_obj.dev[i]; 1752 common = &ch->common[VPIF_VIDEO_INDEX]; 1753 1754 if (!vb2_start_streaming_called(&common->buffer_queue)) 1755 continue; 1756 1757 mutex_lock(&common->lock); 1758 /* Disable channel */ 1759 if (ch->channel_id == VPIF_CHANNEL0_VIDEO) { 1760 enable_channel0(0); 1761 channel0_intr_enable(0); 1762 } 1763 if (ch->channel_id == VPIF_CHANNEL1_VIDEO || 1764 ycmux_mode == 2) { 1765 enable_channel1(0); 1766 channel1_intr_enable(0); 1767 } 1768 mutex_unlock(&common->lock); 1769 } 1770 1771 return 0; 1772 } 1773 1774 /* 1775 * vpif_resume: vpif device suspend 1776 */ 1777 static int vpif_resume(struct device *dev) 1778 { 1779 struct common_obj *common; 1780 struct channel_obj *ch; 1781 int i; 1782 1783 for (i = 0; i < VPIF_CAPTURE_MAX_DEVICES; i++) { 1784 /* Get the pointer to the channel object */ 1785 ch = vpif_obj.dev[i]; 1786 common = &ch->common[VPIF_VIDEO_INDEX]; 1787 1788 if (!vb2_start_streaming_called(&common->buffer_queue)) 1789 continue; 1790 1791 mutex_lock(&common->lock); 1792 /* Enable channel */ 1793 if (ch->channel_id == VPIF_CHANNEL0_VIDEO) { 1794 enable_channel0(1); 1795 channel0_intr_enable(1); 1796 } 1797 if (ch->channel_id == VPIF_CHANNEL1_VIDEO || 1798 ycmux_mode == 2) { 1799 enable_channel1(1); 1800 channel1_intr_enable(1); 1801 } 1802 mutex_unlock(&common->lock); 1803 } 1804 1805 return 0; 1806 } 1807 #endif 1808 1809 static SIMPLE_DEV_PM_OPS(vpif_pm_ops, vpif_suspend, vpif_resume); 1810 1811 static __refdata struct platform_driver vpif_driver = { 1812 .driver = { 1813 .name = VPIF_DRIVER_NAME, 1814 .pm = &vpif_pm_ops, 1815 }, 1816 .probe = vpif_probe, 1817 .remove_new = vpif_remove, 1818 }; 1819 1820 module_platform_driver(vpif_driver); 1821