1#include <media/saa7146_vv.h> 2 3static int max_memory = 32; 4 5module_param(max_memory, int, 0644); 6MODULE_PARM_DESC(max_memory, "maximum memory usage for capture buffers (default: 32Mb)"); 7 8#define IS_CAPTURE_ACTIVE(fh) \ 9 (((vv->video_status & STATUS_CAPTURE) != 0) && (vv->video_fh == fh)) 10 11#define IS_OVERLAY_ACTIVE(fh) \ 12 (((vv->video_status & STATUS_OVERLAY) != 0) && (vv->video_fh == fh)) 13 14/* format descriptions for capture and preview */ 15static struct saa7146_format formats[] = { 16 { 17 .name = "RGB-8 (3-3-2)", 18 .pixelformat = V4L2_PIX_FMT_RGB332, 19 .trans = RGB08_COMPOSED, 20 .depth = 8, 21 .flags = 0, 22 }, { 23 .name = "RGB-16 (5/B-6/G-5/R)", 24 .pixelformat = V4L2_PIX_FMT_RGB565, 25 .trans = RGB16_COMPOSED, 26 .depth = 16, 27 .flags = 0, 28 }, { 29 .name = "RGB-24 (B-G-R)", 30 .pixelformat = V4L2_PIX_FMT_BGR24, 31 .trans = RGB24_COMPOSED, 32 .depth = 24, 33 .flags = 0, 34 }, { 35 .name = "RGB-32 (B-G-R)", 36 .pixelformat = V4L2_PIX_FMT_BGR32, 37 .trans = RGB32_COMPOSED, 38 .depth = 32, 39 .flags = 0, 40 }, { 41 .name = "RGB-32 (R-G-B)", 42 .pixelformat = V4L2_PIX_FMT_RGB32, 43 .trans = RGB32_COMPOSED, 44 .depth = 32, 45 .flags = 0, 46 .swap = 0x2, 47 }, { 48 .name = "Greyscale-8", 49 .pixelformat = V4L2_PIX_FMT_GREY, 50 .trans = Y8, 51 .depth = 8, 52 .flags = 0, 53 }, { 54 .name = "YUV 4:2:2 planar (Y-Cb-Cr)", 55 .pixelformat = V4L2_PIX_FMT_YUV422P, 56 .trans = YUV422_DECOMPOSED, 57 .depth = 16, 58 .flags = FORMAT_BYTE_SWAP|FORMAT_IS_PLANAR, 59 }, { 60 .name = "YVU 4:2:0 planar (Y-Cb-Cr)", 61 .pixelformat = V4L2_PIX_FMT_YVU420, 62 .trans = YUV420_DECOMPOSED, 63 .depth = 12, 64 .flags = FORMAT_BYTE_SWAP|FORMAT_IS_PLANAR, 65 }, { 66 .name = "YUV 4:2:0 planar (Y-Cb-Cr)", 67 .pixelformat = V4L2_PIX_FMT_YUV420, 68 .trans = YUV420_DECOMPOSED, 69 .depth = 12, 70 .flags = FORMAT_IS_PLANAR, 71 }, { 72 .name = "YUV 4:2:2 (U-Y-V-Y)", 73 .pixelformat = V4L2_PIX_FMT_UYVY, 74 .trans = YUV422_COMPOSED, 75 .depth = 16, 76 .flags = 0, 77 } 78}; 79 80/* unfortunately, the saa7146 contains a bug which prevents it from doing on-the-fly byte swaps. 81 due to this, it's impossible to provide additional *packed* formats, which are simply byte swapped 82 (like V4L2_PIX_FMT_YUYV) ... 8-( */ 83 84static int NUM_FORMATS = sizeof(formats)/sizeof(struct saa7146_format); 85 86struct saa7146_format* format_by_fourcc(struct saa7146_dev *dev, int fourcc) 87{ 88 int i, j = NUM_FORMATS; 89 90 for (i = 0; i < j; i++) { 91 if (formats[i].pixelformat == fourcc) { 92 return formats+i; 93 } 94 } 95 96 DEB_D(("unknown pixelformat:'%4.4s'\n",(char *)&fourcc)); 97 return NULL; 98} 99 100static int g_fmt(struct saa7146_fh *fh, struct v4l2_format *f) 101{ 102 struct saa7146_dev *dev = fh->dev; 103 DEB_EE(("dev:%p, fh:%p\n",dev,fh)); 104 105 switch (f->type) { 106 case V4L2_BUF_TYPE_VIDEO_CAPTURE: 107 f->fmt.pix = fh->video_fmt; 108 return 0; 109 case V4L2_BUF_TYPE_VIDEO_OVERLAY: 110 f->fmt.win = fh->ov.win; 111 return 0; 112 case V4L2_BUF_TYPE_VBI_CAPTURE: 113 { 114 f->fmt.vbi = fh->vbi_fmt; 115 return 0; 116 } 117 default: 118 DEB_D(("invalid format type '%d'.\n",f->type)); 119 return -EINVAL; 120 } 121} 122 123static int try_win(struct saa7146_dev *dev, struct v4l2_window *win) 124{ 125 struct saa7146_vv *vv = dev->vv_data; 126 enum v4l2_field field; 127 int maxw, maxh; 128 129 DEB_EE(("dev:%p\n",dev)); 130 131 if (NULL == vv->ov_fb.base) { 132 DEB_D(("no fb base set.\n")); 133 return -EINVAL; 134 } 135 if (NULL == vv->ov_fmt) { 136 DEB_D(("no fb fmt set.\n")); 137 return -EINVAL; 138 } 139 if (win->w.width < 48 || win->w.height < 32) { 140 DEB_D(("min width/height. (%d,%d)\n",win->w.width,win->w.height)); 141 return -EINVAL; 142 } 143 if (win->clipcount > 16) { 144 DEB_D(("clipcount too big.\n")); 145 return -EINVAL; 146 } 147 148 field = win->field; 149 maxw = vv->standard->h_max_out; 150 maxh = vv->standard->v_max_out; 151 152 if (V4L2_FIELD_ANY == field) { 153 field = (win->w.height > maxh/2) 154 ? V4L2_FIELD_INTERLACED 155 : V4L2_FIELD_TOP; 156 } 157 switch (field) { 158 case V4L2_FIELD_TOP: 159 case V4L2_FIELD_BOTTOM: 160 case V4L2_FIELD_ALTERNATE: 161 maxh = maxh / 2; 162 break; 163 case V4L2_FIELD_INTERLACED: 164 break; 165 default: { 166 DEB_D(("no known field mode '%d'.\n",field)); 167 return -EINVAL; 168 } 169 } 170 171 win->field = field; 172 if (win->w.width > maxw) 173 win->w.width = maxw; 174 if (win->w.height > maxh) 175 win->w.height = maxh; 176 177 return 0; 178} 179 180static int try_fmt(struct saa7146_fh *fh, struct v4l2_format *f) 181{ 182 struct saa7146_dev *dev = fh->dev; 183 struct saa7146_vv *vv = dev->vv_data; 184 int err; 185 186 switch (f->type) { 187 case V4L2_BUF_TYPE_VIDEO_CAPTURE: 188 { 189 struct saa7146_format *fmt; 190 enum v4l2_field field; 191 int maxw, maxh; 192 int calc_bpl; 193 194 DEB_EE(("V4L2_BUF_TYPE_VIDEO_CAPTURE: dev:%p, fh:%p\n",dev,fh)); 195 196 fmt = format_by_fourcc(dev,f->fmt.pix.pixelformat); 197 if (NULL == fmt) { 198 return -EINVAL; 199 } 200 201 field = f->fmt.pix.field; 202 maxw = vv->standard->h_max_out; 203 maxh = vv->standard->v_max_out; 204 205 if (V4L2_FIELD_ANY == field) { 206 field = (f->fmt.pix.height > maxh/2) 207 ? V4L2_FIELD_INTERLACED 208 : V4L2_FIELD_BOTTOM; 209 } 210 switch (field) { 211 case V4L2_FIELD_ALTERNATE: { 212 vv->last_field = V4L2_FIELD_TOP; 213 maxh = maxh / 2; 214 break; 215 } 216 case V4L2_FIELD_TOP: 217 case V4L2_FIELD_BOTTOM: 218 vv->last_field = V4L2_FIELD_INTERLACED; 219 maxh = maxh / 2; 220 break; 221 case V4L2_FIELD_INTERLACED: 222 vv->last_field = V4L2_FIELD_INTERLACED; 223 break; 224 default: { 225 DEB_D(("no known field mode '%d'.\n",field)); 226 return -EINVAL; 227 } 228 } 229 230 f->fmt.pix.field = field; 231 if (f->fmt.pix.width > maxw) 232 f->fmt.pix.width = maxw; 233 if (f->fmt.pix.height > maxh) 234 f->fmt.pix.height = maxh; 235 236 calc_bpl = (f->fmt.pix.width * fmt->depth)/8; 237 238 if (f->fmt.pix.bytesperline < calc_bpl) 239 f->fmt.pix.bytesperline = calc_bpl; 240 241 if (f->fmt.pix.bytesperline > (2*PAGE_SIZE * fmt->depth)/8) /* arbitrary constraint */ 242 f->fmt.pix.bytesperline = calc_bpl; 243 244 f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * f->fmt.pix.height; 245 DEB_D(("w:%d, h:%d, bytesperline:%d, sizeimage:%d\n",f->fmt.pix.width,f->fmt.pix.height,f->fmt.pix.bytesperline,f->fmt.pix.sizeimage)); 246 247 return 0; 248 } 249 case V4L2_BUF_TYPE_VIDEO_OVERLAY: 250 DEB_EE(("V4L2_BUF_TYPE_VIDEO_OVERLAY: dev:%p, fh:%p\n",dev,fh)); 251 err = try_win(dev,&f->fmt.win); 252 if (0 != err) { 253 return err; 254 } 255 return 0; 256 default: 257 DEB_EE(("unknown format type '%d'\n",f->type)); 258 return -EINVAL; 259 } 260} 261 262int saa7146_start_preview(struct saa7146_fh *fh) 263{ 264 struct saa7146_dev *dev = fh->dev; 265 struct saa7146_vv *vv = dev->vv_data; 266 int ret = 0, err = 0; 267 268 DEB_EE(("dev:%p, fh:%p\n",dev,fh)); 269 270 /* check if we have overlay informations */ 271 if( NULL == fh->ov.fh ) { 272 DEB_D(("no overlay data available. try S_FMT first.\n")); 273 return -EAGAIN; 274 } 275 276 /* check if streaming capture is running */ 277 if (IS_CAPTURE_ACTIVE(fh) != 0) { 278 DEB_D(("streaming capture is active.\n")); 279 return -EBUSY; 280 } 281 282 /* check if overlay is running */ 283 if (IS_OVERLAY_ACTIVE(fh) != 0) { 284 if (vv->video_fh == fh) { 285 DEB_D(("overlay is already active.\n")); 286 return 0; 287 } 288 DEB_D(("overlay is already active in another open.\n")); 289 return -EBUSY; 290 } 291 292 if (0 == saa7146_res_get(fh, RESOURCE_DMA1_HPS|RESOURCE_DMA2_CLP)) { 293 DEB_D(("cannot get necessary overlay resources\n")); 294 return -EBUSY; 295 } 296 297 err = try_win(dev,&fh->ov.win); 298 if (0 != err) { 299 saa7146_res_free(vv->video_fh, RESOURCE_DMA1_HPS|RESOURCE_DMA2_CLP); 300 return -EBUSY; 301 } 302 303 vv->ov_data = &fh->ov; 304 305 DEB_D(("%dx%d+%d+%d %s field=%s\n", 306 fh->ov.win.w.width,fh->ov.win.w.height, 307 fh->ov.win.w.left,fh->ov.win.w.top, 308 vv->ov_fmt->name,v4l2_field_names[fh->ov.win.field])); 309 310 if (0 != (ret = saa7146_enable_overlay(fh))) { 311 DEB_D(("enabling overlay failed: %d\n",ret)); 312 saa7146_res_free(vv->video_fh, RESOURCE_DMA1_HPS|RESOURCE_DMA2_CLP); 313 return ret; 314 } 315 316 vv->video_status = STATUS_OVERLAY; 317 vv->video_fh = fh; 318 319 return 0; 320} 321EXPORT_SYMBOL_GPL(saa7146_start_preview); 322 323int saa7146_stop_preview(struct saa7146_fh *fh) 324{ 325 struct saa7146_dev *dev = fh->dev; 326 struct saa7146_vv *vv = dev->vv_data; 327 328 DEB_EE(("dev:%p, fh:%p\n",dev,fh)); 329 330 /* check if streaming capture is running */ 331 if (IS_CAPTURE_ACTIVE(fh) != 0) { 332 DEB_D(("streaming capture is active.\n")); 333 return -EBUSY; 334 } 335 336 /* check if overlay is running at all */ 337 if ((vv->video_status & STATUS_OVERLAY) == 0) { 338 DEB_D(("no active overlay.\n")); 339 return 0; 340 } 341 342 if (vv->video_fh != fh) { 343 DEB_D(("overlay is active, but in another open.\n")); 344 return -EBUSY; 345 } 346 347 vv->video_status = 0; 348 vv->video_fh = NULL; 349 350 saa7146_disable_overlay(fh); 351 352 saa7146_res_free(fh, RESOURCE_DMA1_HPS|RESOURCE_DMA2_CLP); 353 354 return 0; 355} 356EXPORT_SYMBOL_GPL(saa7146_stop_preview); 357 358static int s_fmt(struct saa7146_fh *fh, struct v4l2_format *f) 359{ 360 struct saa7146_dev *dev = fh->dev; 361 struct saa7146_vv *vv = dev->vv_data; 362 363 int err; 364 365 switch (f->type) { 366 case V4L2_BUF_TYPE_VIDEO_CAPTURE: 367 DEB_EE(("V4L2_BUF_TYPE_VIDEO_CAPTURE: dev:%p, fh:%p\n",dev,fh)); 368 if (IS_CAPTURE_ACTIVE(fh) != 0) { 369 DEB_EE(("streaming capture is active\n")); 370 return -EBUSY; 371 } 372 err = try_fmt(fh,f); 373 if (0 != err) 374 return err; 375 fh->video_fmt = f->fmt.pix; 376 DEB_EE(("set to pixelformat '%4.4s'\n",(char *)&fh->video_fmt.pixelformat)); 377 return 0; 378 case V4L2_BUF_TYPE_VIDEO_OVERLAY: 379 DEB_EE(("V4L2_BUF_TYPE_VIDEO_OVERLAY: dev:%p, fh:%p\n",dev,fh)); 380 err = try_win(dev,&f->fmt.win); 381 if (0 != err) 382 return err; 383 mutex_lock(&dev->lock); 384 fh->ov.win = f->fmt.win; 385 fh->ov.nclips = f->fmt.win.clipcount; 386 if (fh->ov.nclips > 16) 387 fh->ov.nclips = 16; 388 if (copy_from_user(fh->ov.clips,f->fmt.win.clips,sizeof(struct v4l2_clip)*fh->ov.nclips)) { 389 mutex_unlock(&dev->lock); 390 return -EFAULT; 391 } 392 393 /* fh->ov.fh is used to indicate that we have valid overlay informations, too */ 394 fh->ov.fh = fh; 395 396 mutex_unlock(&dev->lock); 397 398 /* check if our current overlay is active */ 399 if (IS_OVERLAY_ACTIVE(fh) != 0) { 400 saa7146_stop_preview(fh); 401 saa7146_start_preview(fh); 402 } 403 return 0; 404 default: 405 DEB_D(("unknown format type '%d'\n",f->type)); 406 return -EINVAL; 407 } 408} 409 410/********************************************************************************/ 411/* device controls */ 412 413static struct v4l2_queryctrl controls[] = { 414 { 415 .id = V4L2_CID_BRIGHTNESS, 416 .name = "Brightness", 417 .minimum = 0, 418 .maximum = 255, 419 .step = 1, 420 .default_value = 128, 421 .type = V4L2_CTRL_TYPE_INTEGER, 422 },{ 423 .id = V4L2_CID_CONTRAST, 424 .name = "Contrast", 425 .minimum = 0, 426 .maximum = 127, 427 .step = 1, 428 .default_value = 64, 429 .type = V4L2_CTRL_TYPE_INTEGER, 430 },{ 431 .id = V4L2_CID_SATURATION, 432 .name = "Saturation", 433 .minimum = 0, 434 .maximum = 127, 435 .step = 1, 436 .default_value = 64, 437 .type = V4L2_CTRL_TYPE_INTEGER, 438 },{ 439 .id = V4L2_CID_VFLIP, 440 .name = "Vertical flip", 441 .minimum = 0, 442 .maximum = 1, 443 .type = V4L2_CTRL_TYPE_BOOLEAN, 444 },{ 445 .id = V4L2_CID_HFLIP, 446 .name = "Horizontal flip", 447 .minimum = 0, 448 .maximum = 1, 449 .type = V4L2_CTRL_TYPE_BOOLEAN, 450 }, 451}; 452static int NUM_CONTROLS = sizeof(controls)/sizeof(struct v4l2_queryctrl); 453 454#define V4L2_CID_PRIVATE_LASTP1 (V4L2_CID_PRIVATE_BASE + 0) 455 456static struct v4l2_queryctrl* ctrl_by_id(int id) 457{ 458 int i; 459 460 for (i = 0; i < NUM_CONTROLS; i++) 461 if (controls[i].id == id) 462 return controls+i; 463 return NULL; 464} 465 466static int get_control(struct saa7146_fh *fh, struct v4l2_control *c) 467{ 468 struct saa7146_dev *dev = fh->dev; 469 struct saa7146_vv *vv = dev->vv_data; 470 471 const struct v4l2_queryctrl* ctrl; 472 u32 value = 0; 473 474 ctrl = ctrl_by_id(c->id); 475 if (NULL == ctrl) 476 return -EINVAL; 477 switch (c->id) { 478 case V4L2_CID_BRIGHTNESS: 479 value = saa7146_read(dev, BCS_CTRL); 480 c->value = 0xff & (value >> 24); 481 DEB_D(("V4L2_CID_BRIGHTNESS: %d\n",c->value)); 482 break; 483 case V4L2_CID_CONTRAST: 484 value = saa7146_read(dev, BCS_CTRL); 485 c->value = 0x7f & (value >> 16); 486 DEB_D(("V4L2_CID_CONTRAST: %d\n",c->value)); 487 break; 488 case V4L2_CID_SATURATION: 489 value = saa7146_read(dev, BCS_CTRL); 490 c->value = 0x7f & (value >> 0); 491 DEB_D(("V4L2_CID_SATURATION: %d\n",c->value)); 492 break; 493 case V4L2_CID_VFLIP: 494 c->value = vv->vflip; 495 DEB_D(("V4L2_CID_VFLIP: %d\n",c->value)); 496 break; 497 case V4L2_CID_HFLIP: 498 c->value = vv->hflip; 499 DEB_D(("V4L2_CID_HFLIP: %d\n",c->value)); 500 break; 501 default: 502 return -EINVAL; 503 } 504 505 return 0; 506} 507 508static int set_control(struct saa7146_fh *fh, struct v4l2_control *c) 509{ 510 struct saa7146_dev *dev = fh->dev; 511 struct saa7146_vv *vv = dev->vv_data; 512 513 const struct v4l2_queryctrl* ctrl; 514 515 ctrl = ctrl_by_id(c->id); 516 if (NULL == ctrl) { 517 DEB_D(("unknown control %d\n",c->id)); 518 return -EINVAL; 519 } 520 521 mutex_lock(&dev->lock); 522 523 switch (ctrl->type) { 524 case V4L2_CTRL_TYPE_BOOLEAN: 525 case V4L2_CTRL_TYPE_MENU: 526 case V4L2_CTRL_TYPE_INTEGER: 527 if (c->value < ctrl->minimum) 528 c->value = ctrl->minimum; 529 if (c->value > ctrl->maximum) 530 c->value = ctrl->maximum; 531 break; 532 default: 533 /* nothing */; 534 }; 535 536 switch (c->id) { 537 case V4L2_CID_BRIGHTNESS: { 538 u32 value = saa7146_read(dev, BCS_CTRL); 539 value &= 0x00ffffff; 540 value |= (c->value << 24); 541 saa7146_write(dev, BCS_CTRL, value); 542 saa7146_write(dev, MC2, MASK_22 | MASK_06 ); 543 break; 544 } 545 case V4L2_CID_CONTRAST: { 546 u32 value = saa7146_read(dev, BCS_CTRL); 547 value &= 0xff00ffff; 548 value |= (c->value << 16); 549 saa7146_write(dev, BCS_CTRL, value); 550 saa7146_write(dev, MC2, MASK_22 | MASK_06 ); 551 break; 552 } 553 case V4L2_CID_SATURATION: { 554 u32 value = saa7146_read(dev, BCS_CTRL); 555 value &= 0xffffff00; 556 value |= (c->value << 0); 557 saa7146_write(dev, BCS_CTRL, value); 558 saa7146_write(dev, MC2, MASK_22 | MASK_06 ); 559 break; 560 } 561 case V4L2_CID_HFLIP: 562 if (IS_CAPTURE_ACTIVE(fh) != 0) { 563 DEB_D(("V4L2_CID_HFLIP while active capture.\n")); 564 mutex_unlock(&dev->lock); 565 return -EINVAL; 566 } 567 vv->hflip = c->value; 568 break; 569 case V4L2_CID_VFLIP: 570 if (IS_CAPTURE_ACTIVE(fh) != 0) { 571 DEB_D(("V4L2_CID_VFLIP while active capture.\n")); 572 mutex_unlock(&dev->lock); 573 return -EINVAL; 574 } 575 vv->vflip = c->value; 576 break; 577 default: { 578 return -EINVAL; 579 } 580 } 581 mutex_unlock(&dev->lock); 582 583 if (IS_OVERLAY_ACTIVE(fh) != 0) { 584 saa7146_stop_preview(fh); 585 saa7146_start_preview(fh); 586 } 587 return 0; 588} 589 590/********************************************************************************/ 591/* common pagetable functions */ 592 593static int saa7146_pgtable_build(struct saa7146_dev *dev, struct saa7146_buf *buf) 594{ 595 struct pci_dev *pci = dev->pci; 596 struct scatterlist *list = buf->vb.dma.sglist; 597 int length = buf->vb.dma.sglen; 598 struct saa7146_format *sfmt = format_by_fourcc(dev,buf->fmt->pixelformat); 599 600 DEB_EE(("dev:%p, buf:%p, sg_len:%d\n",dev,buf,length)); 601 602 if( 0 != IS_PLANAR(sfmt->trans)) { 603 struct saa7146_pgtable *pt1 = &buf->pt[0]; 604 struct saa7146_pgtable *pt2 = &buf->pt[1]; 605 struct saa7146_pgtable *pt3 = &buf->pt[2]; 606 u32 *ptr1, *ptr2, *ptr3; 607 u32 fill; 608 609 int size = buf->fmt->width*buf->fmt->height; 610 int i,p,m1,m2,m3,o1,o2; 611 612 switch( sfmt->depth ) { 613 case 12: { 614 /* create some offsets inside the page table */ 615 m1 = ((size+PAGE_SIZE)/PAGE_SIZE)-1; 616 m2 = ((size+(size/4)+PAGE_SIZE)/PAGE_SIZE)-1; 617 m3 = ((size+(size/2)+PAGE_SIZE)/PAGE_SIZE)-1; 618 o1 = size%PAGE_SIZE; 619 o2 = (size+(size/4))%PAGE_SIZE; 620 DEB_CAP(("size:%d, m1:%d, m2:%d, m3:%d, o1:%d, o2:%d\n",size,m1,m2,m3,o1,o2)); 621 break; 622 } 623 case 16: { 624 /* create some offsets inside the page table */ 625 m1 = ((size+PAGE_SIZE)/PAGE_SIZE)-1; 626 m2 = ((size+(size/2)+PAGE_SIZE)/PAGE_SIZE)-1; 627 m3 = ((2*size+PAGE_SIZE)/PAGE_SIZE)-1; 628 o1 = size%PAGE_SIZE; 629 o2 = (size+(size/2))%PAGE_SIZE; 630 DEB_CAP(("size:%d, m1:%d, m2:%d, m3:%d, o1:%d, o2:%d\n",size,m1,m2,m3,o1,o2)); 631 break; 632 } 633 default: { 634 return -1; 635 } 636 } 637 638 ptr1 = pt1->cpu; 639 ptr2 = pt2->cpu; 640 ptr3 = pt3->cpu; 641 642 /* walk all pages, copy all page addresses to ptr1 */ 643 for (i = 0; i < length; i++, list++) { 644 for (p = 0; p * 4096 < list->length; p++, ptr1++) { 645 *ptr1 = cpu_to_le32(sg_dma_address(list) - list->offset); 646 } 647 } 648/* 649 ptr1 = pt1->cpu; 650 for(j=0;j<40;j++) { 651 printk("ptr1 %d: 0x%08x\n",j,ptr1[j]); 652 } 653*/ 654 655 /* if we have a user buffer, the first page may not be 656 aligned to a page boundary. */ 657 pt1->offset = buf->vb.dma.sglist->offset; 658 pt2->offset = pt1->offset+o1; 659 pt3->offset = pt1->offset+o2; 660 661 /* create video-dma2 page table */ 662 ptr1 = pt1->cpu; 663 for(i = m1; i <= m2 ; i++, ptr2++) { 664 *ptr2 = ptr1[i]; 665 } 666 fill = *(ptr2-1); 667 for(;i<1024;i++,ptr2++) { 668 *ptr2 = fill; 669 } 670 /* create video-dma3 page table */ 671 ptr1 = pt1->cpu; 672 for(i = m2; i <= m3; i++,ptr3++) { 673 *ptr3 = ptr1[i]; 674 } 675 fill = *(ptr3-1); 676 for(;i<1024;i++,ptr3++) { 677 *ptr3 = fill; 678 } 679 /* finally: finish up video-dma1 page table */ 680 ptr1 = pt1->cpu+m1; 681 fill = pt1->cpu[m1]; 682 for(i=m1;i<1024;i++,ptr1++) { 683 *ptr1 = fill; 684 } 685/* 686 ptr1 = pt1->cpu; 687 ptr2 = pt2->cpu; 688 ptr3 = pt3->cpu; 689 for(j=0;j<40;j++) { 690 printk("ptr1 %d: 0x%08x\n",j,ptr1[j]); 691 } 692 for(j=0;j<40;j++) { 693 printk("ptr2 %d: 0x%08x\n",j,ptr2[j]); 694 } 695 for(j=0;j<40;j++) { 696 printk("ptr3 %d: 0x%08x\n",j,ptr3[j]); 697 } 698*/ 699 } else { 700 struct saa7146_pgtable *pt = &buf->pt[0]; 701 return saa7146_pgtable_build_single(pci, pt, list, length); 702 } 703 704 return 0; 705} 706 707 708/********************************************************************************/ 709/* file operations */ 710 711static int video_begin(struct saa7146_fh *fh) 712{ 713 struct saa7146_dev *dev = fh->dev; 714 struct saa7146_vv *vv = dev->vv_data; 715 struct saa7146_format *fmt = NULL; 716 unsigned int resource; 717 int ret = 0, err = 0; 718 719 DEB_EE(("dev:%p, fh:%p\n",dev,fh)); 720 721 if ((vv->video_status & STATUS_CAPTURE) != 0) { 722 if (vv->video_fh == fh) { 723 DEB_S(("already capturing.\n")); 724 return 0; 725 } 726 DEB_S(("already capturing in another open.\n")); 727 return -EBUSY; 728 } 729 730 if ((vv->video_status & STATUS_OVERLAY) != 0) { 731 DEB_S(("warning: suspending overlay video for streaming capture.\n")); 732 vv->ov_suspend = vv->video_fh; 733 err = saa7146_stop_preview(vv->video_fh); /* side effect: video_status is now 0, video_fh is NULL */ 734 if (0 != err) { 735 DEB_D(("suspending video failed. aborting\n")); 736 return err; 737 } 738 } 739 740 fmt = format_by_fourcc(dev,fh->video_fmt.pixelformat); 741 /* we need to have a valid format set here */ 742 BUG_ON(NULL == fmt); 743 744 if (0 != (fmt->flags & FORMAT_IS_PLANAR)) { 745 resource = RESOURCE_DMA1_HPS|RESOURCE_DMA2_CLP|RESOURCE_DMA3_BRS; 746 } else { 747 resource = RESOURCE_DMA1_HPS; 748 } 749 750 ret = saa7146_res_get(fh, resource); 751 if (0 == ret) { 752 DEB_S(("cannot get capture resource %d\n",resource)); 753 if (vv->ov_suspend != NULL) { 754 saa7146_start_preview(vv->ov_suspend); 755 vv->ov_suspend = NULL; 756 } 757 return -EBUSY; 758 } 759 760 /* clear out beginning of streaming bit (rps register 0)*/ 761 saa7146_write(dev, MC2, MASK_27 ); 762 763 /* enable rps0 irqs */ 764 SAA7146_IER_ENABLE(dev, MASK_27); 765 766 vv->video_fh = fh; 767 vv->video_status = STATUS_CAPTURE; 768 769 return 0; 770} 771 772static int video_end(struct saa7146_fh *fh, struct file *file) 773{ 774 struct saa7146_dev *dev = fh->dev; 775 struct saa7146_vv *vv = dev->vv_data; 776 struct saa7146_format *fmt = NULL; 777 unsigned long flags; 778 unsigned int resource; 779 u32 dmas = 0; 780 DEB_EE(("dev:%p, fh:%p\n",dev,fh)); 781 782 if ((vv->video_status & STATUS_CAPTURE) != STATUS_CAPTURE) { 783 DEB_S(("not capturing.\n")); 784 return 0; 785 } 786 787 if (vv->video_fh != fh) { 788 DEB_S(("capturing, but in another open.\n")); 789 return -EBUSY; 790 } 791 792 fmt = format_by_fourcc(dev,fh->video_fmt.pixelformat); 793 /* we need to have a valid format set here */ 794 BUG_ON(NULL == fmt); 795 796 if (0 != (fmt->flags & FORMAT_IS_PLANAR)) { 797 resource = RESOURCE_DMA1_HPS|RESOURCE_DMA2_CLP|RESOURCE_DMA3_BRS; 798 dmas = MASK_22 | MASK_21 | MASK_20; 799 } else { 800 resource = RESOURCE_DMA1_HPS; 801 dmas = MASK_22; 802 } 803 spin_lock_irqsave(&dev->slock,flags); 804 805 /* disable rps0 */ 806 saa7146_write(dev, MC1, MASK_28); 807 808 /* disable rps0 irqs */ 809 SAA7146_IER_DISABLE(dev, MASK_27); 810 811 /* shut down all used video dma transfers */ 812 saa7146_write(dev, MC1, dmas); 813 814 spin_unlock_irqrestore(&dev->slock, flags); 815 816 vv->video_fh = NULL; 817 vv->video_status = 0; 818 819 saa7146_res_free(fh, resource); 820 821 if (vv->ov_suspend != NULL) { 822 saa7146_start_preview(vv->ov_suspend); 823 vv->ov_suspend = NULL; 824 } 825 826 return 0; 827} 828 829/* 830 * This function is _not_ called directly, but from 831 * video_generic_ioctl (and maybe others). userspace 832 * copying is done already, arg is a kernel pointer. 833 */ 834 835int saa7146_video_do_ioctl(struct inode *inode, struct file *file, unsigned int cmd, void *arg) 836{ 837 struct saa7146_fh *fh = file->private_data; 838 struct saa7146_dev *dev = fh->dev; 839 struct saa7146_vv *vv = dev->vv_data; 840 841 int err = 0, result = 0, ee = 0; 842 843 struct saa7146_use_ops *ops; 844 struct videobuf_queue *q; 845 846 /* check if extension handles the command */ 847 for(ee = 0; dev->ext_vv_data->ioctls[ee].flags != 0; ee++) { 848 if( cmd == dev->ext_vv_data->ioctls[ee].cmd ) 849 break; 850 } 851 852 if( 0 != (dev->ext_vv_data->ioctls[ee].flags & SAA7146_EXCLUSIVE) ) { 853 DEB_D(("extension handles ioctl exclusive.\n")); 854 result = dev->ext_vv_data->ioctl(fh, cmd, arg); 855 return result; 856 } 857 if( 0 != (dev->ext_vv_data->ioctls[ee].flags & SAA7146_BEFORE) ) { 858 DEB_D(("extension handles ioctl before.\n")); 859 result = dev->ext_vv_data->ioctl(fh, cmd, arg); 860 if( -EAGAIN != result ) { 861 return result; 862 } 863 } 864 865 866 switch (fh->type) { 867 case V4L2_BUF_TYPE_VIDEO_CAPTURE: { 868 ops = &saa7146_video_uops; 869 q = &fh->video_q; 870 break; 871 } 872 case V4L2_BUF_TYPE_VBI_CAPTURE: { 873 ops = &saa7146_vbi_uops; 874 q = &fh->vbi_q; 875 break; 876 } 877 default: 878 BUG(); 879 return 0; 880 } 881 882 switch (cmd) { 883 case VIDIOC_QUERYCAP: 884 { 885 struct v4l2_capability *cap = arg; 886 memset(cap,0,sizeof(*cap)); 887 888 DEB_EE(("VIDIOC_QUERYCAP\n")); 889 890 strcpy(cap->driver, "saa7146 v4l2"); 891 strlcpy(cap->card, dev->ext->name, sizeof(cap->card)); 892 sprintf(cap->bus_info,"PCI:%s", pci_name(dev->pci)); 893 cap->version = SAA7146_VERSION_CODE; 894 cap->capabilities = 895 V4L2_CAP_VIDEO_CAPTURE | 896 V4L2_CAP_VIDEO_OVERLAY | 897 V4L2_CAP_READWRITE | 898 V4L2_CAP_STREAMING; 899 cap->capabilities |= dev->ext_vv_data->capabilities; 900 return 0; 901 } 902 case VIDIOC_G_FBUF: 903 { 904 struct v4l2_framebuffer *fb = arg; 905 906 DEB_EE(("VIDIOC_G_FBUF\n")); 907 908 *fb = vv->ov_fb; 909 fb->capability = V4L2_FBUF_CAP_LIST_CLIPPING; 910 return 0; 911 } 912 case VIDIOC_S_FBUF: 913 { 914 struct v4l2_framebuffer *fb = arg; 915 struct saa7146_format *fmt; 916 917 DEB_EE(("VIDIOC_S_FBUF\n")); 918 919 if(!capable(CAP_SYS_ADMIN) && 920 !capable(CAP_SYS_RAWIO)) 921 return -EPERM; 922 923 /* check args */ 924 fmt = format_by_fourcc(dev,fb->fmt.pixelformat); 925 if (NULL == fmt) { 926 return -EINVAL; 927 } 928 929 /* planar formats are not allowed for overlay video, clipping and video dma would clash */ 930 if (0 != (fmt->flags & FORMAT_IS_PLANAR)) { 931 DEB_S(("planar pixelformat '%4.4s' not allowed for overlay\n",(char *)&fmt->pixelformat)); 932 } 933 934 /* check if overlay is running */ 935 if (IS_OVERLAY_ACTIVE(fh) != 0) { 936 if (vv->video_fh != fh) { 937 DEB_D(("refusing to change framebuffer informations while overlay is active in another open.\n")); 938 return -EBUSY; 939 } 940 } 941 942 mutex_lock(&dev->lock); 943 944 /* ok, accept it */ 945 vv->ov_fb = *fb; 946 vv->ov_fmt = fmt; 947 if (0 == vv->ov_fb.fmt.bytesperline) 948 vv->ov_fb.fmt.bytesperline = 949 vv->ov_fb.fmt.width*fmt->depth/8; 950 951 mutex_unlock(&dev->lock); 952 953 return 0; 954 } 955 case VIDIOC_ENUM_FMT: 956 { 957 struct v4l2_fmtdesc *f = arg; 958 int index; 959 960 switch (f->type) { 961 case V4L2_BUF_TYPE_VIDEO_CAPTURE: 962 case V4L2_BUF_TYPE_VIDEO_OVERLAY: { 963 index = f->index; 964 if (index < 0 || index >= NUM_FORMATS) { 965 return -EINVAL; 966 } 967 memset(f,0,sizeof(*f)); 968 f->index = index; 969 strlcpy(f->description,formats[index].name,sizeof(f->description)); 970 f->pixelformat = formats[index].pixelformat; 971 break; 972 } 973 default: 974 return -EINVAL; 975 } 976 977 DEB_EE(("VIDIOC_ENUM_FMT: type:%d, index:%d\n",f->type,f->index)); 978 return 0; 979 } 980 case VIDIOC_QUERYCTRL: 981 { 982 const struct v4l2_queryctrl *ctrl; 983 struct v4l2_queryctrl *c = arg; 984 985 if ((c->id < V4L2_CID_BASE || 986 c->id >= V4L2_CID_LASTP1) && 987 (c->id < V4L2_CID_PRIVATE_BASE || 988 c->id >= V4L2_CID_PRIVATE_LASTP1)) 989 return -EINVAL; 990 991 ctrl = ctrl_by_id(c->id); 992 if( NULL == ctrl ) { 993 return -EINVAL; 994/* 995 c->flags = V4L2_CTRL_FLAG_DISABLED; 996 return 0; 997*/ 998 } 999 1000 DEB_EE(("VIDIOC_QUERYCTRL: id:%d\n",c->id)); 1001 *c = *ctrl; 1002 return 0; 1003 } 1004 case VIDIOC_G_CTRL: { 1005 DEB_EE(("VIDIOC_G_CTRL\n")); 1006 return get_control(fh,arg); 1007 } 1008 case VIDIOC_S_CTRL: 1009 { 1010 DEB_EE(("VIDIOC_S_CTRL\n")); 1011 err = set_control(fh,arg); 1012 return err; 1013 } 1014 case VIDIOC_G_PARM: 1015 { 1016 struct v4l2_streamparm *parm = arg; 1017 if( parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ) { 1018 return -EINVAL; 1019 } 1020 memset(&parm->parm.capture,0,sizeof(struct v4l2_captureparm)); 1021 parm->parm.capture.readbuffers = 1; 1022 parm->parm.capture.timeperframe.numerator = 1; 1023 parm->parm.capture.timeperframe.denominator = 25; 1024 return 0; 1025 } 1026 case VIDIOC_G_FMT: 1027 { 1028 struct v4l2_format *f = arg; 1029 DEB_EE(("VIDIOC_G_FMT\n")); 1030 return g_fmt(fh,f); 1031 } 1032 case VIDIOC_S_FMT: 1033 { 1034 struct v4l2_format *f = arg; 1035 DEB_EE(("VIDIOC_S_FMT\n")); 1036 return s_fmt(fh,f); 1037 } 1038 case VIDIOC_TRY_FMT: 1039 { 1040 struct v4l2_format *f = arg; 1041 DEB_EE(("VIDIOC_TRY_FMT\n")); 1042 return try_fmt(fh,f); 1043 } 1044 case VIDIOC_G_STD: 1045 { 1046 v4l2_std_id *id = arg; 1047 DEB_EE(("VIDIOC_G_STD\n")); 1048 *id = vv->standard->id; 1049 return 0; 1050 } 1051 /* the saa7146 supfhrts (used in conjunction with the saa7111a for example) 1052 PAL / NTSC / SECAM. if your hardware does not (or does more) 1053 -- override this function in your extension */ 1054 case VIDIOC_ENUMSTD: 1055 { 1056 struct v4l2_standard *e = arg; 1057 if (e->index < 0 ) 1058 return -EINVAL; 1059 if( e->index < dev->ext_vv_data->num_stds ) { 1060 DEB_EE(("VIDIOC_ENUMSTD: index:%d\n",e->index)); 1061 v4l2_video_std_construct(e, dev->ext_vv_data->stds[e->index].id, dev->ext_vv_data->stds[e->index].name); 1062 return 0; 1063 } 1064 return -EINVAL; 1065 } 1066 case VIDIOC_S_STD: 1067 { 1068 v4l2_std_id *id = arg; 1069 int found = 0; 1070 int i, err; 1071 1072 DEB_EE(("VIDIOC_S_STD\n")); 1073 1074 if ((vv->video_status & STATUS_CAPTURE) == STATUS_CAPTURE) { 1075 DEB_D(("cannot change video standard while streaming capture is active\n")); 1076 return -EBUSY; 1077 } 1078 1079 if ((vv->video_status & STATUS_OVERLAY) != 0) { 1080 vv->ov_suspend = vv->video_fh; 1081 err = saa7146_stop_preview(vv->video_fh); /* side effect: video_status is now 0, video_fh is NULL */ 1082 if (0 != err) { 1083 DEB_D(("suspending video failed. aborting\n")); 1084 return err; 1085 } 1086 } 1087 1088 mutex_lock(&dev->lock); 1089 1090 for(i = 0; i < dev->ext_vv_data->num_stds; i++) 1091 if (*id & dev->ext_vv_data->stds[i].id) 1092 break; 1093 if (i != dev->ext_vv_data->num_stds) { 1094 vv->standard = &dev->ext_vv_data->stds[i]; 1095 if( NULL != dev->ext_vv_data->std_callback ) 1096 dev->ext_vv_data->std_callback(dev, vv->standard); 1097 found = 1; 1098 } 1099 1100 mutex_unlock(&dev->lock); 1101 1102 if (vv->ov_suspend != NULL) { 1103 saa7146_start_preview(vv->ov_suspend); 1104 vv->ov_suspend = NULL; 1105 } 1106 1107 if( 0 == found ) { 1108 DEB_EE(("VIDIOC_S_STD: standard not found.\n")); 1109 return -EINVAL; 1110 } 1111 1112 DEB_EE(("VIDIOC_S_STD: set to standard to '%s'\n",vv->standard->name)); 1113 return 0; 1114 } 1115 case VIDIOC_OVERLAY: 1116 { 1117 int on = *(int *)arg; 1118 int err = 0; 1119 1120 DEB_D(("VIDIOC_OVERLAY on:%d\n",on)); 1121 if (on != 0) { 1122 err = saa7146_start_preview(fh); 1123 } else { 1124 err = saa7146_stop_preview(fh); 1125 } 1126 return err; 1127 } 1128 case VIDIOC_REQBUFS: { 1129 struct v4l2_requestbuffers *req = arg; 1130 DEB_D(("VIDIOC_REQBUFS, type:%d\n",req->type)); 1131 return videobuf_reqbufs(q,req); 1132 } 1133 case VIDIOC_QUERYBUF: { 1134 struct v4l2_buffer *buf = arg; 1135 DEB_D(("VIDIOC_QUERYBUF, type:%d, offset:%d\n",buf->type,buf->m.offset)); 1136 return videobuf_querybuf(q,buf); 1137 } 1138 case VIDIOC_QBUF: { 1139 struct v4l2_buffer *buf = arg; 1140 int ret = 0; 1141 ret = videobuf_qbuf(q,buf); 1142 DEB_D(("VIDIOC_QBUF: ret:%d, index:%d\n",ret,buf->index)); 1143 return ret; 1144 } 1145 case VIDIOC_DQBUF: { 1146 struct v4l2_buffer *buf = arg; 1147 int ret = 0; 1148 ret = videobuf_dqbuf(q,buf,file->f_flags & O_NONBLOCK); 1149 DEB_D(("VIDIOC_DQBUF: ret:%d, index:%d\n",ret,buf->index)); 1150 return ret; 1151 } 1152 case VIDIOC_STREAMON: { 1153 int *type = arg; 1154 DEB_D(("VIDIOC_STREAMON, type:%d\n",*type)); 1155 1156 err = video_begin(fh); 1157 if( 0 != err) { 1158 return err; 1159 } 1160 err = videobuf_streamon(q); 1161 return err; 1162 } 1163 case VIDIOC_STREAMOFF: { 1164 int *type = arg; 1165 1166 DEB_D(("VIDIOC_STREAMOFF, type:%d\n",*type)); 1167 1168 /* ugly: we need to copy some checks from video_end(), 1169 because videobuf_streamoff() relies on the capture running. 1170 check and fix this */ 1171 if ((vv->video_status & STATUS_CAPTURE) != STATUS_CAPTURE) { 1172 DEB_S(("not capturing.\n")); 1173 return 0; 1174 } 1175 1176 if (vv->video_fh != fh) { 1177 DEB_S(("capturing, but in another open.\n")); 1178 return -EBUSY; 1179 } 1180 1181 err = videobuf_streamoff(q); 1182 if (0 != err) { 1183 DEB_D(("warning: videobuf_streamoff() failed.\n")); 1184 video_end(fh, file); 1185 } else { 1186 err = video_end(fh, file); 1187 } 1188 return err; 1189 } 1190#ifdef CONFIG_VIDEO_V4L1_COMPAT 1191 case VIDIOCGMBUF: 1192 { 1193 struct video_mbuf *mbuf = arg; 1194 struct videobuf_queue *q; 1195 int i; 1196 1197 int gbuffers = 2; 1198 int gbufsize = 768*576*4; 1199 1200 DEB_D(("VIDIOCGMBUF \n")); 1201 1202 q = &fh->video_q; 1203 mutex_lock(&q->lock); 1204 err = videobuf_mmap_setup(q,gbuffers,gbufsize, 1205 V4L2_MEMORY_MMAP); 1206 if (err < 0) { 1207 mutex_unlock(&q->lock); 1208 return err; 1209 } 1210 memset(mbuf,0,sizeof(*mbuf)); 1211 mbuf->frames = gbuffers; 1212 mbuf->size = gbuffers * gbufsize; 1213 for (i = 0; i < gbuffers; i++) 1214 mbuf->offsets[i] = i * gbufsize; 1215 mutex_unlock(&q->lock); 1216 return 0; 1217 } 1218#endif 1219 default: 1220 return v4l_compat_translate_ioctl(inode,file,cmd,arg, 1221 saa7146_video_do_ioctl); 1222 } 1223 return 0; 1224} 1225 1226/*********************************************************************************/ 1227/* buffer handling functions */ 1228 1229static int buffer_activate (struct saa7146_dev *dev, 1230 struct saa7146_buf *buf, 1231 struct saa7146_buf *next) 1232{ 1233 struct saa7146_vv *vv = dev->vv_data; 1234 1235 buf->vb.state = STATE_ACTIVE; 1236 saa7146_set_capture(dev,buf,next); 1237 1238 mod_timer(&vv->video_q.timeout, jiffies+BUFFER_TIMEOUT); 1239 return 0; 1240} 1241 1242static int buffer_prepare(struct videobuf_queue *q, 1243 struct videobuf_buffer *vb, enum v4l2_field field) 1244{ 1245 struct file *file = q->priv_data; 1246 struct saa7146_fh *fh = file->private_data; 1247 struct saa7146_dev *dev = fh->dev; 1248 struct saa7146_vv *vv = dev->vv_data; 1249 struct saa7146_buf *buf = (struct saa7146_buf *)vb; 1250 int size,err = 0; 1251 1252 DEB_CAP(("vbuf:%p\n",vb)); 1253 1254 /* sanity checks */ 1255 if (fh->video_fmt.width < 48 || 1256 fh->video_fmt.height < 32 || 1257 fh->video_fmt.width > vv->standard->h_max_out || 1258 fh->video_fmt.height > vv->standard->v_max_out) { 1259 DEB_D(("w (%d) / h (%d) out of bounds.\n",fh->video_fmt.width,fh->video_fmt.height)); 1260 return -EINVAL; 1261 } 1262 1263 size = fh->video_fmt.sizeimage; 1264 if (0 != buf->vb.baddr && buf->vb.bsize < size) { 1265 DEB_D(("size mismatch.\n")); 1266 return -EINVAL; 1267 } 1268 1269 DEB_CAP(("buffer_prepare [size=%dx%d,bytes=%d,fields=%s]\n", 1270 fh->video_fmt.width,fh->video_fmt.height,size,v4l2_field_names[fh->video_fmt.field])); 1271 if (buf->vb.width != fh->video_fmt.width || 1272 buf->vb.bytesperline != fh->video_fmt.bytesperline || 1273 buf->vb.height != fh->video_fmt.height || 1274 buf->vb.size != size || 1275 buf->vb.field != field || 1276 buf->vb.field != fh->video_fmt.field || 1277 buf->fmt != &fh->video_fmt) { 1278 saa7146_dma_free(dev,q,buf); 1279 } 1280 1281 if (STATE_NEEDS_INIT == buf->vb.state) { 1282 struct saa7146_format *sfmt; 1283 1284 buf->vb.bytesperline = fh->video_fmt.bytesperline; 1285 buf->vb.width = fh->video_fmt.width; 1286 buf->vb.height = fh->video_fmt.height; 1287 buf->vb.size = size; 1288 buf->vb.field = field; 1289 buf->fmt = &fh->video_fmt; 1290 buf->vb.field = fh->video_fmt.field; 1291 1292 sfmt = format_by_fourcc(dev,buf->fmt->pixelformat); 1293 1294 if( 0 != IS_PLANAR(sfmt->trans)) { 1295 saa7146_pgtable_free(dev->pci, &buf->pt[0]); 1296 saa7146_pgtable_free(dev->pci, &buf->pt[1]); 1297 saa7146_pgtable_free(dev->pci, &buf->pt[2]); 1298 1299 saa7146_pgtable_alloc(dev->pci, &buf->pt[0]); 1300 saa7146_pgtable_alloc(dev->pci, &buf->pt[1]); 1301 saa7146_pgtable_alloc(dev->pci, &buf->pt[2]); 1302 } else { 1303 saa7146_pgtable_free(dev->pci, &buf->pt[0]); 1304 saa7146_pgtable_alloc(dev->pci, &buf->pt[0]); 1305 } 1306 1307 err = videobuf_iolock(q,&buf->vb, &vv->ov_fb); 1308 if (err) 1309 goto oops; 1310 err = saa7146_pgtable_build(dev,buf); 1311 if (err) 1312 goto oops; 1313 } 1314 buf->vb.state = STATE_PREPARED; 1315 buf->activate = buffer_activate; 1316 1317 return 0; 1318 1319 oops: 1320 DEB_D(("error out.\n")); 1321 saa7146_dma_free(dev,q,buf); 1322 1323 return err; 1324} 1325 1326static int buffer_setup(struct videobuf_queue *q, unsigned int *count, unsigned int *size) 1327{ 1328 struct file *file = q->priv_data; 1329 struct saa7146_fh *fh = file->private_data; 1330 1331 if (0 == *count || *count > MAX_SAA7146_CAPTURE_BUFFERS) 1332 *count = MAX_SAA7146_CAPTURE_BUFFERS; 1333 1334 *size = fh->video_fmt.sizeimage; 1335 1336 /* check if we exceed the "max_memory" parameter */ 1337 if( (*count * *size) > (max_memory*1048576) ) { 1338 *count = (max_memory*1048576) / *size; 1339 } 1340 1341 DEB_CAP(("%d buffers, %d bytes each.\n",*count,*size)); 1342 1343 return 0; 1344} 1345 1346static void buffer_queue(struct videobuf_queue *q, struct videobuf_buffer *vb) 1347{ 1348 struct file *file = q->priv_data; 1349 struct saa7146_fh *fh = file->private_data; 1350 struct saa7146_dev *dev = fh->dev; 1351 struct saa7146_vv *vv = dev->vv_data; 1352 struct saa7146_buf *buf = (struct saa7146_buf *)vb; 1353 1354 DEB_CAP(("vbuf:%p\n",vb)); 1355 saa7146_buffer_queue(fh->dev,&vv->video_q,buf); 1356} 1357 1358static void buffer_release(struct videobuf_queue *q, struct videobuf_buffer *vb) 1359{ 1360 struct file *file = q->priv_data; 1361 struct saa7146_fh *fh = file->private_data; 1362 struct saa7146_dev *dev = fh->dev; 1363 struct saa7146_buf *buf = (struct saa7146_buf *)vb; 1364 1365 DEB_CAP(("vbuf:%p\n",vb)); 1366 saa7146_dma_free(dev,q,buf); 1367} 1368 1369static struct videobuf_queue_ops video_qops = { 1370 .buf_setup = buffer_setup, 1371 .buf_prepare = buffer_prepare, 1372 .buf_queue = buffer_queue, 1373 .buf_release = buffer_release, 1374}; 1375 1376/********************************************************************************/ 1377/* file operations */ 1378 1379static void video_init(struct saa7146_dev *dev, struct saa7146_vv *vv) 1380{ 1381 INIT_LIST_HEAD(&vv->video_q.queue); 1382 1383 init_timer(&vv->video_q.timeout); 1384 vv->video_q.timeout.function = saa7146_buffer_timeout; 1385 vv->video_q.timeout.data = (unsigned long)(&vv->video_q); 1386 vv->video_q.dev = dev; 1387 1388 /* set some default values */ 1389 vv->standard = &dev->ext_vv_data->stds[0]; 1390 1391 vv->current_hps_source = SAA7146_HPS_SOURCE_PORT_A; 1392 vv->current_hps_sync = SAA7146_HPS_SYNC_PORT_A; 1393} 1394 1395 1396static int video_open(struct saa7146_dev *dev, struct file *file) 1397{ 1398 struct saa7146_fh *fh = (struct saa7146_fh *)file->private_data; 1399 struct saa7146_format *sfmt; 1400 1401 fh->video_fmt.width = 384; 1402 fh->video_fmt.height = 288; 1403 fh->video_fmt.pixelformat = V4L2_PIX_FMT_BGR24; 1404 fh->video_fmt.bytesperline = 0; 1405 fh->video_fmt.field = V4L2_FIELD_ANY; 1406 sfmt = format_by_fourcc(dev,fh->video_fmt.pixelformat); 1407 fh->video_fmt.sizeimage = (fh->video_fmt.width * fh->video_fmt.height * sfmt->depth)/8; 1408 1409 videobuf_queue_init(&fh->video_q, &video_qops, 1410 dev->pci, &dev->slock, 1411 V4L2_BUF_TYPE_VIDEO_CAPTURE, 1412 V4L2_FIELD_INTERLACED, 1413 sizeof(struct saa7146_buf), 1414 file); 1415 1416 mutex_init(&fh->video_q.lock); 1417 1418 return 0; 1419} 1420 1421 1422static void video_close(struct saa7146_dev *dev, struct file *file) 1423{ 1424 struct saa7146_fh *fh = (struct saa7146_fh *)file->private_data; 1425 struct saa7146_vv *vv = dev->vv_data; 1426 struct videobuf_queue *q = &fh->video_q; 1427 int err; 1428 1429 if (IS_CAPTURE_ACTIVE(fh) != 0) { 1430 err = video_end(fh, file); 1431 } else if (IS_OVERLAY_ACTIVE(fh) != 0) { 1432 err = saa7146_stop_preview(fh); 1433 } 1434 1435 // release all capture buffers 1436 mutex_lock(&q->lock); 1437 videobuf_read_stop(q); 1438 mutex_unlock(&q->lock); 1439 1440 /* hmm, why is this function declared void? */ 1441 /* return err */ 1442} 1443 1444 1445static void video_irq_done(struct saa7146_dev *dev, unsigned long st) 1446{ 1447 struct saa7146_vv *vv = dev->vv_data; 1448 struct saa7146_dmaqueue *q = &vv->video_q; 1449 1450 spin_lock(&dev->slock); 1451 DEB_CAP(("called.\n")); 1452 1453 /* only finish the buffer if we have one... */ 1454 if( NULL != q->curr ) { 1455 saa7146_buffer_finish(dev,q,STATE_DONE); 1456 } 1457 saa7146_buffer_next(dev,q,0); 1458 1459 spin_unlock(&dev->slock); 1460} 1461 1462static ssize_t video_read(struct file *file, char __user *data, size_t count, loff_t *ppos) 1463{ 1464 struct saa7146_fh *fh = file->private_data; 1465 struct saa7146_dev *dev = fh->dev; 1466 struct saa7146_vv *vv = dev->vv_data; 1467 ssize_t ret = 0; 1468 1469 DEB_EE(("called.\n")); 1470 1471 if ((vv->video_status & STATUS_CAPTURE) != 0) { 1472 if (vv->video_fh == fh) { 1473 DEB_S(("already capturing.\n")); 1474 return -EBUSY; 1475 } 1476 DEB_S(("already capturing in another open.\n")); 1477 return -EBUSY; 1478 } 1479 1480 ret = video_begin(fh); 1481 if( 0 != ret) { 1482 goto out; 1483 } 1484 1485 ret = videobuf_read_one(&fh->video_q , data, count, ppos, 1486 file->f_flags & O_NONBLOCK); 1487 if (ret != 0) { 1488 video_end(fh, file); 1489 } else { 1490 ret = video_end(fh, file); 1491 } 1492out: 1493 /* restart overlay if it was active before */ 1494 if (vv->ov_suspend != NULL) { 1495 saa7146_start_preview(vv->ov_suspend); 1496 vv->ov_suspend = NULL; 1497 } 1498 1499 return ret; 1500} 1501 1502struct saa7146_use_ops saa7146_video_uops = { 1503 .init = video_init, 1504 .open = video_open, 1505 .release = video_close, 1506 .irq_done = video_irq_done, 1507 .read = video_read, 1508}; 1509