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