1 /* 2 * Zoran zr36057/zr36067 PCI controller driver, for the 3 * Pinnacle/Miro DC10/DC10+/DC30/DC30+, Iomega Buz, Linux 4 * Media Labs LML33/LML33R10. 5 * 6 * Copyright (C) 2000 Serguei Miridonov <mirsev@cicese.mx> 7 * 8 * Changes for BUZ by Wolfgang Scherr <scherr@net4you.net> 9 * 10 * Changes for DC10/DC30 by Laurent Pinchart <laurent.pinchart@skynet.be> 11 * 12 * Changes for LML33R10 by Maxim Yevtyushkin <max@linuxmedialabs.com> 13 * 14 * Changes for videodev2/v4l2 by Ronald Bultje <rbultje@ronald.bitfreak.net> 15 * 16 * Based on 17 * 18 * Miro DC10 driver 19 * Copyright (C) 1999 Wolfgang Scherr <scherr@net4you.net> 20 * 21 * Iomega Buz driver version 1.0 22 * Copyright (C) 1999 Rainer Johanni <Rainer@Johanni.de> 23 * 24 * buz.0.0.3 25 * Copyright (C) 1998 Dave Perks <dperks@ibm.net> 26 * 27 * bttv - Bt848 frame grabber driver 28 * Copyright (C) 1996,97,98 Ralph Metzler (rjkm@thp.uni-koeln.de) 29 * & Marcus Metzler (mocm@thp.uni-koeln.de) 30 * 31 * 32 * This program is free software; you can redistribute it and/or modify 33 * it under the terms of the GNU General Public License as published by 34 * the Free Software Foundation; either version 2 of the License, or 35 * (at your option) any later version. 36 * 37 * This program is distributed in the hope that it will be useful, 38 * but WITHOUT ANY WARRANTY; without even the implied warranty of 39 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 40 * GNU General Public License for more details. 41 * 42 * You should have received a copy of the GNU General Public License 43 * along with this program; if not, write to the Free Software 44 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 45 */ 46 47 #include <linux/init.h> 48 #include <linux/module.h> 49 #include <linux/delay.h> 50 #include <linux/slab.h> 51 #include <linux/pci.h> 52 #include <linux/vmalloc.h> 53 #include <linux/wait.h> 54 55 #include <linux/interrupt.h> 56 #include <linux/i2c.h> 57 #include <linux/i2c-algo-bit.h> 58 59 #include <linux/spinlock.h> 60 61 #include <linux/videodev2.h> 62 #include <media/v4l2-common.h> 63 #include <media/v4l2-ioctl.h> 64 #include "videocodec.h" 65 66 #include <asm/byteorder.h> 67 #include <asm/io.h> 68 #include <asm/uaccess.h> 69 #include <linux/proc_fs.h> 70 71 #include <linux/mutex.h> 72 #include "zoran.h" 73 #include "zoran_device.h" 74 #include "zoran_card.h" 75 76 77 const struct zoran_format zoran_formats[] = { 78 { 79 .name = "15-bit RGB LE", 80 .fourcc = V4L2_PIX_FMT_RGB555, 81 .colorspace = V4L2_COLORSPACE_SRGB, 82 .depth = 15, 83 .flags = ZORAN_FORMAT_CAPTURE | 84 ZORAN_FORMAT_OVERLAY, 85 .vfespfr = ZR36057_VFESPFR_RGB555|ZR36057_VFESPFR_ErrDif| 86 ZR36057_VFESPFR_LittleEndian, 87 }, { 88 .name = "15-bit RGB BE", 89 .fourcc = V4L2_PIX_FMT_RGB555X, 90 .colorspace = V4L2_COLORSPACE_SRGB, 91 .depth = 15, 92 .flags = ZORAN_FORMAT_CAPTURE | 93 ZORAN_FORMAT_OVERLAY, 94 .vfespfr = ZR36057_VFESPFR_RGB555|ZR36057_VFESPFR_ErrDif, 95 }, { 96 .name = "16-bit RGB LE", 97 .fourcc = V4L2_PIX_FMT_RGB565, 98 .colorspace = V4L2_COLORSPACE_SRGB, 99 .depth = 16, 100 .flags = ZORAN_FORMAT_CAPTURE | 101 ZORAN_FORMAT_OVERLAY, 102 .vfespfr = ZR36057_VFESPFR_RGB565|ZR36057_VFESPFR_ErrDif| 103 ZR36057_VFESPFR_LittleEndian, 104 }, { 105 .name = "16-bit RGB BE", 106 .fourcc = V4L2_PIX_FMT_RGB565X, 107 .colorspace = V4L2_COLORSPACE_SRGB, 108 .depth = 16, 109 .flags = ZORAN_FORMAT_CAPTURE | 110 ZORAN_FORMAT_OVERLAY, 111 .vfespfr = ZR36057_VFESPFR_RGB565|ZR36057_VFESPFR_ErrDif, 112 }, { 113 .name = "24-bit RGB", 114 .fourcc = V4L2_PIX_FMT_BGR24, 115 .colorspace = V4L2_COLORSPACE_SRGB, 116 .depth = 24, 117 .flags = ZORAN_FORMAT_CAPTURE | 118 ZORAN_FORMAT_OVERLAY, 119 .vfespfr = ZR36057_VFESPFR_RGB888|ZR36057_VFESPFR_Pack24, 120 }, { 121 .name = "32-bit RGB LE", 122 .fourcc = V4L2_PIX_FMT_BGR32, 123 .colorspace = V4L2_COLORSPACE_SRGB, 124 .depth = 32, 125 .flags = ZORAN_FORMAT_CAPTURE | 126 ZORAN_FORMAT_OVERLAY, 127 .vfespfr = ZR36057_VFESPFR_RGB888|ZR36057_VFESPFR_LittleEndian, 128 }, { 129 .name = "32-bit RGB BE", 130 .fourcc = V4L2_PIX_FMT_RGB32, 131 .colorspace = V4L2_COLORSPACE_SRGB, 132 .depth = 32, 133 .flags = ZORAN_FORMAT_CAPTURE | 134 ZORAN_FORMAT_OVERLAY, 135 .vfespfr = ZR36057_VFESPFR_RGB888, 136 }, { 137 .name = "4:2:2, packed, YUYV", 138 .fourcc = V4L2_PIX_FMT_YUYV, 139 .colorspace = V4L2_COLORSPACE_SMPTE170M, 140 .depth = 16, 141 .flags = ZORAN_FORMAT_CAPTURE | 142 ZORAN_FORMAT_OVERLAY, 143 .vfespfr = ZR36057_VFESPFR_YUV422, 144 }, { 145 .name = "4:2:2, packed, UYVY", 146 .fourcc = V4L2_PIX_FMT_UYVY, 147 .colorspace = V4L2_COLORSPACE_SMPTE170M, 148 .depth = 16, 149 .flags = ZORAN_FORMAT_CAPTURE | 150 ZORAN_FORMAT_OVERLAY, 151 .vfespfr = ZR36057_VFESPFR_YUV422|ZR36057_VFESPFR_LittleEndian, 152 }, { 153 .name = "Hardware-encoded Motion-JPEG", 154 .fourcc = V4L2_PIX_FMT_MJPEG, 155 .colorspace = V4L2_COLORSPACE_SMPTE170M, 156 .depth = 0, 157 .flags = ZORAN_FORMAT_CAPTURE | 158 ZORAN_FORMAT_PLAYBACK | 159 ZORAN_FORMAT_COMPRESSED, 160 } 161 }; 162 #define NUM_FORMATS ARRAY_SIZE(zoran_formats) 163 164 /* small helper function for calculating buffersizes for v4l2 165 * we calculate the nearest higher power-of-two, which 166 * will be the recommended buffersize */ 167 static __u32 168 zoran_v4l2_calc_bufsize (struct zoran_jpg_settings *settings) 169 { 170 __u8 div = settings->VerDcm * settings->HorDcm * settings->TmpDcm; 171 __u32 num = (1024 * 512) / (div); 172 __u32 result = 2; 173 174 num--; 175 while (num) { 176 num >>= 1; 177 result <<= 1; 178 } 179 180 if (result > jpg_bufsize) 181 return jpg_bufsize; 182 if (result < 8192) 183 return 8192; 184 return result; 185 } 186 187 /* forward references */ 188 static void v4l_fbuffer_free(struct zoran_fh *fh); 189 static void jpg_fbuffer_free(struct zoran_fh *fh); 190 191 /* Set mapping mode */ 192 static void map_mode_raw(struct zoran_fh *fh) 193 { 194 fh->map_mode = ZORAN_MAP_MODE_RAW; 195 fh->buffers.buffer_size = v4l_bufsize; 196 fh->buffers.num_buffers = v4l_nbufs; 197 } 198 static void map_mode_jpg(struct zoran_fh *fh, int play) 199 { 200 fh->map_mode = play ? ZORAN_MAP_MODE_JPG_PLAY : ZORAN_MAP_MODE_JPG_REC; 201 fh->buffers.buffer_size = jpg_bufsize; 202 fh->buffers.num_buffers = jpg_nbufs; 203 } 204 static inline const char *mode_name(enum zoran_map_mode mode) 205 { 206 return mode == ZORAN_MAP_MODE_RAW ? "V4L" : "JPG"; 207 } 208 209 /* 210 * Allocate the V4L grab buffers 211 * 212 * These have to be pysically contiguous. 213 */ 214 215 static int v4l_fbuffer_alloc(struct zoran_fh *fh) 216 { 217 struct zoran *zr = fh->zr; 218 int i, off; 219 unsigned char *mem; 220 221 for (i = 0; i < fh->buffers.num_buffers; i++) { 222 if (fh->buffers.buffer[i].v4l.fbuffer) 223 dprintk(2, 224 KERN_WARNING 225 "%s: %s - buffer %d already allocated!?\n", 226 ZR_DEVNAME(zr), __func__, i); 227 228 //udelay(20); 229 mem = kmalloc(fh->buffers.buffer_size, 230 GFP_KERNEL | __GFP_NOWARN); 231 if (!mem) { 232 dprintk(1, 233 KERN_ERR 234 "%s: %s - kmalloc for V4L buf %d failed\n", 235 ZR_DEVNAME(zr), __func__, i); 236 v4l_fbuffer_free(fh); 237 return -ENOBUFS; 238 } 239 fh->buffers.buffer[i].v4l.fbuffer = mem; 240 fh->buffers.buffer[i].v4l.fbuffer_phys = virt_to_phys(mem); 241 fh->buffers.buffer[i].v4l.fbuffer_bus = virt_to_bus(mem); 242 for (off = 0; off < fh->buffers.buffer_size; 243 off += PAGE_SIZE) 244 SetPageReserved(virt_to_page(mem + off)); 245 dprintk(4, 246 KERN_INFO 247 "%s: %s - V4L frame %d mem 0x%lx (bus: 0x%llx)\n", 248 ZR_DEVNAME(zr), __func__, i, (unsigned long) mem, 249 (unsigned long long)virt_to_bus(mem)); 250 } 251 252 fh->buffers.allocated = 1; 253 254 return 0; 255 } 256 257 /* free the V4L grab buffers */ 258 static void v4l_fbuffer_free(struct zoran_fh *fh) 259 { 260 struct zoran *zr = fh->zr; 261 int i, off; 262 unsigned char *mem; 263 264 dprintk(4, KERN_INFO "%s: %s\n", ZR_DEVNAME(zr), __func__); 265 266 for (i = 0; i < fh->buffers.num_buffers; i++) { 267 if (!fh->buffers.buffer[i].v4l.fbuffer) 268 continue; 269 270 mem = fh->buffers.buffer[i].v4l.fbuffer; 271 for (off = 0; off < fh->buffers.buffer_size; 272 off += PAGE_SIZE) 273 ClearPageReserved(virt_to_page(mem + off)); 274 kfree(fh->buffers.buffer[i].v4l.fbuffer); 275 fh->buffers.buffer[i].v4l.fbuffer = NULL; 276 } 277 278 fh->buffers.allocated = 0; 279 } 280 281 /* 282 * Allocate the MJPEG grab buffers. 283 * 284 * If a Natoma chipset is present and this is a revision 1 zr36057, 285 * each MJPEG buffer needs to be physically contiguous. 286 * (RJ: This statement is from Dave Perks' original driver, 287 * I could never check it because I have a zr36067) 288 * 289 * RJ: The contents grab buffers needs never be accessed in the driver. 290 * Therefore there is no need to allocate them with vmalloc in order 291 * to get a contiguous virtual memory space. 292 * I don't understand why many other drivers first allocate them with 293 * vmalloc (which uses internally also get_zeroed_page, but delivers you 294 * virtual addresses) and then again have to make a lot of efforts 295 * to get the physical address. 296 * 297 * Ben Capper: 298 * On big-endian architectures (such as ppc) some extra steps 299 * are needed. When reading and writing to the stat_com array 300 * and fragment buffers, the device expects to see little- 301 * endian values. The use of cpu_to_le32() and le32_to_cpu() 302 * in this function (and one or two others in zoran_device.c) 303 * ensure that these values are always stored in little-endian 304 * form, regardless of architecture. The zr36057 does Very Bad 305 * Things on big endian architectures if the stat_com array 306 * and fragment buffers are not little-endian. 307 */ 308 309 static int jpg_fbuffer_alloc(struct zoran_fh *fh) 310 { 311 struct zoran *zr = fh->zr; 312 int i, j, off; 313 u8 *mem; 314 315 for (i = 0; i < fh->buffers.num_buffers; i++) { 316 if (fh->buffers.buffer[i].jpg.frag_tab) 317 dprintk(2, 318 KERN_WARNING 319 "%s: %s - buffer %d already allocated!?\n", 320 ZR_DEVNAME(zr), __func__, i); 321 322 /* Allocate fragment table for this buffer */ 323 324 mem = (void *)get_zeroed_page(GFP_KERNEL); 325 if (!mem) { 326 dprintk(1, 327 KERN_ERR 328 "%s: %s - get_zeroed_page (frag_tab) failed for buffer %d\n", 329 ZR_DEVNAME(zr), __func__, i); 330 jpg_fbuffer_free(fh); 331 return -ENOBUFS; 332 } 333 fh->buffers.buffer[i].jpg.frag_tab = (__le32 *)mem; 334 fh->buffers.buffer[i].jpg.frag_tab_bus = virt_to_bus(mem); 335 336 if (fh->buffers.need_contiguous) { 337 mem = kmalloc(fh->buffers.buffer_size, GFP_KERNEL); 338 if (mem == NULL) { 339 dprintk(1, 340 KERN_ERR 341 "%s: %s - kmalloc failed for buffer %d\n", 342 ZR_DEVNAME(zr), __func__, i); 343 jpg_fbuffer_free(fh); 344 return -ENOBUFS; 345 } 346 fh->buffers.buffer[i].jpg.frag_tab[0] = 347 cpu_to_le32(virt_to_bus(mem)); 348 fh->buffers.buffer[i].jpg.frag_tab[1] = 349 cpu_to_le32((fh->buffers.buffer_size >> 1) | 1); 350 for (off = 0; off < fh->buffers.buffer_size; off += PAGE_SIZE) 351 SetPageReserved(virt_to_page(mem + off)); 352 } else { 353 /* jpg_bufsize is already page aligned */ 354 for (j = 0; j < fh->buffers.buffer_size / PAGE_SIZE; j++) { 355 mem = (void *)get_zeroed_page(GFP_KERNEL); 356 if (mem == NULL) { 357 dprintk(1, 358 KERN_ERR 359 "%s: %s - get_zeroed_page failed for buffer %d\n", 360 ZR_DEVNAME(zr), __func__, i); 361 jpg_fbuffer_free(fh); 362 return -ENOBUFS; 363 } 364 365 fh->buffers.buffer[i].jpg.frag_tab[2 * j] = 366 cpu_to_le32(virt_to_bus(mem)); 367 fh->buffers.buffer[i].jpg.frag_tab[2 * j + 1] = 368 cpu_to_le32((PAGE_SIZE >> 2) << 1); 369 SetPageReserved(virt_to_page(mem)); 370 } 371 372 fh->buffers.buffer[i].jpg.frag_tab[2 * j - 1] |= cpu_to_le32(1); 373 } 374 } 375 376 dprintk(4, 377 KERN_DEBUG "%s: %s - %d KB allocated\n", 378 ZR_DEVNAME(zr), __func__, 379 (fh->buffers.num_buffers * fh->buffers.buffer_size) >> 10); 380 381 fh->buffers.allocated = 1; 382 383 return 0; 384 } 385 386 /* free the MJPEG grab buffers */ 387 static void jpg_fbuffer_free(struct zoran_fh *fh) 388 { 389 struct zoran *zr = fh->zr; 390 int i, j, off; 391 unsigned char *mem; 392 __le32 frag_tab; 393 struct zoran_buffer *buffer; 394 395 dprintk(4, KERN_DEBUG "%s: %s\n", ZR_DEVNAME(zr), __func__); 396 397 for (i = 0, buffer = &fh->buffers.buffer[0]; 398 i < fh->buffers.num_buffers; i++, buffer++) { 399 if (!buffer->jpg.frag_tab) 400 continue; 401 402 if (fh->buffers.need_contiguous) { 403 frag_tab = buffer->jpg.frag_tab[0]; 404 405 if (frag_tab) { 406 mem = bus_to_virt(le32_to_cpu(frag_tab)); 407 for (off = 0; off < fh->buffers.buffer_size; off += PAGE_SIZE) 408 ClearPageReserved(virt_to_page(mem + off)); 409 kfree(mem); 410 buffer->jpg.frag_tab[0] = 0; 411 buffer->jpg.frag_tab[1] = 0; 412 } 413 } else { 414 for (j = 0; j < fh->buffers.buffer_size / PAGE_SIZE; j++) { 415 frag_tab = buffer->jpg.frag_tab[2 * j]; 416 417 if (!frag_tab) 418 break; 419 ClearPageReserved(virt_to_page(bus_to_virt(le32_to_cpu(frag_tab)))); 420 free_page((unsigned long)bus_to_virt(le32_to_cpu(frag_tab))); 421 buffer->jpg.frag_tab[2 * j] = 0; 422 buffer->jpg.frag_tab[2 * j + 1] = 0; 423 } 424 } 425 426 free_page((unsigned long)buffer->jpg.frag_tab); 427 buffer->jpg.frag_tab = NULL; 428 } 429 430 fh->buffers.allocated = 0; 431 } 432 433 /* 434 * V4L Buffer grabbing 435 */ 436 437 static int 438 zoran_v4l_set_format (struct zoran_fh *fh, 439 int width, 440 int height, 441 const struct zoran_format *format) 442 { 443 struct zoran *zr = fh->zr; 444 int bpp; 445 446 /* Check size and format of the grab wanted */ 447 448 if (height < BUZ_MIN_HEIGHT || width < BUZ_MIN_WIDTH || 449 height > BUZ_MAX_HEIGHT || width > BUZ_MAX_WIDTH) { 450 dprintk(1, 451 KERN_ERR 452 "%s: %s - wrong frame size (%dx%d)\n", 453 ZR_DEVNAME(zr), __func__, width, height); 454 return -EINVAL; 455 } 456 457 bpp = (format->depth + 7) / 8; 458 459 /* Check against available buffer size */ 460 if (height * width * bpp > fh->buffers.buffer_size) { 461 dprintk(1, 462 KERN_ERR 463 "%s: %s - video buffer size (%d kB) is too small\n", 464 ZR_DEVNAME(zr), __func__, fh->buffers.buffer_size >> 10); 465 return -EINVAL; 466 } 467 468 /* The video front end needs 4-byte alinged line sizes */ 469 470 if ((bpp == 2 && (width & 1)) || (bpp == 3 && (width & 3))) { 471 dprintk(1, 472 KERN_ERR 473 "%s: %s - wrong frame alignment\n", 474 ZR_DEVNAME(zr), __func__); 475 return -EINVAL; 476 } 477 478 fh->v4l_settings.width = width; 479 fh->v4l_settings.height = height; 480 fh->v4l_settings.format = format; 481 fh->v4l_settings.bytesperline = bpp * fh->v4l_settings.width; 482 483 return 0; 484 } 485 486 static int zoran_v4l_queue_frame(struct zoran_fh *fh, int num) 487 { 488 struct zoran *zr = fh->zr; 489 unsigned long flags; 490 int res = 0; 491 492 if (!fh->buffers.allocated) { 493 dprintk(1, 494 KERN_ERR 495 "%s: %s - buffers not yet allocated\n", 496 ZR_DEVNAME(zr), __func__); 497 res = -ENOMEM; 498 } 499 500 /* No grabbing outside the buffer range! */ 501 if (num >= fh->buffers.num_buffers || num < 0) { 502 dprintk(1, 503 KERN_ERR 504 "%s: %s - buffer %d is out of range\n", 505 ZR_DEVNAME(zr), __func__, num); 506 res = -EINVAL; 507 } 508 509 spin_lock_irqsave(&zr->spinlock, flags); 510 511 if (fh->buffers.active == ZORAN_FREE) { 512 if (zr->v4l_buffers.active == ZORAN_FREE) { 513 zr->v4l_buffers = fh->buffers; 514 fh->buffers.active = ZORAN_ACTIVE; 515 } else { 516 dprintk(1, 517 KERN_ERR 518 "%s: %s - another session is already capturing\n", 519 ZR_DEVNAME(zr), __func__); 520 res = -EBUSY; 521 } 522 } 523 524 /* make sure a grab isn't going on currently with this buffer */ 525 if (!res) { 526 switch (zr->v4l_buffers.buffer[num].state) { 527 default: 528 case BUZ_STATE_PEND: 529 if (zr->v4l_buffers.active == ZORAN_FREE) { 530 fh->buffers.active = ZORAN_FREE; 531 zr->v4l_buffers.allocated = 0; 532 } 533 res = -EBUSY; /* what are you doing? */ 534 break; 535 case BUZ_STATE_DONE: 536 dprintk(2, 537 KERN_WARNING 538 "%s: %s - queueing buffer %d in state DONE!?\n", 539 ZR_DEVNAME(zr), __func__, num); 540 case BUZ_STATE_USER: 541 /* since there is at least one unused buffer there's room for at least 542 * one more pend[] entry */ 543 zr->v4l_pend[zr->v4l_pend_head++ & V4L_MASK_FRAME] = num; 544 zr->v4l_buffers.buffer[num].state = BUZ_STATE_PEND; 545 zr->v4l_buffers.buffer[num].bs.length = 546 fh->v4l_settings.bytesperline * 547 zr->v4l_settings.height; 548 fh->buffers.buffer[num] = zr->v4l_buffers.buffer[num]; 549 break; 550 } 551 } 552 553 spin_unlock_irqrestore(&zr->spinlock, flags); 554 555 if (!res && zr->v4l_buffers.active == ZORAN_FREE) 556 zr->v4l_buffers.active = fh->buffers.active; 557 558 return res; 559 } 560 561 /* 562 * Sync on a V4L buffer 563 */ 564 565 static int v4l_sync(struct zoran_fh *fh, int frame) 566 { 567 struct zoran *zr = fh->zr; 568 unsigned long flags; 569 570 if (fh->buffers.active == ZORAN_FREE) { 571 dprintk(1, 572 KERN_ERR 573 "%s: %s - no grab active for this session\n", 574 ZR_DEVNAME(zr), __func__); 575 return -EINVAL; 576 } 577 578 /* check passed-in frame number */ 579 if (frame >= fh->buffers.num_buffers || frame < 0) { 580 dprintk(1, 581 KERN_ERR "%s: %s - frame %d is invalid\n", 582 ZR_DEVNAME(zr), __func__, frame); 583 return -EINVAL; 584 } 585 586 /* Check if is buffer was queued at all */ 587 if (zr->v4l_buffers.buffer[frame].state == BUZ_STATE_USER) { 588 dprintk(1, 589 KERN_ERR 590 "%s: %s - attempt to sync on a buffer which was not queued?\n", 591 ZR_DEVNAME(zr), __func__); 592 return -EPROTO; 593 } 594 595 /* wait on this buffer to get ready */ 596 if (!wait_event_interruptible_timeout(zr->v4l_capq, 597 (zr->v4l_buffers.buffer[frame].state != BUZ_STATE_PEND), 10*HZ)) 598 return -ETIME; 599 if (signal_pending(current)) 600 return -ERESTARTSYS; 601 602 /* buffer should now be in BUZ_STATE_DONE */ 603 if (zr->v4l_buffers.buffer[frame].state != BUZ_STATE_DONE) 604 dprintk(2, 605 KERN_ERR "%s: %s - internal state error\n", 606 ZR_DEVNAME(zr), __func__); 607 608 zr->v4l_buffers.buffer[frame].state = BUZ_STATE_USER; 609 fh->buffers.buffer[frame] = zr->v4l_buffers.buffer[frame]; 610 611 spin_lock_irqsave(&zr->spinlock, flags); 612 613 /* Check if streaming capture has finished */ 614 if (zr->v4l_pend_tail == zr->v4l_pend_head) { 615 zr36057_set_memgrab(zr, 0); 616 if (zr->v4l_buffers.active == ZORAN_ACTIVE) { 617 fh->buffers.active = zr->v4l_buffers.active = ZORAN_FREE; 618 zr->v4l_buffers.allocated = 0; 619 } 620 } 621 622 spin_unlock_irqrestore(&zr->spinlock, flags); 623 624 return 0; 625 } 626 627 /* 628 * Queue a MJPEG buffer for capture/playback 629 */ 630 631 static int zoran_jpg_queue_frame(struct zoran_fh *fh, int num, 632 enum zoran_codec_mode mode) 633 { 634 struct zoran *zr = fh->zr; 635 unsigned long flags; 636 int res = 0; 637 638 /* Check if buffers are allocated */ 639 if (!fh->buffers.allocated) { 640 dprintk(1, 641 KERN_ERR 642 "%s: %s - buffers not yet allocated\n", 643 ZR_DEVNAME(zr), __func__); 644 return -ENOMEM; 645 } 646 647 /* No grabbing outside the buffer range! */ 648 if (num >= fh->buffers.num_buffers || num < 0) { 649 dprintk(1, 650 KERN_ERR 651 "%s: %s - buffer %d out of range\n", 652 ZR_DEVNAME(zr), __func__, num); 653 return -EINVAL; 654 } 655 656 /* what is the codec mode right now? */ 657 if (zr->codec_mode == BUZ_MODE_IDLE) { 658 zr->jpg_settings = fh->jpg_settings; 659 } else if (zr->codec_mode != mode) { 660 /* wrong codec mode active - invalid */ 661 dprintk(1, 662 KERN_ERR 663 "%s: %s - codec in wrong mode\n", 664 ZR_DEVNAME(zr), __func__); 665 return -EINVAL; 666 } 667 668 if (fh->buffers.active == ZORAN_FREE) { 669 if (zr->jpg_buffers.active == ZORAN_FREE) { 670 zr->jpg_buffers = fh->buffers; 671 fh->buffers.active = ZORAN_ACTIVE; 672 } else { 673 dprintk(1, 674 KERN_ERR 675 "%s: %s - another session is already capturing\n", 676 ZR_DEVNAME(zr), __func__); 677 res = -EBUSY; 678 } 679 } 680 681 if (!res && zr->codec_mode == BUZ_MODE_IDLE) { 682 /* Ok load up the jpeg codec */ 683 zr36057_enable_jpg(zr, mode); 684 } 685 686 spin_lock_irqsave(&zr->spinlock, flags); 687 688 if (!res) { 689 switch (zr->jpg_buffers.buffer[num].state) { 690 case BUZ_STATE_DONE: 691 dprintk(2, 692 KERN_WARNING 693 "%s: %s - queing frame in BUZ_STATE_DONE state!?\n", 694 ZR_DEVNAME(zr), __func__); 695 case BUZ_STATE_USER: 696 /* since there is at least one unused buffer there's room for at 697 *least one more pend[] entry */ 698 zr->jpg_pend[zr->jpg_que_head++ & BUZ_MASK_FRAME] = num; 699 zr->jpg_buffers.buffer[num].state = BUZ_STATE_PEND; 700 fh->buffers.buffer[num] = zr->jpg_buffers.buffer[num]; 701 zoran_feed_stat_com(zr); 702 break; 703 default: 704 case BUZ_STATE_DMA: 705 case BUZ_STATE_PEND: 706 if (zr->jpg_buffers.active == ZORAN_FREE) { 707 fh->buffers.active = ZORAN_FREE; 708 zr->jpg_buffers.allocated = 0; 709 } 710 res = -EBUSY; /* what are you doing? */ 711 break; 712 } 713 } 714 715 spin_unlock_irqrestore(&zr->spinlock, flags); 716 717 if (!res && zr->jpg_buffers.active == ZORAN_FREE) 718 zr->jpg_buffers.active = fh->buffers.active; 719 720 return res; 721 } 722 723 static int jpg_qbuf(struct zoran_fh *fh, int frame, enum zoran_codec_mode mode) 724 { 725 struct zoran *zr = fh->zr; 726 int res = 0; 727 728 /* Does the user want to stop streaming? */ 729 if (frame < 0) { 730 if (zr->codec_mode == mode) { 731 if (fh->buffers.active == ZORAN_FREE) { 732 dprintk(1, 733 KERN_ERR 734 "%s: %s(-1) - session not active\n", 735 ZR_DEVNAME(zr), __func__); 736 return -EINVAL; 737 } 738 fh->buffers.active = zr->jpg_buffers.active = ZORAN_FREE; 739 zr->jpg_buffers.allocated = 0; 740 zr36057_enable_jpg(zr, BUZ_MODE_IDLE); 741 return 0; 742 } else { 743 dprintk(1, 744 KERN_ERR 745 "%s: %s - stop streaming but not in streaming mode\n", 746 ZR_DEVNAME(zr), __func__); 747 return -EINVAL; 748 } 749 } 750 751 if ((res = zoran_jpg_queue_frame(fh, frame, mode))) 752 return res; 753 754 /* Start the jpeg codec when the first frame is queued */ 755 if (!res && zr->jpg_que_head == 1) 756 jpeg_start(zr); 757 758 return res; 759 } 760 761 /* 762 * Sync on a MJPEG buffer 763 */ 764 765 static int jpg_sync(struct zoran_fh *fh, struct zoran_sync *bs) 766 { 767 struct zoran *zr = fh->zr; 768 unsigned long flags; 769 int frame; 770 771 if (fh->buffers.active == ZORAN_FREE) { 772 dprintk(1, 773 KERN_ERR 774 "%s: %s - capture is not currently active\n", 775 ZR_DEVNAME(zr), __func__); 776 return -EINVAL; 777 } 778 if (zr->codec_mode != BUZ_MODE_MOTION_DECOMPRESS && 779 zr->codec_mode != BUZ_MODE_MOTION_COMPRESS) { 780 dprintk(1, 781 KERN_ERR 782 "%s: %s - codec not in streaming mode\n", 783 ZR_DEVNAME(zr), __func__); 784 return -EINVAL; 785 } 786 if (!wait_event_interruptible_timeout(zr->jpg_capq, 787 (zr->jpg_que_tail != zr->jpg_dma_tail || 788 zr->jpg_dma_tail == zr->jpg_dma_head), 789 10*HZ)) { 790 int isr; 791 792 btand(~ZR36057_JMC_Go_en, ZR36057_JMC); 793 udelay(1); 794 zr->codec->control(zr->codec, CODEC_G_STATUS, 795 sizeof(isr), &isr); 796 dprintk(1, 797 KERN_ERR 798 "%s: %s - timeout: codec isr=0x%02x\n", 799 ZR_DEVNAME(zr), __func__, isr); 800 801 return -ETIME; 802 803 } 804 if (signal_pending(current)) 805 return -ERESTARTSYS; 806 807 spin_lock_irqsave(&zr->spinlock, flags); 808 809 if (zr->jpg_dma_tail != zr->jpg_dma_head) 810 frame = zr->jpg_pend[zr->jpg_que_tail++ & BUZ_MASK_FRAME]; 811 else 812 frame = zr->jpg_pend[zr->jpg_que_tail & BUZ_MASK_FRAME]; 813 814 /* buffer should now be in BUZ_STATE_DONE */ 815 if (zr->jpg_buffers.buffer[frame].state != BUZ_STATE_DONE) 816 dprintk(2, 817 KERN_ERR "%s: %s - internal state error\n", 818 ZR_DEVNAME(zr), __func__); 819 820 *bs = zr->jpg_buffers.buffer[frame].bs; 821 bs->frame = frame; 822 zr->jpg_buffers.buffer[frame].state = BUZ_STATE_USER; 823 fh->buffers.buffer[frame] = zr->jpg_buffers.buffer[frame]; 824 825 spin_unlock_irqrestore(&zr->spinlock, flags); 826 827 return 0; 828 } 829 830 static void zoran_open_init_session(struct zoran_fh *fh) 831 { 832 int i; 833 struct zoran *zr = fh->zr; 834 835 /* Per default, map the V4L Buffers */ 836 map_mode_raw(fh); 837 838 /* take over the card's current settings */ 839 fh->overlay_settings = zr->overlay_settings; 840 fh->overlay_settings.is_set = 0; 841 fh->overlay_settings.format = zr->overlay_settings.format; 842 fh->overlay_active = ZORAN_FREE; 843 844 /* v4l settings */ 845 fh->v4l_settings = zr->v4l_settings; 846 /* jpg settings */ 847 fh->jpg_settings = zr->jpg_settings; 848 849 /* buffers */ 850 memset(&fh->buffers, 0, sizeof(fh->buffers)); 851 for (i = 0; i < MAX_FRAME; i++) { 852 fh->buffers.buffer[i].state = BUZ_STATE_USER; /* nothing going on */ 853 fh->buffers.buffer[i].bs.frame = i; 854 } 855 fh->buffers.allocated = 0; 856 fh->buffers.active = ZORAN_FREE; 857 } 858 859 static void zoran_close_end_session(struct zoran_fh *fh) 860 { 861 struct zoran *zr = fh->zr; 862 863 /* overlay */ 864 if (fh->overlay_active != ZORAN_FREE) { 865 fh->overlay_active = zr->overlay_active = ZORAN_FREE; 866 zr->v4l_overlay_active = 0; 867 if (!zr->v4l_memgrab_active) 868 zr36057_overlay(zr, 0); 869 zr->overlay_mask = NULL; 870 } 871 872 if (fh->map_mode == ZORAN_MAP_MODE_RAW) { 873 /* v4l capture */ 874 if (fh->buffers.active != ZORAN_FREE) { 875 unsigned long flags; 876 877 spin_lock_irqsave(&zr->spinlock, flags); 878 zr36057_set_memgrab(zr, 0); 879 zr->v4l_buffers.allocated = 0; 880 zr->v4l_buffers.active = fh->buffers.active = ZORAN_FREE; 881 spin_unlock_irqrestore(&zr->spinlock, flags); 882 } 883 884 /* v4l buffers */ 885 if (fh->buffers.allocated) 886 v4l_fbuffer_free(fh); 887 } else { 888 /* jpg capture */ 889 if (fh->buffers.active != ZORAN_FREE) { 890 zr36057_enable_jpg(zr, BUZ_MODE_IDLE); 891 zr->jpg_buffers.allocated = 0; 892 zr->jpg_buffers.active = fh->buffers.active = ZORAN_FREE; 893 } 894 895 /* jpg buffers */ 896 if (fh->buffers.allocated) 897 jpg_fbuffer_free(fh); 898 } 899 } 900 901 /* 902 * Open a zoran card. Right now the flags stuff is just playing 903 */ 904 905 static int zoran_open(struct file *file) 906 { 907 struct zoran *zr = video_drvdata(file); 908 struct zoran_fh *fh; 909 int res, first_open = 0; 910 911 dprintk(2, KERN_INFO "%s: %s(%s, pid=[%d]), users(-)=%d\n", 912 ZR_DEVNAME(zr), __func__, current->comm, task_pid_nr(current), zr->user + 1); 913 914 mutex_lock(&zr->other_lock); 915 916 if (zr->user >= 2048) { 917 dprintk(1, KERN_ERR "%s: too many users (%d) on device\n", 918 ZR_DEVNAME(zr), zr->user); 919 res = -EBUSY; 920 goto fail_unlock; 921 } 922 923 /* now, create the open()-specific file_ops struct */ 924 fh = kzalloc(sizeof(struct zoran_fh), GFP_KERNEL); 925 if (!fh) { 926 dprintk(1, 927 KERN_ERR 928 "%s: %s - allocation of zoran_fh failed\n", 929 ZR_DEVNAME(zr), __func__); 930 res = -ENOMEM; 931 goto fail_unlock; 932 } 933 /* used to be BUZ_MAX_WIDTH/HEIGHT, but that gives overflows 934 * on norm-change! */ 935 fh->overlay_mask = 936 kmalloc(((768 + 31) / 32) * 576 * 4, GFP_KERNEL); 937 if (!fh->overlay_mask) { 938 dprintk(1, 939 KERN_ERR 940 "%s: %s - allocation of overlay_mask failed\n", 941 ZR_DEVNAME(zr), __func__); 942 res = -ENOMEM; 943 goto fail_fh; 944 } 945 946 if (zr->user++ == 0) 947 first_open = 1; 948 949 /*mutex_unlock(&zr->resource_lock);*/ 950 951 /* default setup - TODO: look at flags */ 952 if (first_open) { /* First device open */ 953 zr36057_restart(zr); 954 zoran_open_init_params(zr); 955 zoran_init_hardware(zr); 956 957 btor(ZR36057_ICR_IntPinEn, ZR36057_ICR); 958 } 959 960 /* set file_ops stuff */ 961 file->private_data = fh; 962 fh->zr = zr; 963 zoran_open_init_session(fh); 964 mutex_unlock(&zr->other_lock); 965 966 return 0; 967 968 fail_fh: 969 kfree(fh); 970 fail_unlock: 971 mutex_unlock(&zr->other_lock); 972 973 dprintk(2, KERN_INFO "%s: open failed (%d), users(-)=%d\n", 974 ZR_DEVNAME(zr), res, zr->user); 975 976 return res; 977 } 978 979 static int 980 zoran_close(struct file *file) 981 { 982 struct zoran_fh *fh = file->private_data; 983 struct zoran *zr = fh->zr; 984 985 dprintk(2, KERN_INFO "%s: %s(%s, pid=[%d]), users(+)=%d\n", 986 ZR_DEVNAME(zr), __func__, current->comm, task_pid_nr(current), zr->user - 1); 987 988 /* kernel locks (fs/device.c), so don't do that ourselves 989 * (prevents deadlocks) */ 990 mutex_lock(&zr->other_lock); 991 992 zoran_close_end_session(fh); 993 994 if (zr->user-- == 1) { /* Last process */ 995 /* Clean up JPEG process */ 996 wake_up_interruptible(&zr->jpg_capq); 997 zr36057_enable_jpg(zr, BUZ_MODE_IDLE); 998 zr->jpg_buffers.allocated = 0; 999 zr->jpg_buffers.active = ZORAN_FREE; 1000 1001 /* disable interrupts */ 1002 btand(~ZR36057_ICR_IntPinEn, ZR36057_ICR); 1003 1004 if (zr36067_debug > 1) 1005 print_interrupts(zr); 1006 1007 /* Overlay off */ 1008 zr->v4l_overlay_active = 0; 1009 zr36057_overlay(zr, 0); 1010 zr->overlay_mask = NULL; 1011 1012 /* capture off */ 1013 wake_up_interruptible(&zr->v4l_capq); 1014 zr36057_set_memgrab(zr, 0); 1015 zr->v4l_buffers.allocated = 0; 1016 zr->v4l_buffers.active = ZORAN_FREE; 1017 zoran_set_pci_master(zr, 0); 1018 1019 if (!pass_through) { /* Switch to color bar */ 1020 decoder_call(zr, video, s_stream, 0); 1021 encoder_call(zr, video, s_routing, 2, 0, 0); 1022 } 1023 } 1024 mutex_unlock(&zr->other_lock); 1025 1026 file->private_data = NULL; 1027 kfree(fh->overlay_mask); 1028 kfree(fh); 1029 1030 dprintk(4, KERN_INFO "%s: %s done\n", ZR_DEVNAME(zr), __func__); 1031 1032 return 0; 1033 } 1034 1035 1036 static ssize_t 1037 zoran_read (struct file *file, 1038 char __user *data, 1039 size_t count, 1040 loff_t *ppos) 1041 { 1042 /* we simply don't support read() (yet)... */ 1043 1044 return -EINVAL; 1045 } 1046 1047 static ssize_t 1048 zoran_write (struct file *file, 1049 const char __user *data, 1050 size_t count, 1051 loff_t *ppos) 1052 { 1053 /* ...and the same goes for write() */ 1054 1055 return -EINVAL; 1056 } 1057 1058 static int setup_fbuffer(struct zoran_fh *fh, 1059 void *base, 1060 const struct zoran_format *fmt, 1061 int width, 1062 int height, 1063 int bytesperline) 1064 { 1065 struct zoran *zr = fh->zr; 1066 1067 /* (Ronald) v4l/v4l2 guidelines */ 1068 if (!capable(CAP_SYS_ADMIN) && !capable(CAP_SYS_RAWIO)) 1069 return -EPERM; 1070 1071 /* Don't allow frame buffer overlay if PCI or AGP is buggy, or on 1072 ALi Magik (that needs very low latency while the card needs a 1073 higher value always) */ 1074 1075 if (pci_pci_problems & (PCIPCI_FAIL | PCIAGP_FAIL | PCIPCI_ALIMAGIK)) 1076 return -ENXIO; 1077 1078 /* we need a bytesperline value, even if not given */ 1079 if (!bytesperline) 1080 bytesperline = width * ((fmt->depth + 7) & ~7) / 8; 1081 1082 #if 0 1083 if (zr->overlay_active) { 1084 /* dzjee... stupid users... don't even bother to turn off 1085 * overlay before changing the memory location... 1086 * normally, we would return errors here. However, one of 1087 * the tools that does this is... xawtv! and since xawtv 1088 * is used by +/- 99% of the users, we'd rather be user- 1089 * friendly and silently do as if nothing went wrong */ 1090 dprintk(3, 1091 KERN_ERR 1092 "%s: %s - forced overlay turnoff because framebuffer changed\n", 1093 ZR_DEVNAME(zr), __func__); 1094 zr36057_overlay(zr, 0); 1095 } 1096 #endif 1097 1098 if (!(fmt->flags & ZORAN_FORMAT_OVERLAY)) { 1099 dprintk(1, 1100 KERN_ERR 1101 "%s: %s - no valid overlay format given\n", 1102 ZR_DEVNAME(zr), __func__); 1103 return -EINVAL; 1104 } 1105 if (height <= 0 || width <= 0 || bytesperline <= 0) { 1106 dprintk(1, 1107 KERN_ERR 1108 "%s: %s - invalid height/width/bpl value (%d|%d|%d)\n", 1109 ZR_DEVNAME(zr), __func__, width, height, bytesperline); 1110 return -EINVAL; 1111 } 1112 if (bytesperline & 3) { 1113 dprintk(1, 1114 KERN_ERR 1115 "%s: %s - bytesperline (%d) must be 4-byte aligned\n", 1116 ZR_DEVNAME(zr), __func__, bytesperline); 1117 return -EINVAL; 1118 } 1119 1120 zr->vbuf_base = (void *) ((unsigned long) base & ~3); 1121 zr->vbuf_height = height; 1122 zr->vbuf_width = width; 1123 zr->vbuf_depth = fmt->depth; 1124 zr->overlay_settings.format = fmt; 1125 zr->vbuf_bytesperline = bytesperline; 1126 1127 /* The user should set new window parameters */ 1128 zr->overlay_settings.is_set = 0; 1129 1130 return 0; 1131 } 1132 1133 1134 static int setup_window(struct zoran_fh *fh, 1135 int x, 1136 int y, 1137 int width, 1138 int height, 1139 struct v4l2_clip __user *clips, 1140 unsigned int clipcount, 1141 void __user *bitmap) 1142 { 1143 struct zoran *zr = fh->zr; 1144 struct v4l2_clip *vcp = NULL; 1145 int on, end; 1146 1147 1148 if (!zr->vbuf_base) { 1149 dprintk(1, 1150 KERN_ERR 1151 "%s: %s - frame buffer has to be set first\n", 1152 ZR_DEVNAME(zr), __func__); 1153 return -EINVAL; 1154 } 1155 1156 if (!fh->overlay_settings.format) { 1157 dprintk(1, 1158 KERN_ERR 1159 "%s: %s - no overlay format set\n", 1160 ZR_DEVNAME(zr), __func__); 1161 return -EINVAL; 1162 } 1163 1164 if (clipcount > 2048) { 1165 dprintk(1, 1166 KERN_ERR 1167 "%s: %s - invalid clipcount\n", 1168 ZR_DEVNAME(zr), __func__); 1169 return -EINVAL; 1170 } 1171 1172 /* 1173 * The video front end needs 4-byte alinged line sizes, we correct that 1174 * silently here if necessary 1175 */ 1176 if (zr->vbuf_depth == 15 || zr->vbuf_depth == 16) { 1177 end = (x + width) & ~1; /* round down */ 1178 x = (x + 1) & ~1; /* round up */ 1179 width = end - x; 1180 } 1181 1182 if (zr->vbuf_depth == 24) { 1183 end = (x + width) & ~3; /* round down */ 1184 x = (x + 3) & ~3; /* round up */ 1185 width = end - x; 1186 } 1187 1188 if (width > BUZ_MAX_WIDTH) 1189 width = BUZ_MAX_WIDTH; 1190 if (height > BUZ_MAX_HEIGHT) 1191 height = BUZ_MAX_HEIGHT; 1192 1193 /* Check for invalid parameters */ 1194 if (width < BUZ_MIN_WIDTH || height < BUZ_MIN_HEIGHT || 1195 width > BUZ_MAX_WIDTH || height > BUZ_MAX_HEIGHT) { 1196 dprintk(1, 1197 KERN_ERR 1198 "%s: %s - width = %d or height = %d invalid\n", 1199 ZR_DEVNAME(zr), __func__, width, height); 1200 return -EINVAL; 1201 } 1202 1203 fh->overlay_settings.x = x; 1204 fh->overlay_settings.y = y; 1205 fh->overlay_settings.width = width; 1206 fh->overlay_settings.height = height; 1207 fh->overlay_settings.clipcount = clipcount; 1208 1209 /* 1210 * If an overlay is running, we have to switch it off 1211 * and switch it on again in order to get the new settings in effect. 1212 * 1213 * We also want to avoid that the overlay mask is written 1214 * when an overlay is running. 1215 */ 1216 1217 on = zr->v4l_overlay_active && !zr->v4l_memgrab_active && 1218 zr->overlay_active != ZORAN_FREE && 1219 fh->overlay_active != ZORAN_FREE; 1220 if (on) 1221 zr36057_overlay(zr, 0); 1222 1223 /* 1224 * Write the overlay mask if clips are wanted. 1225 * We prefer a bitmap. 1226 */ 1227 if (bitmap) { 1228 /* fake value - it just means we want clips */ 1229 fh->overlay_settings.clipcount = 1; 1230 1231 if (copy_from_user(fh->overlay_mask, bitmap, 1232 (width * height + 7) / 8)) { 1233 return -EFAULT; 1234 } 1235 } else if (clipcount) { 1236 /* write our own bitmap from the clips */ 1237 vcp = vmalloc(sizeof(struct v4l2_clip) * (clipcount + 4)); 1238 if (vcp == NULL) { 1239 dprintk(1, 1240 KERN_ERR 1241 "%s: %s - Alloc of clip mask failed\n", 1242 ZR_DEVNAME(zr), __func__); 1243 return -ENOMEM; 1244 } 1245 if (copy_from_user 1246 (vcp, clips, sizeof(struct v4l2_clip) * clipcount)) { 1247 vfree(vcp); 1248 return -EFAULT; 1249 } 1250 write_overlay_mask(fh, vcp, clipcount); 1251 vfree(vcp); 1252 } 1253 1254 fh->overlay_settings.is_set = 1; 1255 if (fh->overlay_active != ZORAN_FREE && 1256 zr->overlay_active != ZORAN_FREE) 1257 zr->overlay_settings = fh->overlay_settings; 1258 1259 if (on) 1260 zr36057_overlay(zr, 1); 1261 1262 /* Make sure the changes come into effect */ 1263 return wait_grab_pending(zr); 1264 } 1265 1266 static int setup_overlay(struct zoran_fh *fh, int on) 1267 { 1268 struct zoran *zr = fh->zr; 1269 1270 /* If there is nothing to do, return immediately */ 1271 if ((on && fh->overlay_active != ZORAN_FREE) || 1272 (!on && fh->overlay_active == ZORAN_FREE)) 1273 return 0; 1274 1275 /* check whether we're touching someone else's overlay */ 1276 if (on && zr->overlay_active != ZORAN_FREE && 1277 fh->overlay_active == ZORAN_FREE) { 1278 dprintk(1, 1279 KERN_ERR 1280 "%s: %s - overlay is already active for another session\n", 1281 ZR_DEVNAME(zr), __func__); 1282 return -EBUSY; 1283 } 1284 if (!on && zr->overlay_active != ZORAN_FREE && 1285 fh->overlay_active == ZORAN_FREE) { 1286 dprintk(1, 1287 KERN_ERR 1288 "%s: %s - you cannot cancel someone else's session\n", 1289 ZR_DEVNAME(zr), __func__); 1290 return -EPERM; 1291 } 1292 1293 if (on == 0) { 1294 zr->overlay_active = fh->overlay_active = ZORAN_FREE; 1295 zr->v4l_overlay_active = 0; 1296 /* When a grab is running, the video simply 1297 * won't be switched on any more */ 1298 if (!zr->v4l_memgrab_active) 1299 zr36057_overlay(zr, 0); 1300 zr->overlay_mask = NULL; 1301 } else { 1302 if (!zr->vbuf_base || !fh->overlay_settings.is_set) { 1303 dprintk(1, 1304 KERN_ERR 1305 "%s: %s - buffer or window not set\n", 1306 ZR_DEVNAME(zr), __func__); 1307 return -EINVAL; 1308 } 1309 if (!fh->overlay_settings.format) { 1310 dprintk(1, 1311 KERN_ERR 1312 "%s: %s - no overlay format set\n", 1313 ZR_DEVNAME(zr), __func__); 1314 return -EINVAL; 1315 } 1316 zr->overlay_active = fh->overlay_active = ZORAN_LOCKED; 1317 zr->v4l_overlay_active = 1; 1318 zr->overlay_mask = fh->overlay_mask; 1319 zr->overlay_settings = fh->overlay_settings; 1320 if (!zr->v4l_memgrab_active) 1321 zr36057_overlay(zr, 1); 1322 /* When a grab is running, the video will be 1323 * switched on when grab is finished */ 1324 } 1325 1326 /* Make sure the changes come into effect */ 1327 return wait_grab_pending(zr); 1328 } 1329 1330 /* get the status of a buffer in the clients buffer queue */ 1331 static int zoran_v4l2_buffer_status(struct zoran_fh *fh, 1332 struct v4l2_buffer *buf, int num) 1333 { 1334 struct zoran *zr = fh->zr; 1335 unsigned long flags; 1336 1337 buf->flags = V4L2_BUF_FLAG_MAPPED; 1338 1339 switch (fh->map_mode) { 1340 case ZORAN_MAP_MODE_RAW: 1341 /* check range */ 1342 if (num < 0 || num >= fh->buffers.num_buffers || 1343 !fh->buffers.allocated) { 1344 dprintk(1, 1345 KERN_ERR 1346 "%s: %s - wrong number or buffers not allocated\n", 1347 ZR_DEVNAME(zr), __func__); 1348 return -EINVAL; 1349 } 1350 1351 spin_lock_irqsave(&zr->spinlock, flags); 1352 dprintk(3, 1353 KERN_DEBUG 1354 "%s: %s() - raw active=%c, buffer %d: state=%c, map=%c\n", 1355 ZR_DEVNAME(zr), __func__, 1356 "FAL"[fh->buffers.active], num, 1357 "UPMD"[zr->v4l_buffers.buffer[num].state], 1358 fh->buffers.buffer[num].map ? 'Y' : 'N'); 1359 spin_unlock_irqrestore(&zr->spinlock, flags); 1360 1361 buf->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 1362 buf->length = fh->buffers.buffer_size; 1363 1364 /* get buffer */ 1365 buf->bytesused = fh->buffers.buffer[num].bs.length; 1366 if (fh->buffers.buffer[num].state == BUZ_STATE_DONE || 1367 fh->buffers.buffer[num].state == BUZ_STATE_USER) { 1368 buf->sequence = fh->buffers.buffer[num].bs.seq; 1369 buf->flags |= V4L2_BUF_FLAG_DONE; 1370 buf->timestamp = fh->buffers.buffer[num].bs.timestamp; 1371 } else { 1372 buf->flags |= V4L2_BUF_FLAG_QUEUED; 1373 } 1374 1375 if (fh->v4l_settings.height <= BUZ_MAX_HEIGHT / 2) 1376 buf->field = V4L2_FIELD_TOP; 1377 else 1378 buf->field = V4L2_FIELD_INTERLACED; 1379 1380 break; 1381 1382 case ZORAN_MAP_MODE_JPG_REC: 1383 case ZORAN_MAP_MODE_JPG_PLAY: 1384 1385 /* check range */ 1386 if (num < 0 || num >= fh->buffers.num_buffers || 1387 !fh->buffers.allocated) { 1388 dprintk(1, 1389 KERN_ERR 1390 "%s: %s - wrong number or buffers not allocated\n", 1391 ZR_DEVNAME(zr), __func__); 1392 return -EINVAL; 1393 } 1394 1395 buf->type = (fh->map_mode == ZORAN_MAP_MODE_JPG_REC) ? 1396 V4L2_BUF_TYPE_VIDEO_CAPTURE : 1397 V4L2_BUF_TYPE_VIDEO_OUTPUT; 1398 buf->length = fh->buffers.buffer_size; 1399 1400 /* these variables are only written after frame has been captured */ 1401 if (fh->buffers.buffer[num].state == BUZ_STATE_DONE || 1402 fh->buffers.buffer[num].state == BUZ_STATE_USER) { 1403 buf->sequence = fh->buffers.buffer[num].bs.seq; 1404 buf->timestamp = fh->buffers.buffer[num].bs.timestamp; 1405 buf->bytesused = fh->buffers.buffer[num].bs.length; 1406 buf->flags |= V4L2_BUF_FLAG_DONE; 1407 } else { 1408 buf->flags |= V4L2_BUF_FLAG_QUEUED; 1409 } 1410 1411 /* which fields are these? */ 1412 if (fh->jpg_settings.TmpDcm != 1) 1413 buf->field = fh->jpg_settings.odd_even ? 1414 V4L2_FIELD_TOP : V4L2_FIELD_BOTTOM; 1415 else 1416 buf->field = fh->jpg_settings.odd_even ? 1417 V4L2_FIELD_SEQ_TB : V4L2_FIELD_SEQ_BT; 1418 1419 break; 1420 1421 default: 1422 1423 dprintk(5, 1424 KERN_ERR 1425 "%s: %s - invalid buffer type|map_mode (%d|%d)\n", 1426 ZR_DEVNAME(zr), __func__, buf->type, fh->map_mode); 1427 return -EINVAL; 1428 } 1429 1430 buf->memory = V4L2_MEMORY_MMAP; 1431 buf->index = num; 1432 buf->m.offset = buf->length * num; 1433 1434 return 0; 1435 } 1436 1437 static int 1438 zoran_set_norm (struct zoran *zr, 1439 v4l2_std_id norm) 1440 { 1441 int on; 1442 1443 if (zr->v4l_buffers.active != ZORAN_FREE || 1444 zr->jpg_buffers.active != ZORAN_FREE) { 1445 dprintk(1, 1446 KERN_WARNING 1447 "%s: %s called while in playback/capture mode\n", 1448 ZR_DEVNAME(zr), __func__); 1449 return -EBUSY; 1450 } 1451 1452 if (!(norm & zr->card.norms)) { 1453 dprintk(1, 1454 KERN_ERR "%s: %s - unsupported norm %llx\n", 1455 ZR_DEVNAME(zr), __func__, norm); 1456 return -EINVAL; 1457 } 1458 1459 if (norm == V4L2_STD_ALL) { 1460 unsigned int status = 0; 1461 v4l2_std_id std = 0; 1462 1463 decoder_call(zr, video, querystd, &std); 1464 decoder_call(zr, core, s_std, std); 1465 1466 /* let changes come into effect */ 1467 ssleep(2); 1468 1469 decoder_call(zr, video, g_input_status, &status); 1470 if (status & V4L2_IN_ST_NO_SIGNAL) { 1471 dprintk(1, 1472 KERN_ERR 1473 "%s: %s - no norm detected\n", 1474 ZR_DEVNAME(zr), __func__); 1475 /* reset norm */ 1476 decoder_call(zr, core, s_std, zr->norm); 1477 return -EIO; 1478 } 1479 1480 norm = std; 1481 } 1482 if (norm & V4L2_STD_SECAM) 1483 zr->timing = zr->card.tvn[2]; 1484 else if (norm & V4L2_STD_NTSC) 1485 zr->timing = zr->card.tvn[1]; 1486 else 1487 zr->timing = zr->card.tvn[0]; 1488 1489 /* We switch overlay off and on since a change in the 1490 * norm needs different VFE settings */ 1491 on = zr->overlay_active && !zr->v4l_memgrab_active; 1492 if (on) 1493 zr36057_overlay(zr, 0); 1494 1495 decoder_call(zr, core, s_std, norm); 1496 encoder_call(zr, video, s_std_output, norm); 1497 1498 if (on) 1499 zr36057_overlay(zr, 1); 1500 1501 /* Make sure the changes come into effect */ 1502 zr->norm = norm; 1503 1504 return 0; 1505 } 1506 1507 static int 1508 zoran_set_input (struct zoran *zr, 1509 int input) 1510 { 1511 if (input == zr->input) { 1512 return 0; 1513 } 1514 1515 if (zr->v4l_buffers.active != ZORAN_FREE || 1516 zr->jpg_buffers.active != ZORAN_FREE) { 1517 dprintk(1, 1518 KERN_WARNING 1519 "%s: %s called while in playback/capture mode\n", 1520 ZR_DEVNAME(zr), __func__); 1521 return -EBUSY; 1522 } 1523 1524 if (input < 0 || input >= zr->card.inputs) { 1525 dprintk(1, 1526 KERN_ERR 1527 "%s: %s - unnsupported input %d\n", 1528 ZR_DEVNAME(zr), __func__, input); 1529 return -EINVAL; 1530 } 1531 1532 zr->input = input; 1533 1534 decoder_call(zr, video, s_routing, 1535 zr->card.input[input].muxsel, 0, 0); 1536 1537 return 0; 1538 } 1539 1540 /* 1541 * ioctl routine 1542 */ 1543 1544 static int zoran_querycap(struct file *file, void *__fh, struct v4l2_capability *cap) 1545 { 1546 struct zoran_fh *fh = __fh; 1547 struct zoran *zr = fh->zr; 1548 1549 memset(cap, 0, sizeof(*cap)); 1550 strncpy(cap->card, ZR_DEVNAME(zr), sizeof(cap->card)-1); 1551 strncpy(cap->driver, "zoran", sizeof(cap->driver)-1); 1552 snprintf(cap->bus_info, sizeof(cap->bus_info), "PCI:%s", 1553 pci_name(zr->pci_dev)); 1554 cap->capabilities = V4L2_CAP_STREAMING | V4L2_CAP_VIDEO_CAPTURE | 1555 V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_VIDEO_OVERLAY; 1556 return 0; 1557 } 1558 1559 static int zoran_enum_fmt(struct zoran *zr, struct v4l2_fmtdesc *fmt, int flag) 1560 { 1561 unsigned int num, i; 1562 1563 for (num = i = 0; i < NUM_FORMATS; i++) { 1564 if (zoran_formats[i].flags & flag && num++ == fmt->index) { 1565 strncpy(fmt->description, zoran_formats[i].name, 1566 sizeof(fmt->description) - 1); 1567 /* fmt struct pre-zeroed, so adding '\0' not needed */ 1568 fmt->pixelformat = zoran_formats[i].fourcc; 1569 if (zoran_formats[i].flags & ZORAN_FORMAT_COMPRESSED) 1570 fmt->flags |= V4L2_FMT_FLAG_COMPRESSED; 1571 return 0; 1572 } 1573 } 1574 return -EINVAL; 1575 } 1576 1577 static int zoran_enum_fmt_vid_cap(struct file *file, void *__fh, 1578 struct v4l2_fmtdesc *f) 1579 { 1580 struct zoran_fh *fh = __fh; 1581 struct zoran *zr = fh->zr; 1582 1583 return zoran_enum_fmt(zr, f, ZORAN_FORMAT_CAPTURE); 1584 } 1585 1586 static int zoran_enum_fmt_vid_out(struct file *file, void *__fh, 1587 struct v4l2_fmtdesc *f) 1588 { 1589 struct zoran_fh *fh = __fh; 1590 struct zoran *zr = fh->zr; 1591 1592 return zoran_enum_fmt(zr, f, ZORAN_FORMAT_PLAYBACK); 1593 } 1594 1595 static int zoran_enum_fmt_vid_overlay(struct file *file, void *__fh, 1596 struct v4l2_fmtdesc *f) 1597 { 1598 struct zoran_fh *fh = __fh; 1599 struct zoran *zr = fh->zr; 1600 1601 return zoran_enum_fmt(zr, f, ZORAN_FORMAT_OVERLAY); 1602 } 1603 1604 static int zoran_g_fmt_vid_out(struct file *file, void *__fh, 1605 struct v4l2_format *fmt) 1606 { 1607 struct zoran_fh *fh = __fh; 1608 struct zoran *zr = fh->zr; 1609 1610 mutex_lock(&zr->resource_lock); 1611 1612 fmt->fmt.pix.width = fh->jpg_settings.img_width / fh->jpg_settings.HorDcm; 1613 fmt->fmt.pix.height = fh->jpg_settings.img_height * 2 / 1614 (fh->jpg_settings.VerDcm * fh->jpg_settings.TmpDcm); 1615 fmt->fmt.pix.sizeimage = zoran_v4l2_calc_bufsize(&fh->jpg_settings); 1616 fmt->fmt.pix.pixelformat = V4L2_PIX_FMT_MJPEG; 1617 if (fh->jpg_settings.TmpDcm == 1) 1618 fmt->fmt.pix.field = (fh->jpg_settings.odd_even ? 1619 V4L2_FIELD_SEQ_TB : V4L2_FIELD_SEQ_BT); 1620 else 1621 fmt->fmt.pix.field = (fh->jpg_settings.odd_even ? 1622 V4L2_FIELD_TOP : V4L2_FIELD_BOTTOM); 1623 fmt->fmt.pix.bytesperline = 0; 1624 fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; 1625 1626 mutex_unlock(&zr->resource_lock); 1627 return 0; 1628 } 1629 1630 static int zoran_g_fmt_vid_cap(struct file *file, void *__fh, 1631 struct v4l2_format *fmt) 1632 { 1633 struct zoran_fh *fh = __fh; 1634 struct zoran *zr = fh->zr; 1635 1636 if (fh->map_mode != ZORAN_MAP_MODE_RAW) 1637 return zoran_g_fmt_vid_out(file, fh, fmt); 1638 1639 mutex_lock(&zr->resource_lock); 1640 fmt->fmt.pix.width = fh->v4l_settings.width; 1641 fmt->fmt.pix.height = fh->v4l_settings.height; 1642 fmt->fmt.pix.sizeimage = fh->v4l_settings.bytesperline * 1643 fh->v4l_settings.height; 1644 fmt->fmt.pix.pixelformat = fh->v4l_settings.format->fourcc; 1645 fmt->fmt.pix.colorspace = fh->v4l_settings.format->colorspace; 1646 fmt->fmt.pix.bytesperline = fh->v4l_settings.bytesperline; 1647 if (BUZ_MAX_HEIGHT < (fh->v4l_settings.height * 2)) 1648 fmt->fmt.pix.field = V4L2_FIELD_INTERLACED; 1649 else 1650 fmt->fmt.pix.field = V4L2_FIELD_TOP; 1651 mutex_unlock(&zr->resource_lock); 1652 return 0; 1653 } 1654 1655 static int zoran_g_fmt_vid_overlay(struct file *file, void *__fh, 1656 struct v4l2_format *fmt) 1657 { 1658 struct zoran_fh *fh = __fh; 1659 struct zoran *zr = fh->zr; 1660 1661 mutex_lock(&zr->resource_lock); 1662 1663 fmt->fmt.win.w.left = fh->overlay_settings.x; 1664 fmt->fmt.win.w.top = fh->overlay_settings.y; 1665 fmt->fmt.win.w.width = fh->overlay_settings.width; 1666 fmt->fmt.win.w.height = fh->overlay_settings.height; 1667 if (fh->overlay_settings.width * 2 > BUZ_MAX_HEIGHT) 1668 fmt->fmt.win.field = V4L2_FIELD_INTERLACED; 1669 else 1670 fmt->fmt.win.field = V4L2_FIELD_TOP; 1671 1672 mutex_unlock(&zr->resource_lock); 1673 return 0; 1674 } 1675 1676 static int zoran_try_fmt_vid_overlay(struct file *file, void *__fh, 1677 struct v4l2_format *fmt) 1678 { 1679 struct zoran_fh *fh = __fh; 1680 struct zoran *zr = fh->zr; 1681 1682 mutex_lock(&zr->resource_lock); 1683 1684 if (fmt->fmt.win.w.width > BUZ_MAX_WIDTH) 1685 fmt->fmt.win.w.width = BUZ_MAX_WIDTH; 1686 if (fmt->fmt.win.w.width < BUZ_MIN_WIDTH) 1687 fmt->fmt.win.w.width = BUZ_MIN_WIDTH; 1688 if (fmt->fmt.win.w.height > BUZ_MAX_HEIGHT) 1689 fmt->fmt.win.w.height = BUZ_MAX_HEIGHT; 1690 if (fmt->fmt.win.w.height < BUZ_MIN_HEIGHT) 1691 fmt->fmt.win.w.height = BUZ_MIN_HEIGHT; 1692 1693 mutex_unlock(&zr->resource_lock); 1694 return 0; 1695 } 1696 1697 static int zoran_try_fmt_vid_out(struct file *file, void *__fh, 1698 struct v4l2_format *fmt) 1699 { 1700 struct zoran_fh *fh = __fh; 1701 struct zoran *zr = fh->zr; 1702 struct zoran_jpg_settings settings; 1703 int res = 0; 1704 1705 if (fmt->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG) 1706 return -EINVAL; 1707 1708 mutex_lock(&zr->resource_lock); 1709 settings = fh->jpg_settings; 1710 1711 /* we actually need to set 'real' parameters now */ 1712 if ((fmt->fmt.pix.height * 2) > BUZ_MAX_HEIGHT) 1713 settings.TmpDcm = 1; 1714 else 1715 settings.TmpDcm = 2; 1716 settings.decimation = 0; 1717 if (fmt->fmt.pix.height <= fh->jpg_settings.img_height / 2) 1718 settings.VerDcm = 2; 1719 else 1720 settings.VerDcm = 1; 1721 if (fmt->fmt.pix.width <= fh->jpg_settings.img_width / 4) 1722 settings.HorDcm = 4; 1723 else if (fmt->fmt.pix.width <= fh->jpg_settings.img_width / 2) 1724 settings.HorDcm = 2; 1725 else 1726 settings.HorDcm = 1; 1727 if (settings.TmpDcm == 1) 1728 settings.field_per_buff = 2; 1729 else 1730 settings.field_per_buff = 1; 1731 1732 if (settings.HorDcm > 1) { 1733 settings.img_x = (BUZ_MAX_WIDTH == 720) ? 8 : 0; 1734 settings.img_width = (BUZ_MAX_WIDTH == 720) ? 704 : BUZ_MAX_WIDTH; 1735 } else { 1736 settings.img_x = 0; 1737 settings.img_width = BUZ_MAX_WIDTH; 1738 } 1739 1740 /* check */ 1741 res = zoran_check_jpg_settings(zr, &settings, 1); 1742 if (res) 1743 goto tryfmt_unlock_and_return; 1744 1745 /* tell the user what we actually did */ 1746 fmt->fmt.pix.width = settings.img_width / settings.HorDcm; 1747 fmt->fmt.pix.height = settings.img_height * 2 / 1748 (settings.TmpDcm * settings.VerDcm); 1749 if (settings.TmpDcm == 1) 1750 fmt->fmt.pix.field = (fh->jpg_settings.odd_even ? 1751 V4L2_FIELD_SEQ_TB : V4L2_FIELD_SEQ_BT); 1752 else 1753 fmt->fmt.pix.field = (fh->jpg_settings.odd_even ? 1754 V4L2_FIELD_TOP : V4L2_FIELD_BOTTOM); 1755 1756 fmt->fmt.pix.sizeimage = zoran_v4l2_calc_bufsize(&settings); 1757 fmt->fmt.pix.bytesperline = 0; 1758 fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; 1759 tryfmt_unlock_and_return: 1760 mutex_unlock(&zr->resource_lock); 1761 return res; 1762 } 1763 1764 static int zoran_try_fmt_vid_cap(struct file *file, void *__fh, 1765 struct v4l2_format *fmt) 1766 { 1767 struct zoran_fh *fh = __fh; 1768 struct zoran *zr = fh->zr; 1769 int bpp; 1770 int i; 1771 1772 if (fmt->fmt.pix.pixelformat == V4L2_PIX_FMT_MJPEG) 1773 return zoran_try_fmt_vid_out(file, fh, fmt); 1774 1775 mutex_lock(&zr->resource_lock); 1776 1777 for (i = 0; i < NUM_FORMATS; i++) 1778 if (zoran_formats[i].fourcc == fmt->fmt.pix.pixelformat) 1779 break; 1780 1781 if (i == NUM_FORMATS) { 1782 mutex_unlock(&zr->resource_lock); 1783 return -EINVAL; 1784 } 1785 1786 bpp = DIV_ROUND_UP(zoran_formats[i].depth, 8); 1787 v4l_bound_align_image( 1788 &fmt->fmt.pix.width, BUZ_MIN_WIDTH, BUZ_MAX_WIDTH, bpp == 2 ? 1 : 2, 1789 &fmt->fmt.pix.height, BUZ_MIN_HEIGHT, BUZ_MAX_HEIGHT, 0, 0); 1790 mutex_unlock(&zr->resource_lock); 1791 1792 return 0; 1793 } 1794 1795 static int zoran_s_fmt_vid_overlay(struct file *file, void *__fh, 1796 struct v4l2_format *fmt) 1797 { 1798 struct zoran_fh *fh = __fh; 1799 struct zoran *zr = fh->zr; 1800 int res; 1801 1802 dprintk(3, "x=%d, y=%d, w=%d, h=%d, cnt=%d, map=0x%p\n", 1803 fmt->fmt.win.w.left, fmt->fmt.win.w.top, 1804 fmt->fmt.win.w.width, 1805 fmt->fmt.win.w.height, 1806 fmt->fmt.win.clipcount, 1807 fmt->fmt.win.bitmap); 1808 mutex_lock(&zr->resource_lock); 1809 res = setup_window(fh, fmt->fmt.win.w.left, fmt->fmt.win.w.top, 1810 fmt->fmt.win.w.width, fmt->fmt.win.w.height, 1811 (struct v4l2_clip __user *)fmt->fmt.win.clips, 1812 fmt->fmt.win.clipcount, fmt->fmt.win.bitmap); 1813 mutex_unlock(&zr->resource_lock); 1814 return res; 1815 } 1816 1817 static int zoran_s_fmt_vid_out(struct file *file, void *__fh, 1818 struct v4l2_format *fmt) 1819 { 1820 struct zoran_fh *fh = __fh; 1821 struct zoran *zr = fh->zr; 1822 __le32 printformat = __cpu_to_le32(fmt->fmt.pix.pixelformat); 1823 struct zoran_jpg_settings settings; 1824 int res = 0; 1825 1826 dprintk(3, "size=%dx%d, fmt=0x%x (%4.4s)\n", 1827 fmt->fmt.pix.width, fmt->fmt.pix.height, 1828 fmt->fmt.pix.pixelformat, 1829 (char *) &printformat); 1830 if (fmt->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG) 1831 return -EINVAL; 1832 1833 mutex_lock(&zr->resource_lock); 1834 1835 if (fh->buffers.allocated) { 1836 dprintk(1, KERN_ERR "%s: VIDIOC_S_FMT - cannot change capture mode\n", 1837 ZR_DEVNAME(zr)); 1838 res = -EBUSY; 1839 goto sfmtjpg_unlock_and_return; 1840 } 1841 1842 settings = fh->jpg_settings; 1843 1844 /* we actually need to set 'real' parameters now */ 1845 if (fmt->fmt.pix.height * 2 > BUZ_MAX_HEIGHT) 1846 settings.TmpDcm = 1; 1847 else 1848 settings.TmpDcm = 2; 1849 settings.decimation = 0; 1850 if (fmt->fmt.pix.height <= fh->jpg_settings.img_height / 2) 1851 settings.VerDcm = 2; 1852 else 1853 settings.VerDcm = 1; 1854 if (fmt->fmt.pix.width <= fh->jpg_settings.img_width / 4) 1855 settings.HorDcm = 4; 1856 else if (fmt->fmt.pix.width <= fh->jpg_settings.img_width / 2) 1857 settings.HorDcm = 2; 1858 else 1859 settings.HorDcm = 1; 1860 if (settings.TmpDcm == 1) 1861 settings.field_per_buff = 2; 1862 else 1863 settings.field_per_buff = 1; 1864 1865 if (settings.HorDcm > 1) { 1866 settings.img_x = (BUZ_MAX_WIDTH == 720) ? 8 : 0; 1867 settings.img_width = (BUZ_MAX_WIDTH == 720) ? 704 : BUZ_MAX_WIDTH; 1868 } else { 1869 settings.img_x = 0; 1870 settings.img_width = BUZ_MAX_WIDTH; 1871 } 1872 1873 /* check */ 1874 res = zoran_check_jpg_settings(zr, &settings, 0); 1875 if (res) 1876 goto sfmtjpg_unlock_and_return; 1877 1878 /* it's ok, so set them */ 1879 fh->jpg_settings = settings; 1880 1881 map_mode_jpg(fh, fmt->type == V4L2_BUF_TYPE_VIDEO_OUTPUT); 1882 fh->buffers.buffer_size = zoran_v4l2_calc_bufsize(&fh->jpg_settings); 1883 1884 /* tell the user what we actually did */ 1885 fmt->fmt.pix.width = settings.img_width / settings.HorDcm; 1886 fmt->fmt.pix.height = settings.img_height * 2 / 1887 (settings.TmpDcm * settings.VerDcm); 1888 if (settings.TmpDcm == 1) 1889 fmt->fmt.pix.field = (fh->jpg_settings.odd_even ? 1890 V4L2_FIELD_SEQ_TB : V4L2_FIELD_SEQ_BT); 1891 else 1892 fmt->fmt.pix.field = (fh->jpg_settings.odd_even ? 1893 V4L2_FIELD_TOP : V4L2_FIELD_BOTTOM); 1894 fmt->fmt.pix.bytesperline = 0; 1895 fmt->fmt.pix.sizeimage = fh->buffers.buffer_size; 1896 fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; 1897 1898 sfmtjpg_unlock_and_return: 1899 mutex_unlock(&zr->resource_lock); 1900 return res; 1901 } 1902 1903 static int zoran_s_fmt_vid_cap(struct file *file, void *__fh, 1904 struct v4l2_format *fmt) 1905 { 1906 struct zoran_fh *fh = __fh; 1907 struct zoran *zr = fh->zr; 1908 int i; 1909 int res = 0; 1910 1911 if (fmt->fmt.pix.pixelformat == V4L2_PIX_FMT_MJPEG) 1912 return zoran_s_fmt_vid_out(file, fh, fmt); 1913 1914 for (i = 0; i < NUM_FORMATS; i++) 1915 if (fmt->fmt.pix.pixelformat == zoran_formats[i].fourcc) 1916 break; 1917 if (i == NUM_FORMATS) { 1918 dprintk(1, KERN_ERR "%s: VIDIOC_S_FMT - unknown/unsupported format 0x%x\n", 1919 ZR_DEVNAME(zr), fmt->fmt.pix.pixelformat); 1920 return -EINVAL; 1921 } 1922 1923 mutex_lock(&zr->resource_lock); 1924 1925 if ((fh->map_mode != ZORAN_MAP_MODE_RAW && fh->buffers.allocated) || 1926 fh->buffers.active != ZORAN_FREE) { 1927 dprintk(1, KERN_ERR "%s: VIDIOC_S_FMT - cannot change capture mode\n", 1928 ZR_DEVNAME(zr)); 1929 res = -EBUSY; 1930 goto sfmtv4l_unlock_and_return; 1931 } 1932 if (fmt->fmt.pix.height > BUZ_MAX_HEIGHT) 1933 fmt->fmt.pix.height = BUZ_MAX_HEIGHT; 1934 if (fmt->fmt.pix.width > BUZ_MAX_WIDTH) 1935 fmt->fmt.pix.width = BUZ_MAX_WIDTH; 1936 1937 map_mode_raw(fh); 1938 1939 res = zoran_v4l_set_format(fh, fmt->fmt.pix.width, fmt->fmt.pix.height, 1940 &zoran_formats[i]); 1941 if (res) 1942 goto sfmtv4l_unlock_and_return; 1943 1944 /* tell the user the results/missing stuff */ 1945 fmt->fmt.pix.bytesperline = fh->v4l_settings.bytesperline; 1946 fmt->fmt.pix.sizeimage = fh->v4l_settings.height * fh->v4l_settings.bytesperline; 1947 fmt->fmt.pix.colorspace = fh->v4l_settings.format->colorspace; 1948 if (BUZ_MAX_HEIGHT < (fh->v4l_settings.height * 2)) 1949 fmt->fmt.pix.field = V4L2_FIELD_INTERLACED; 1950 else 1951 fmt->fmt.pix.field = V4L2_FIELD_TOP; 1952 1953 sfmtv4l_unlock_and_return: 1954 mutex_unlock(&zr->resource_lock); 1955 return res; 1956 } 1957 1958 static int zoran_g_fbuf(struct file *file, void *__fh, 1959 struct v4l2_framebuffer *fb) 1960 { 1961 struct zoran_fh *fh = __fh; 1962 struct zoran *zr = fh->zr; 1963 1964 memset(fb, 0, sizeof(*fb)); 1965 mutex_lock(&zr->resource_lock); 1966 fb->base = zr->vbuf_base; 1967 fb->fmt.width = zr->vbuf_width; 1968 fb->fmt.height = zr->vbuf_height; 1969 if (zr->overlay_settings.format) 1970 fb->fmt.pixelformat = fh->overlay_settings.format->fourcc; 1971 fb->fmt.bytesperline = zr->vbuf_bytesperline; 1972 mutex_unlock(&zr->resource_lock); 1973 fb->fmt.colorspace = V4L2_COLORSPACE_SRGB; 1974 fb->fmt.field = V4L2_FIELD_INTERLACED; 1975 fb->capability = V4L2_FBUF_CAP_LIST_CLIPPING; 1976 1977 return 0; 1978 } 1979 1980 static int zoran_s_fbuf(struct file *file, void *__fh, 1981 const struct v4l2_framebuffer *fb) 1982 { 1983 struct zoran_fh *fh = __fh; 1984 struct zoran *zr = fh->zr; 1985 int i, res = 0; 1986 __le32 printformat = __cpu_to_le32(fb->fmt.pixelformat); 1987 1988 for (i = 0; i < NUM_FORMATS; i++) 1989 if (zoran_formats[i].fourcc == fb->fmt.pixelformat) 1990 break; 1991 if (i == NUM_FORMATS) { 1992 dprintk(1, KERN_ERR "%s: VIDIOC_S_FBUF - format=0x%x (%4.4s) not allowed\n", 1993 ZR_DEVNAME(zr), fb->fmt.pixelformat, 1994 (char *)&printformat); 1995 return -EINVAL; 1996 } 1997 1998 mutex_lock(&zr->resource_lock); 1999 res = setup_fbuffer(fh, fb->base, &zoran_formats[i], fb->fmt.width, 2000 fb->fmt.height, fb->fmt.bytesperline); 2001 mutex_unlock(&zr->resource_lock); 2002 2003 return res; 2004 } 2005 2006 static int zoran_overlay(struct file *file, void *__fh, unsigned int on) 2007 { 2008 struct zoran_fh *fh = __fh; 2009 struct zoran *zr = fh->zr; 2010 int res; 2011 2012 mutex_lock(&zr->resource_lock); 2013 res = setup_overlay(fh, on); 2014 mutex_unlock(&zr->resource_lock); 2015 2016 return res; 2017 } 2018 2019 static int zoran_streamoff(struct file *file, void *__fh, enum v4l2_buf_type type); 2020 2021 static int zoran_reqbufs(struct file *file, void *__fh, struct v4l2_requestbuffers *req) 2022 { 2023 struct zoran_fh *fh = __fh; 2024 struct zoran *zr = fh->zr; 2025 int res = 0; 2026 2027 if (req->memory != V4L2_MEMORY_MMAP) { 2028 dprintk(2, 2029 KERN_ERR 2030 "%s: only MEMORY_MMAP capture is supported, not %d\n", 2031 ZR_DEVNAME(zr), req->memory); 2032 return -EINVAL; 2033 } 2034 2035 if (req->count == 0) 2036 return zoran_streamoff(file, fh, req->type); 2037 2038 mutex_lock(&zr->resource_lock); 2039 if (fh->buffers.allocated) { 2040 dprintk(2, 2041 KERN_ERR 2042 "%s: VIDIOC_REQBUFS - buffers already allocated\n", 2043 ZR_DEVNAME(zr)); 2044 res = -EBUSY; 2045 goto v4l2reqbuf_unlock_and_return; 2046 } 2047 2048 if (fh->map_mode == ZORAN_MAP_MODE_RAW && 2049 req->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) { 2050 /* control user input */ 2051 if (req->count < 2) 2052 req->count = 2; 2053 if (req->count > v4l_nbufs) 2054 req->count = v4l_nbufs; 2055 2056 /* The next mmap will map the V4L buffers */ 2057 map_mode_raw(fh); 2058 fh->buffers.num_buffers = req->count; 2059 2060 if (v4l_fbuffer_alloc(fh)) { 2061 res = -ENOMEM; 2062 goto v4l2reqbuf_unlock_and_return; 2063 } 2064 } else if (fh->map_mode == ZORAN_MAP_MODE_JPG_REC || 2065 fh->map_mode == ZORAN_MAP_MODE_JPG_PLAY) { 2066 /* we need to calculate size ourselves now */ 2067 if (req->count < 4) 2068 req->count = 4; 2069 if (req->count > jpg_nbufs) 2070 req->count = jpg_nbufs; 2071 2072 /* The next mmap will map the MJPEG buffers */ 2073 map_mode_jpg(fh, req->type == V4L2_BUF_TYPE_VIDEO_OUTPUT); 2074 fh->buffers.num_buffers = req->count; 2075 fh->buffers.buffer_size = zoran_v4l2_calc_bufsize(&fh->jpg_settings); 2076 2077 if (jpg_fbuffer_alloc(fh)) { 2078 res = -ENOMEM; 2079 goto v4l2reqbuf_unlock_and_return; 2080 } 2081 } else { 2082 dprintk(1, 2083 KERN_ERR 2084 "%s: VIDIOC_REQBUFS - unknown type %d\n", 2085 ZR_DEVNAME(zr), req->type); 2086 res = -EINVAL; 2087 goto v4l2reqbuf_unlock_and_return; 2088 } 2089 v4l2reqbuf_unlock_and_return: 2090 mutex_unlock(&zr->resource_lock); 2091 2092 return res; 2093 } 2094 2095 static int zoran_querybuf(struct file *file, void *__fh, struct v4l2_buffer *buf) 2096 { 2097 struct zoran_fh *fh = __fh; 2098 struct zoran *zr = fh->zr; 2099 int res; 2100 2101 mutex_lock(&zr->resource_lock); 2102 res = zoran_v4l2_buffer_status(fh, buf, buf->index); 2103 mutex_unlock(&zr->resource_lock); 2104 2105 return res; 2106 } 2107 2108 static int zoran_qbuf(struct file *file, void *__fh, struct v4l2_buffer *buf) 2109 { 2110 struct zoran_fh *fh = __fh; 2111 struct zoran *zr = fh->zr; 2112 int res = 0, codec_mode, buf_type; 2113 2114 mutex_lock(&zr->resource_lock); 2115 2116 switch (fh->map_mode) { 2117 case ZORAN_MAP_MODE_RAW: 2118 if (buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) { 2119 dprintk(1, KERN_ERR 2120 "%s: VIDIOC_QBUF - invalid buf->type=%d for map_mode=%d\n", 2121 ZR_DEVNAME(zr), buf->type, fh->map_mode); 2122 res = -EINVAL; 2123 goto qbuf_unlock_and_return; 2124 } 2125 2126 res = zoran_v4l_queue_frame(fh, buf->index); 2127 if (res) 2128 goto qbuf_unlock_and_return; 2129 if (!zr->v4l_memgrab_active && fh->buffers.active == ZORAN_LOCKED) 2130 zr36057_set_memgrab(zr, 1); 2131 break; 2132 2133 case ZORAN_MAP_MODE_JPG_REC: 2134 case ZORAN_MAP_MODE_JPG_PLAY: 2135 if (fh->map_mode == ZORAN_MAP_MODE_JPG_PLAY) { 2136 buf_type = V4L2_BUF_TYPE_VIDEO_OUTPUT; 2137 codec_mode = BUZ_MODE_MOTION_DECOMPRESS; 2138 } else { 2139 buf_type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 2140 codec_mode = BUZ_MODE_MOTION_COMPRESS; 2141 } 2142 2143 if (buf->type != buf_type) { 2144 dprintk(1, KERN_ERR 2145 "%s: VIDIOC_QBUF - invalid buf->type=%d for map_mode=%d\n", 2146 ZR_DEVNAME(zr), buf->type, fh->map_mode); 2147 res = -EINVAL; 2148 goto qbuf_unlock_and_return; 2149 } 2150 2151 res = zoran_jpg_queue_frame(fh, buf->index, codec_mode); 2152 if (res != 0) 2153 goto qbuf_unlock_and_return; 2154 if (zr->codec_mode == BUZ_MODE_IDLE && 2155 fh->buffers.active == ZORAN_LOCKED) 2156 zr36057_enable_jpg(zr, codec_mode); 2157 2158 break; 2159 2160 default: 2161 dprintk(1, KERN_ERR 2162 "%s: VIDIOC_QBUF - unsupported type %d\n", 2163 ZR_DEVNAME(zr), buf->type); 2164 res = -EINVAL; 2165 break; 2166 } 2167 qbuf_unlock_and_return: 2168 mutex_unlock(&zr->resource_lock); 2169 2170 return res; 2171 } 2172 2173 static int zoran_dqbuf(struct file *file, void *__fh, struct v4l2_buffer *buf) 2174 { 2175 struct zoran_fh *fh = __fh; 2176 struct zoran *zr = fh->zr; 2177 int res = 0, buf_type, num = -1; /* compiler borks here (?) */ 2178 2179 mutex_lock(&zr->resource_lock); 2180 2181 switch (fh->map_mode) { 2182 case ZORAN_MAP_MODE_RAW: 2183 if (buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) { 2184 dprintk(1, KERN_ERR 2185 "%s: VIDIOC_QBUF - invalid buf->type=%d for map_mode=%d\n", 2186 ZR_DEVNAME(zr), buf->type, fh->map_mode); 2187 res = -EINVAL; 2188 goto dqbuf_unlock_and_return; 2189 } 2190 2191 num = zr->v4l_pend[zr->v4l_sync_tail & V4L_MASK_FRAME]; 2192 if (file->f_flags & O_NONBLOCK && 2193 zr->v4l_buffers.buffer[num].state != BUZ_STATE_DONE) { 2194 res = -EAGAIN; 2195 goto dqbuf_unlock_and_return; 2196 } 2197 res = v4l_sync(fh, num); 2198 if (res) 2199 goto dqbuf_unlock_and_return; 2200 zr->v4l_sync_tail++; 2201 res = zoran_v4l2_buffer_status(fh, buf, num); 2202 break; 2203 2204 case ZORAN_MAP_MODE_JPG_REC: 2205 case ZORAN_MAP_MODE_JPG_PLAY: 2206 { 2207 struct zoran_sync bs; 2208 2209 if (fh->map_mode == ZORAN_MAP_MODE_JPG_PLAY) 2210 buf_type = V4L2_BUF_TYPE_VIDEO_OUTPUT; 2211 else 2212 buf_type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 2213 2214 if (buf->type != buf_type) { 2215 dprintk(1, KERN_ERR 2216 "%s: VIDIOC_QBUF - invalid buf->type=%d for map_mode=%d\n", 2217 ZR_DEVNAME(zr), buf->type, fh->map_mode); 2218 res = -EINVAL; 2219 goto dqbuf_unlock_and_return; 2220 } 2221 2222 num = zr->jpg_pend[zr->jpg_que_tail & BUZ_MASK_FRAME]; 2223 2224 if (file->f_flags & O_NONBLOCK && 2225 zr->jpg_buffers.buffer[num].state != BUZ_STATE_DONE) { 2226 res = -EAGAIN; 2227 goto dqbuf_unlock_and_return; 2228 } 2229 bs.frame = 0; /* suppress compiler warning */ 2230 res = jpg_sync(fh, &bs); 2231 if (res) 2232 goto dqbuf_unlock_and_return; 2233 res = zoran_v4l2_buffer_status(fh, buf, bs.frame); 2234 break; 2235 } 2236 2237 default: 2238 dprintk(1, KERN_ERR 2239 "%s: VIDIOC_DQBUF - unsupported type %d\n", 2240 ZR_DEVNAME(zr), buf->type); 2241 res = -EINVAL; 2242 break; 2243 } 2244 dqbuf_unlock_and_return: 2245 mutex_unlock(&zr->resource_lock); 2246 2247 return res; 2248 } 2249 2250 static int zoran_streamon(struct file *file, void *__fh, enum v4l2_buf_type type) 2251 { 2252 struct zoran_fh *fh = __fh; 2253 struct zoran *zr = fh->zr; 2254 int res = 0; 2255 2256 mutex_lock(&zr->resource_lock); 2257 2258 switch (fh->map_mode) { 2259 case ZORAN_MAP_MODE_RAW: /* raw capture */ 2260 if (zr->v4l_buffers.active != ZORAN_ACTIVE || 2261 fh->buffers.active != ZORAN_ACTIVE) { 2262 res = -EBUSY; 2263 goto strmon_unlock_and_return; 2264 } 2265 2266 zr->v4l_buffers.active = fh->buffers.active = ZORAN_LOCKED; 2267 zr->v4l_settings = fh->v4l_settings; 2268 2269 zr->v4l_sync_tail = zr->v4l_pend_tail; 2270 if (!zr->v4l_memgrab_active && 2271 zr->v4l_pend_head != zr->v4l_pend_tail) { 2272 zr36057_set_memgrab(zr, 1); 2273 } 2274 break; 2275 2276 case ZORAN_MAP_MODE_JPG_REC: 2277 case ZORAN_MAP_MODE_JPG_PLAY: 2278 /* what is the codec mode right now? */ 2279 if (zr->jpg_buffers.active != ZORAN_ACTIVE || 2280 fh->buffers.active != ZORAN_ACTIVE) { 2281 res = -EBUSY; 2282 goto strmon_unlock_and_return; 2283 } 2284 2285 zr->jpg_buffers.active = fh->buffers.active = ZORAN_LOCKED; 2286 2287 if (zr->jpg_que_head != zr->jpg_que_tail) { 2288 /* Start the jpeg codec when the first frame is queued */ 2289 jpeg_start(zr); 2290 } 2291 break; 2292 2293 default: 2294 dprintk(1, 2295 KERN_ERR 2296 "%s: VIDIOC_STREAMON - invalid map mode %d\n", 2297 ZR_DEVNAME(zr), fh->map_mode); 2298 res = -EINVAL; 2299 break; 2300 } 2301 strmon_unlock_and_return: 2302 mutex_unlock(&zr->resource_lock); 2303 2304 return res; 2305 } 2306 2307 static int zoran_streamoff(struct file *file, void *__fh, enum v4l2_buf_type type) 2308 { 2309 struct zoran_fh *fh = __fh; 2310 struct zoran *zr = fh->zr; 2311 int i, res = 0; 2312 unsigned long flags; 2313 2314 mutex_lock(&zr->resource_lock); 2315 2316 switch (fh->map_mode) { 2317 case ZORAN_MAP_MODE_RAW: /* raw capture */ 2318 if (fh->buffers.active == ZORAN_FREE && 2319 zr->v4l_buffers.active != ZORAN_FREE) { 2320 res = -EPERM; /* stay off other's settings! */ 2321 goto strmoff_unlock_and_return; 2322 } 2323 if (zr->v4l_buffers.active == ZORAN_FREE) 2324 goto strmoff_unlock_and_return; 2325 2326 spin_lock_irqsave(&zr->spinlock, flags); 2327 /* unload capture */ 2328 if (zr->v4l_memgrab_active) { 2329 2330 zr36057_set_memgrab(zr, 0); 2331 } 2332 2333 for (i = 0; i < fh->buffers.num_buffers; i++) 2334 zr->v4l_buffers.buffer[i].state = BUZ_STATE_USER; 2335 fh->buffers = zr->v4l_buffers; 2336 2337 zr->v4l_buffers.active = fh->buffers.active = ZORAN_FREE; 2338 2339 zr->v4l_grab_seq = 0; 2340 zr->v4l_pend_head = zr->v4l_pend_tail = 0; 2341 zr->v4l_sync_tail = 0; 2342 2343 spin_unlock_irqrestore(&zr->spinlock, flags); 2344 2345 break; 2346 2347 case ZORAN_MAP_MODE_JPG_REC: 2348 case ZORAN_MAP_MODE_JPG_PLAY: 2349 if (fh->buffers.active == ZORAN_FREE && 2350 zr->jpg_buffers.active != ZORAN_FREE) { 2351 res = -EPERM; /* stay off other's settings! */ 2352 goto strmoff_unlock_and_return; 2353 } 2354 if (zr->jpg_buffers.active == ZORAN_FREE) 2355 goto strmoff_unlock_and_return; 2356 2357 res = jpg_qbuf(fh, -1, 2358 (fh->map_mode == ZORAN_MAP_MODE_JPG_REC) ? 2359 BUZ_MODE_MOTION_COMPRESS : 2360 BUZ_MODE_MOTION_DECOMPRESS); 2361 if (res) 2362 goto strmoff_unlock_and_return; 2363 break; 2364 default: 2365 dprintk(1, KERN_ERR 2366 "%s: VIDIOC_STREAMOFF - invalid map mode %d\n", 2367 ZR_DEVNAME(zr), fh->map_mode); 2368 res = -EINVAL; 2369 break; 2370 } 2371 strmoff_unlock_and_return: 2372 mutex_unlock(&zr->resource_lock); 2373 2374 return res; 2375 } 2376 2377 static int zoran_queryctrl(struct file *file, void *__fh, 2378 struct v4l2_queryctrl *ctrl) 2379 { 2380 struct zoran_fh *fh = __fh; 2381 struct zoran *zr = fh->zr; 2382 2383 /* we only support hue/saturation/contrast/brightness */ 2384 if (ctrl->id < V4L2_CID_BRIGHTNESS || 2385 ctrl->id > V4L2_CID_HUE) 2386 return -EINVAL; 2387 2388 decoder_call(zr, core, queryctrl, ctrl); 2389 2390 return 0; 2391 } 2392 2393 static int zoran_g_ctrl(struct file *file, void *__fh, struct v4l2_control *ctrl) 2394 { 2395 struct zoran_fh *fh = __fh; 2396 struct zoran *zr = fh->zr; 2397 2398 /* we only support hue/saturation/contrast/brightness */ 2399 if (ctrl->id < V4L2_CID_BRIGHTNESS || 2400 ctrl->id > V4L2_CID_HUE) 2401 return -EINVAL; 2402 2403 mutex_lock(&zr->resource_lock); 2404 decoder_call(zr, core, g_ctrl, ctrl); 2405 mutex_unlock(&zr->resource_lock); 2406 2407 return 0; 2408 } 2409 2410 static int zoran_s_ctrl(struct file *file, void *__fh, struct v4l2_control *ctrl) 2411 { 2412 struct zoran_fh *fh = __fh; 2413 struct zoran *zr = fh->zr; 2414 2415 /* we only support hue/saturation/contrast/brightness */ 2416 if (ctrl->id < V4L2_CID_BRIGHTNESS || 2417 ctrl->id > V4L2_CID_HUE) 2418 return -EINVAL; 2419 2420 mutex_lock(&zr->resource_lock); 2421 decoder_call(zr, core, s_ctrl, ctrl); 2422 mutex_unlock(&zr->resource_lock); 2423 2424 return 0; 2425 } 2426 2427 static int zoran_g_std(struct file *file, void *__fh, v4l2_std_id *std) 2428 { 2429 struct zoran_fh *fh = __fh; 2430 struct zoran *zr = fh->zr; 2431 2432 mutex_lock(&zr->resource_lock); 2433 *std = zr->norm; 2434 mutex_unlock(&zr->resource_lock); 2435 return 0; 2436 } 2437 2438 static int zoran_s_std(struct file *file, void *__fh, v4l2_std_id *std) 2439 { 2440 struct zoran_fh *fh = __fh; 2441 struct zoran *zr = fh->zr; 2442 int res = 0; 2443 2444 mutex_lock(&zr->resource_lock); 2445 res = zoran_set_norm(zr, *std); 2446 if (res) 2447 goto sstd_unlock_and_return; 2448 2449 res = wait_grab_pending(zr); 2450 sstd_unlock_and_return: 2451 mutex_unlock(&zr->resource_lock); 2452 return res; 2453 } 2454 2455 static int zoran_enum_input(struct file *file, void *__fh, 2456 struct v4l2_input *inp) 2457 { 2458 struct zoran_fh *fh = __fh; 2459 struct zoran *zr = fh->zr; 2460 2461 if (inp->index >= zr->card.inputs) 2462 return -EINVAL; 2463 2464 strncpy(inp->name, zr->card.input[inp->index].name, 2465 sizeof(inp->name) - 1); 2466 inp->type = V4L2_INPUT_TYPE_CAMERA; 2467 inp->std = V4L2_STD_ALL; 2468 2469 /* Get status of video decoder */ 2470 mutex_lock(&zr->resource_lock); 2471 decoder_call(zr, video, g_input_status, &inp->status); 2472 mutex_unlock(&zr->resource_lock); 2473 return 0; 2474 } 2475 2476 static int zoran_g_input(struct file *file, void *__fh, unsigned int *input) 2477 { 2478 struct zoran_fh *fh = __fh; 2479 struct zoran *zr = fh->zr; 2480 2481 mutex_lock(&zr->resource_lock); 2482 *input = zr->input; 2483 mutex_unlock(&zr->resource_lock); 2484 2485 return 0; 2486 } 2487 2488 static int zoran_s_input(struct file *file, void *__fh, unsigned int input) 2489 { 2490 struct zoran_fh *fh = __fh; 2491 struct zoran *zr = fh->zr; 2492 int res; 2493 2494 mutex_lock(&zr->resource_lock); 2495 res = zoran_set_input(zr, input); 2496 if (res) 2497 goto sinput_unlock_and_return; 2498 2499 /* Make sure the changes come into effect */ 2500 res = wait_grab_pending(zr); 2501 sinput_unlock_and_return: 2502 mutex_unlock(&zr->resource_lock); 2503 return res; 2504 } 2505 2506 static int zoran_enum_output(struct file *file, void *__fh, 2507 struct v4l2_output *outp) 2508 { 2509 if (outp->index != 0) 2510 return -EINVAL; 2511 2512 outp->index = 0; 2513 outp->type = V4L2_OUTPUT_TYPE_ANALOGVGAOVERLAY; 2514 strncpy(outp->name, "Autodetect", sizeof(outp->name)-1); 2515 2516 return 0; 2517 } 2518 2519 static int zoran_g_output(struct file *file, void *__fh, unsigned int *output) 2520 { 2521 *output = 0; 2522 2523 return 0; 2524 } 2525 2526 static int zoran_s_output(struct file *file, void *__fh, unsigned int output) 2527 { 2528 if (output != 0) 2529 return -EINVAL; 2530 2531 return 0; 2532 } 2533 2534 /* cropping (sub-frame capture) */ 2535 static int zoran_cropcap(struct file *file, void *__fh, 2536 struct v4l2_cropcap *cropcap) 2537 { 2538 struct zoran_fh *fh = __fh; 2539 struct zoran *zr = fh->zr; 2540 int type = cropcap->type, res = 0; 2541 2542 memset(cropcap, 0, sizeof(*cropcap)); 2543 cropcap->type = type; 2544 2545 mutex_lock(&zr->resource_lock); 2546 2547 if (cropcap->type != V4L2_BUF_TYPE_VIDEO_OUTPUT && 2548 (cropcap->type != V4L2_BUF_TYPE_VIDEO_CAPTURE || 2549 fh->map_mode == ZORAN_MAP_MODE_RAW)) { 2550 dprintk(1, KERN_ERR 2551 "%s: VIDIOC_CROPCAP - subcapture only supported for compressed capture\n", 2552 ZR_DEVNAME(zr)); 2553 res = -EINVAL; 2554 goto cropcap_unlock_and_return; 2555 } 2556 2557 cropcap->bounds.top = cropcap->bounds.left = 0; 2558 cropcap->bounds.width = BUZ_MAX_WIDTH; 2559 cropcap->bounds.height = BUZ_MAX_HEIGHT; 2560 cropcap->defrect.top = cropcap->defrect.left = 0; 2561 cropcap->defrect.width = BUZ_MIN_WIDTH; 2562 cropcap->defrect.height = BUZ_MIN_HEIGHT; 2563 cropcap_unlock_and_return: 2564 mutex_unlock(&zr->resource_lock); 2565 return res; 2566 } 2567 2568 static int zoran_g_crop(struct file *file, void *__fh, struct v4l2_crop *crop) 2569 { 2570 struct zoran_fh *fh = __fh; 2571 struct zoran *zr = fh->zr; 2572 int type = crop->type, res = 0; 2573 2574 memset(crop, 0, sizeof(*crop)); 2575 crop->type = type; 2576 2577 mutex_lock(&zr->resource_lock); 2578 2579 if (crop->type != V4L2_BUF_TYPE_VIDEO_OUTPUT && 2580 (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE || 2581 fh->map_mode == ZORAN_MAP_MODE_RAW)) { 2582 dprintk(1, 2583 KERN_ERR 2584 "%s: VIDIOC_G_CROP - subcapture only supported for compressed capture\n", 2585 ZR_DEVNAME(zr)); 2586 res = -EINVAL; 2587 goto gcrop_unlock_and_return; 2588 } 2589 2590 crop->c.top = fh->jpg_settings.img_y; 2591 crop->c.left = fh->jpg_settings.img_x; 2592 crop->c.width = fh->jpg_settings.img_width; 2593 crop->c.height = fh->jpg_settings.img_height; 2594 2595 gcrop_unlock_and_return: 2596 mutex_unlock(&zr->resource_lock); 2597 2598 return res; 2599 } 2600 2601 static int zoran_s_crop(struct file *file, void *__fh, const struct v4l2_crop *crop) 2602 { 2603 struct zoran_fh *fh = __fh; 2604 struct zoran *zr = fh->zr; 2605 int res = 0; 2606 struct zoran_jpg_settings settings; 2607 2608 settings = fh->jpg_settings; 2609 2610 mutex_lock(&zr->resource_lock); 2611 2612 if (fh->buffers.allocated) { 2613 dprintk(1, KERN_ERR 2614 "%s: VIDIOC_S_CROP - cannot change settings while active\n", 2615 ZR_DEVNAME(zr)); 2616 res = -EBUSY; 2617 goto scrop_unlock_and_return; 2618 } 2619 2620 if (crop->type != V4L2_BUF_TYPE_VIDEO_OUTPUT && 2621 (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE || 2622 fh->map_mode == ZORAN_MAP_MODE_RAW)) { 2623 dprintk(1, KERN_ERR 2624 "%s: VIDIOC_G_CROP - subcapture only supported for compressed capture\n", 2625 ZR_DEVNAME(zr)); 2626 res = -EINVAL; 2627 goto scrop_unlock_and_return; 2628 } 2629 2630 /* move into a form that we understand */ 2631 settings.img_x = crop->c.left; 2632 settings.img_y = crop->c.top; 2633 settings.img_width = crop->c.width; 2634 settings.img_height = crop->c.height; 2635 2636 /* check validity */ 2637 res = zoran_check_jpg_settings(zr, &settings, 0); 2638 if (res) 2639 goto scrop_unlock_and_return; 2640 2641 /* accept */ 2642 fh->jpg_settings = settings; 2643 2644 scrop_unlock_and_return: 2645 mutex_unlock(&zr->resource_lock); 2646 return res; 2647 } 2648 2649 static int zoran_g_jpegcomp(struct file *file, void *__fh, 2650 struct v4l2_jpegcompression *params) 2651 { 2652 struct zoran_fh *fh = __fh; 2653 struct zoran *zr = fh->zr; 2654 memset(params, 0, sizeof(*params)); 2655 2656 mutex_lock(&zr->resource_lock); 2657 2658 params->quality = fh->jpg_settings.jpg_comp.quality; 2659 params->APPn = fh->jpg_settings.jpg_comp.APPn; 2660 memcpy(params->APP_data, 2661 fh->jpg_settings.jpg_comp.APP_data, 2662 fh->jpg_settings.jpg_comp.APP_len); 2663 params->APP_len = fh->jpg_settings.jpg_comp.APP_len; 2664 memcpy(params->COM_data, 2665 fh->jpg_settings.jpg_comp.COM_data, 2666 fh->jpg_settings.jpg_comp.COM_len); 2667 params->COM_len = fh->jpg_settings.jpg_comp.COM_len; 2668 params->jpeg_markers = 2669 fh->jpg_settings.jpg_comp.jpeg_markers; 2670 2671 mutex_unlock(&zr->resource_lock); 2672 2673 return 0; 2674 } 2675 2676 static int zoran_s_jpegcomp(struct file *file, void *__fh, 2677 const struct v4l2_jpegcompression *params) 2678 { 2679 struct zoran_fh *fh = __fh; 2680 struct zoran *zr = fh->zr; 2681 int res = 0; 2682 struct zoran_jpg_settings settings; 2683 2684 settings = fh->jpg_settings; 2685 2686 settings.jpg_comp = *params; 2687 2688 mutex_lock(&zr->resource_lock); 2689 2690 if (fh->buffers.active != ZORAN_FREE) { 2691 dprintk(1, KERN_WARNING 2692 "%s: VIDIOC_S_JPEGCOMP called while in playback/capture mode\n", 2693 ZR_DEVNAME(zr)); 2694 res = -EBUSY; 2695 goto sjpegc_unlock_and_return; 2696 } 2697 2698 res = zoran_check_jpg_settings(zr, &settings, 0); 2699 if (res) 2700 goto sjpegc_unlock_and_return; 2701 if (!fh->buffers.allocated) 2702 fh->buffers.buffer_size = 2703 zoran_v4l2_calc_bufsize(&fh->jpg_settings); 2704 fh->jpg_settings.jpg_comp = settings.jpg_comp; 2705 sjpegc_unlock_and_return: 2706 mutex_unlock(&zr->resource_lock); 2707 2708 return res; 2709 } 2710 2711 static unsigned int 2712 zoran_poll (struct file *file, 2713 poll_table *wait) 2714 { 2715 struct zoran_fh *fh = file->private_data; 2716 struct zoran *zr = fh->zr; 2717 int res = 0, frame; 2718 unsigned long flags; 2719 2720 /* we should check whether buffers are ready to be synced on 2721 * (w/o waits - O_NONBLOCK) here 2722 * if ready for read (sync), return POLLIN|POLLRDNORM, 2723 * if ready for write (sync), return POLLOUT|POLLWRNORM, 2724 * if error, return POLLERR, 2725 * if no buffers queued or so, return POLLNVAL 2726 */ 2727 2728 mutex_lock(&zr->resource_lock); 2729 2730 switch (fh->map_mode) { 2731 case ZORAN_MAP_MODE_RAW: 2732 poll_wait(file, &zr->v4l_capq, wait); 2733 frame = zr->v4l_pend[zr->v4l_sync_tail & V4L_MASK_FRAME]; 2734 2735 spin_lock_irqsave(&zr->spinlock, flags); 2736 dprintk(3, 2737 KERN_DEBUG 2738 "%s: %s() raw - active=%c, sync_tail=%lu/%c, pend_tail=%lu, pend_head=%lu\n", 2739 ZR_DEVNAME(zr), __func__, 2740 "FAL"[fh->buffers.active], zr->v4l_sync_tail, 2741 "UPMD"[zr->v4l_buffers.buffer[frame].state], 2742 zr->v4l_pend_tail, zr->v4l_pend_head); 2743 /* Process is the one capturing? */ 2744 if (fh->buffers.active != ZORAN_FREE && 2745 /* Buffer ready to DQBUF? */ 2746 zr->v4l_buffers.buffer[frame].state == BUZ_STATE_DONE) 2747 res = POLLIN | POLLRDNORM; 2748 spin_unlock_irqrestore(&zr->spinlock, flags); 2749 2750 break; 2751 2752 case ZORAN_MAP_MODE_JPG_REC: 2753 case ZORAN_MAP_MODE_JPG_PLAY: 2754 poll_wait(file, &zr->jpg_capq, wait); 2755 frame = zr->jpg_pend[zr->jpg_que_tail & BUZ_MASK_FRAME]; 2756 2757 spin_lock_irqsave(&zr->spinlock, flags); 2758 dprintk(3, 2759 KERN_DEBUG 2760 "%s: %s() jpg - active=%c, que_tail=%lu/%c, que_head=%lu, dma=%lu/%lu\n", 2761 ZR_DEVNAME(zr), __func__, 2762 "FAL"[fh->buffers.active], zr->jpg_que_tail, 2763 "UPMD"[zr->jpg_buffers.buffer[frame].state], 2764 zr->jpg_que_head, zr->jpg_dma_tail, zr->jpg_dma_head); 2765 if (fh->buffers.active != ZORAN_FREE && 2766 zr->jpg_buffers.buffer[frame].state == BUZ_STATE_DONE) { 2767 if (fh->map_mode == ZORAN_MAP_MODE_JPG_REC) 2768 res = POLLIN | POLLRDNORM; 2769 else 2770 res = POLLOUT | POLLWRNORM; 2771 } 2772 spin_unlock_irqrestore(&zr->spinlock, flags); 2773 2774 break; 2775 2776 default: 2777 dprintk(1, 2778 KERN_ERR 2779 "%s: %s - internal error, unknown map_mode=%d\n", 2780 ZR_DEVNAME(zr), __func__, fh->map_mode); 2781 res = POLLNVAL; 2782 } 2783 2784 mutex_unlock(&zr->resource_lock); 2785 2786 return res; 2787 } 2788 2789 2790 /* 2791 * This maps the buffers to user space. 2792 * 2793 * Depending on the state of fh->map_mode 2794 * the V4L or the MJPEG buffers are mapped 2795 * per buffer or all together 2796 * 2797 * Note that we need to connect to some 2798 * unmap signal event to unmap the de-allocate 2799 * the buffer accordingly (zoran_vm_close()) 2800 */ 2801 2802 static void 2803 zoran_vm_open (struct vm_area_struct *vma) 2804 { 2805 struct zoran_mapping *map = vma->vm_private_data; 2806 2807 map->count++; 2808 } 2809 2810 static void 2811 zoran_vm_close (struct vm_area_struct *vma) 2812 { 2813 struct zoran_mapping *map = vma->vm_private_data; 2814 struct zoran_fh *fh = map->fh; 2815 struct zoran *zr = fh->zr; 2816 int i; 2817 2818 if (--map->count > 0) 2819 return; 2820 2821 dprintk(3, KERN_INFO "%s: %s - munmap(%s)\n", ZR_DEVNAME(zr), 2822 __func__, mode_name(fh->map_mode)); 2823 2824 for (i = 0; i < fh->buffers.num_buffers; i++) { 2825 if (fh->buffers.buffer[i].map == map) 2826 fh->buffers.buffer[i].map = NULL; 2827 } 2828 kfree(map); 2829 2830 /* Any buffers still mapped? */ 2831 for (i = 0; i < fh->buffers.num_buffers; i++) 2832 if (fh->buffers.buffer[i].map) 2833 return; 2834 2835 dprintk(3, KERN_INFO "%s: %s - free %s buffers\n", ZR_DEVNAME(zr), 2836 __func__, mode_name(fh->map_mode)); 2837 2838 mutex_lock(&zr->resource_lock); 2839 2840 if (fh->map_mode == ZORAN_MAP_MODE_RAW) { 2841 if (fh->buffers.active != ZORAN_FREE) { 2842 unsigned long flags; 2843 2844 spin_lock_irqsave(&zr->spinlock, flags); 2845 zr36057_set_memgrab(zr, 0); 2846 zr->v4l_buffers.allocated = 0; 2847 zr->v4l_buffers.active = fh->buffers.active = ZORAN_FREE; 2848 spin_unlock_irqrestore(&zr->spinlock, flags); 2849 } 2850 v4l_fbuffer_free(fh); 2851 } else { 2852 if (fh->buffers.active != ZORAN_FREE) { 2853 jpg_qbuf(fh, -1, zr->codec_mode); 2854 zr->jpg_buffers.allocated = 0; 2855 zr->jpg_buffers.active = fh->buffers.active = ZORAN_FREE; 2856 } 2857 jpg_fbuffer_free(fh); 2858 } 2859 2860 mutex_unlock(&zr->resource_lock); 2861 } 2862 2863 static const struct vm_operations_struct zoran_vm_ops = { 2864 .open = zoran_vm_open, 2865 .close = zoran_vm_close, 2866 }; 2867 2868 static int 2869 zoran_mmap (struct file *file, 2870 struct vm_area_struct *vma) 2871 { 2872 struct zoran_fh *fh = file->private_data; 2873 struct zoran *zr = fh->zr; 2874 unsigned long size = (vma->vm_end - vma->vm_start); 2875 unsigned long offset = vma->vm_pgoff << PAGE_SHIFT; 2876 int i, j; 2877 unsigned long page, start = vma->vm_start, todo, pos, fraglen; 2878 int first, last; 2879 struct zoran_mapping *map; 2880 int res = 0; 2881 2882 dprintk(3, 2883 KERN_INFO "%s: %s(%s) of 0x%08lx-0x%08lx (size=%lu)\n", 2884 ZR_DEVNAME(zr), __func__, 2885 mode_name(fh->map_mode), vma->vm_start, vma->vm_end, size); 2886 2887 if (!(vma->vm_flags & VM_SHARED) || !(vma->vm_flags & VM_READ) || 2888 !(vma->vm_flags & VM_WRITE)) { 2889 dprintk(1, 2890 KERN_ERR 2891 "%s: %s - no MAP_SHARED/PROT_{READ,WRITE} given\n", 2892 ZR_DEVNAME(zr), __func__); 2893 return -EINVAL; 2894 } 2895 2896 mutex_lock(&zr->resource_lock); 2897 2898 if (!fh->buffers.allocated) { 2899 dprintk(1, 2900 KERN_ERR 2901 "%s: %s(%s) - buffers not yet allocated\n", 2902 ZR_DEVNAME(zr), __func__, mode_name(fh->map_mode)); 2903 res = -ENOMEM; 2904 goto mmap_unlock_and_return; 2905 } 2906 2907 first = offset / fh->buffers.buffer_size; 2908 last = first - 1 + size / fh->buffers.buffer_size; 2909 if (offset % fh->buffers.buffer_size != 0 || 2910 size % fh->buffers.buffer_size != 0 || first < 0 || 2911 last < 0 || first >= fh->buffers.num_buffers || 2912 last >= fh->buffers.buffer_size) { 2913 dprintk(1, 2914 KERN_ERR 2915 "%s: %s(%s) - offset=%lu or size=%lu invalid for bufsize=%d and numbufs=%d\n", 2916 ZR_DEVNAME(zr), __func__, mode_name(fh->map_mode), offset, size, 2917 fh->buffers.buffer_size, 2918 fh->buffers.num_buffers); 2919 res = -EINVAL; 2920 goto mmap_unlock_and_return; 2921 } 2922 2923 /* Check if any buffers are already mapped */ 2924 for (i = first; i <= last; i++) { 2925 if (fh->buffers.buffer[i].map) { 2926 dprintk(1, 2927 KERN_ERR 2928 "%s: %s(%s) - buffer %d already mapped\n", 2929 ZR_DEVNAME(zr), __func__, mode_name(fh->map_mode), i); 2930 res = -EBUSY; 2931 goto mmap_unlock_and_return; 2932 } 2933 } 2934 2935 /* map these buffers */ 2936 map = kmalloc(sizeof(struct zoran_mapping), GFP_KERNEL); 2937 if (!map) { 2938 res = -ENOMEM; 2939 goto mmap_unlock_and_return; 2940 } 2941 map->fh = fh; 2942 map->count = 1; 2943 2944 vma->vm_ops = &zoran_vm_ops; 2945 vma->vm_flags |= VM_DONTEXPAND; 2946 vma->vm_private_data = map; 2947 2948 if (fh->map_mode == ZORAN_MAP_MODE_RAW) { 2949 for (i = first; i <= last; i++) { 2950 todo = size; 2951 if (todo > fh->buffers.buffer_size) 2952 todo = fh->buffers.buffer_size; 2953 page = fh->buffers.buffer[i].v4l.fbuffer_phys; 2954 if (remap_pfn_range(vma, start, page >> PAGE_SHIFT, 2955 todo, PAGE_SHARED)) { 2956 dprintk(1, 2957 KERN_ERR 2958 "%s: %s(V4L) - remap_pfn_range failed\n", 2959 ZR_DEVNAME(zr), __func__); 2960 res = -EAGAIN; 2961 goto mmap_unlock_and_return; 2962 } 2963 size -= todo; 2964 start += todo; 2965 fh->buffers.buffer[i].map = map; 2966 if (size == 0) 2967 break; 2968 } 2969 } else { 2970 for (i = first; i <= last; i++) { 2971 for (j = 0; 2972 j < fh->buffers.buffer_size / PAGE_SIZE; 2973 j++) { 2974 fraglen = 2975 (le32_to_cpu(fh->buffers.buffer[i].jpg. 2976 frag_tab[2 * j + 1]) & ~1) << 1; 2977 todo = size; 2978 if (todo > fraglen) 2979 todo = fraglen; 2980 pos = 2981 le32_to_cpu(fh->buffers. 2982 buffer[i].jpg.frag_tab[2 * j]); 2983 /* should just be pos on i386 */ 2984 page = virt_to_phys(bus_to_virt(pos)) 2985 >> PAGE_SHIFT; 2986 if (remap_pfn_range(vma, start, page, 2987 todo, PAGE_SHARED)) { 2988 dprintk(1, 2989 KERN_ERR 2990 "%s: %s(V4L) - remap_pfn_range failed\n", 2991 ZR_DEVNAME(zr), __func__); 2992 res = -EAGAIN; 2993 goto mmap_unlock_and_return; 2994 } 2995 size -= todo; 2996 start += todo; 2997 if (size == 0) 2998 break; 2999 if (le32_to_cpu(fh->buffers.buffer[i].jpg. 3000 frag_tab[2 * j + 1]) & 1) 3001 break; /* was last fragment */ 3002 } 3003 fh->buffers.buffer[i].map = map; 3004 if (size == 0) 3005 break; 3006 3007 } 3008 } 3009 3010 mmap_unlock_and_return: 3011 mutex_unlock(&zr->resource_lock); 3012 3013 return res; 3014 } 3015 3016 static const struct v4l2_ioctl_ops zoran_ioctl_ops = { 3017 .vidioc_querycap = zoran_querycap, 3018 .vidioc_cropcap = zoran_cropcap, 3019 .vidioc_s_crop = zoran_s_crop, 3020 .vidioc_g_crop = zoran_g_crop, 3021 .vidioc_enum_input = zoran_enum_input, 3022 .vidioc_g_input = zoran_g_input, 3023 .vidioc_s_input = zoran_s_input, 3024 .vidioc_enum_output = zoran_enum_output, 3025 .vidioc_g_output = zoran_g_output, 3026 .vidioc_s_output = zoran_s_output, 3027 .vidioc_g_fbuf = zoran_g_fbuf, 3028 .vidioc_s_fbuf = zoran_s_fbuf, 3029 .vidioc_g_std = zoran_g_std, 3030 .vidioc_s_std = zoran_s_std, 3031 .vidioc_g_jpegcomp = zoran_g_jpegcomp, 3032 .vidioc_s_jpegcomp = zoran_s_jpegcomp, 3033 .vidioc_overlay = zoran_overlay, 3034 .vidioc_reqbufs = zoran_reqbufs, 3035 .vidioc_querybuf = zoran_querybuf, 3036 .vidioc_qbuf = zoran_qbuf, 3037 .vidioc_dqbuf = zoran_dqbuf, 3038 .vidioc_streamon = zoran_streamon, 3039 .vidioc_streamoff = zoran_streamoff, 3040 .vidioc_enum_fmt_vid_cap = zoran_enum_fmt_vid_cap, 3041 .vidioc_enum_fmt_vid_out = zoran_enum_fmt_vid_out, 3042 .vidioc_enum_fmt_vid_overlay = zoran_enum_fmt_vid_overlay, 3043 .vidioc_g_fmt_vid_cap = zoran_g_fmt_vid_cap, 3044 .vidioc_g_fmt_vid_out = zoran_g_fmt_vid_out, 3045 .vidioc_g_fmt_vid_overlay = zoran_g_fmt_vid_overlay, 3046 .vidioc_s_fmt_vid_cap = zoran_s_fmt_vid_cap, 3047 .vidioc_s_fmt_vid_out = zoran_s_fmt_vid_out, 3048 .vidioc_s_fmt_vid_overlay = zoran_s_fmt_vid_overlay, 3049 .vidioc_try_fmt_vid_cap = zoran_try_fmt_vid_cap, 3050 .vidioc_try_fmt_vid_out = zoran_try_fmt_vid_out, 3051 .vidioc_try_fmt_vid_overlay = zoran_try_fmt_vid_overlay, 3052 .vidioc_queryctrl = zoran_queryctrl, 3053 .vidioc_s_ctrl = zoran_s_ctrl, 3054 .vidioc_g_ctrl = zoran_g_ctrl, 3055 }; 3056 3057 /* please use zr->resource_lock consistently and kill this wrapper */ 3058 static long zoran_ioctl(struct file *file, unsigned int cmd, 3059 unsigned long arg) 3060 { 3061 struct zoran_fh *fh = file->private_data; 3062 struct zoran *zr = fh->zr; 3063 int ret; 3064 3065 mutex_lock(&zr->other_lock); 3066 ret = video_ioctl2(file, cmd, arg); 3067 mutex_unlock(&zr->other_lock); 3068 3069 return ret; 3070 } 3071 3072 static const struct v4l2_file_operations zoran_fops = { 3073 .owner = THIS_MODULE, 3074 .open = zoran_open, 3075 .release = zoran_close, 3076 .unlocked_ioctl = zoran_ioctl, 3077 .read = zoran_read, 3078 .write = zoran_write, 3079 .mmap = zoran_mmap, 3080 .poll = zoran_poll, 3081 }; 3082 3083 struct video_device zoran_template __devinitdata = { 3084 .name = ZORAN_NAME, 3085 .fops = &zoran_fops, 3086 .ioctl_ops = &zoran_ioctl_ops, 3087 .release = &zoran_vdev_release, 3088 .tvnorms = V4L2_STD_NTSC | V4L2_STD_PAL | V4L2_STD_SECAM, 3089 }; 3090 3091