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 | V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 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_SECAM) 1460 zr->timing = zr->card.tvn[2]; 1461 else if (norm & V4L2_STD_NTSC) 1462 zr->timing = zr->card.tvn[1]; 1463 else 1464 zr->timing = zr->card.tvn[0]; 1465 1466 /* We switch overlay off and on since a change in the 1467 * norm needs different VFE settings */ 1468 on = zr->overlay_active && !zr->v4l_memgrab_active; 1469 if (on) 1470 zr36057_overlay(zr, 0); 1471 1472 decoder_call(zr, video, s_std, norm); 1473 encoder_call(zr, video, s_std_output, norm); 1474 1475 if (on) 1476 zr36057_overlay(zr, 1); 1477 1478 /* Make sure the changes come into effect */ 1479 zr->norm = norm; 1480 1481 return 0; 1482 } 1483 1484 static int 1485 zoran_set_input (struct zoran *zr, 1486 int input) 1487 { 1488 if (input == zr->input) { 1489 return 0; 1490 } 1491 1492 if (zr->v4l_buffers.active != ZORAN_FREE || 1493 zr->jpg_buffers.active != ZORAN_FREE) { 1494 dprintk(1, 1495 KERN_WARNING 1496 "%s: %s called while in playback/capture mode\n", 1497 ZR_DEVNAME(zr), __func__); 1498 return -EBUSY; 1499 } 1500 1501 if (input < 0 || input >= zr->card.inputs) { 1502 dprintk(1, 1503 KERN_ERR 1504 "%s: %s - unnsupported input %d\n", 1505 ZR_DEVNAME(zr), __func__, input); 1506 return -EINVAL; 1507 } 1508 1509 zr->input = input; 1510 1511 decoder_call(zr, video, s_routing, 1512 zr->card.input[input].muxsel, 0, 0); 1513 1514 return 0; 1515 } 1516 1517 /* 1518 * ioctl routine 1519 */ 1520 1521 static int zoran_querycap(struct file *file, void *__fh, struct v4l2_capability *cap) 1522 { 1523 struct zoran_fh *fh = __fh; 1524 struct zoran *zr = fh->zr; 1525 1526 memset(cap, 0, sizeof(*cap)); 1527 strncpy(cap->card, ZR_DEVNAME(zr), sizeof(cap->card)-1); 1528 strncpy(cap->driver, "zoran", sizeof(cap->driver)-1); 1529 snprintf(cap->bus_info, sizeof(cap->bus_info), "PCI:%s", 1530 pci_name(zr->pci_dev)); 1531 cap->device_caps = V4L2_CAP_STREAMING | V4L2_CAP_VIDEO_CAPTURE | 1532 V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_VIDEO_OVERLAY; 1533 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS; 1534 return 0; 1535 } 1536 1537 static int zoran_enum_fmt(struct zoran *zr, struct v4l2_fmtdesc *fmt, int flag) 1538 { 1539 unsigned int num, i; 1540 1541 for (num = i = 0; i < NUM_FORMATS; i++) { 1542 if (zoran_formats[i].flags & flag && num++ == fmt->index) { 1543 strncpy(fmt->description, zoran_formats[i].name, 1544 sizeof(fmt->description) - 1); 1545 /* fmt struct pre-zeroed, so adding '\0' not needed */ 1546 fmt->pixelformat = zoran_formats[i].fourcc; 1547 if (zoran_formats[i].flags & ZORAN_FORMAT_COMPRESSED) 1548 fmt->flags |= V4L2_FMT_FLAG_COMPRESSED; 1549 return 0; 1550 } 1551 } 1552 return -EINVAL; 1553 } 1554 1555 static int zoran_enum_fmt_vid_cap(struct file *file, void *__fh, 1556 struct v4l2_fmtdesc *f) 1557 { 1558 struct zoran_fh *fh = __fh; 1559 struct zoran *zr = fh->zr; 1560 1561 return zoran_enum_fmt(zr, f, ZORAN_FORMAT_CAPTURE); 1562 } 1563 1564 static int zoran_enum_fmt_vid_out(struct file *file, void *__fh, 1565 struct v4l2_fmtdesc *f) 1566 { 1567 struct zoran_fh *fh = __fh; 1568 struct zoran *zr = fh->zr; 1569 1570 return zoran_enum_fmt(zr, f, ZORAN_FORMAT_PLAYBACK); 1571 } 1572 1573 static int zoran_enum_fmt_vid_overlay(struct file *file, void *__fh, 1574 struct v4l2_fmtdesc *f) 1575 { 1576 struct zoran_fh *fh = __fh; 1577 struct zoran *zr = fh->zr; 1578 1579 return zoran_enum_fmt(zr, f, ZORAN_FORMAT_OVERLAY); 1580 } 1581 1582 static int zoran_g_fmt_vid_out(struct file *file, void *__fh, 1583 struct v4l2_format *fmt) 1584 { 1585 struct zoran_fh *fh = __fh; 1586 struct zoran *zr = fh->zr; 1587 1588 mutex_lock(&zr->resource_lock); 1589 1590 fmt->fmt.pix.width = fh->jpg_settings.img_width / fh->jpg_settings.HorDcm; 1591 fmt->fmt.pix.height = fh->jpg_settings.img_height * 2 / 1592 (fh->jpg_settings.VerDcm * fh->jpg_settings.TmpDcm); 1593 fmt->fmt.pix.sizeimage = zoran_v4l2_calc_bufsize(&fh->jpg_settings); 1594 fmt->fmt.pix.pixelformat = V4L2_PIX_FMT_MJPEG; 1595 if (fh->jpg_settings.TmpDcm == 1) 1596 fmt->fmt.pix.field = (fh->jpg_settings.odd_even ? 1597 V4L2_FIELD_SEQ_TB : V4L2_FIELD_SEQ_BT); 1598 else 1599 fmt->fmt.pix.field = (fh->jpg_settings.odd_even ? 1600 V4L2_FIELD_TOP : V4L2_FIELD_BOTTOM); 1601 fmt->fmt.pix.bytesperline = 0; 1602 fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; 1603 1604 mutex_unlock(&zr->resource_lock); 1605 return 0; 1606 } 1607 1608 static int zoran_g_fmt_vid_cap(struct file *file, void *__fh, 1609 struct v4l2_format *fmt) 1610 { 1611 struct zoran_fh *fh = __fh; 1612 struct zoran *zr = fh->zr; 1613 1614 if (fh->map_mode != ZORAN_MAP_MODE_RAW) 1615 return zoran_g_fmt_vid_out(file, fh, fmt); 1616 1617 mutex_lock(&zr->resource_lock); 1618 fmt->fmt.pix.width = fh->v4l_settings.width; 1619 fmt->fmt.pix.height = fh->v4l_settings.height; 1620 fmt->fmt.pix.sizeimage = fh->v4l_settings.bytesperline * 1621 fh->v4l_settings.height; 1622 fmt->fmt.pix.pixelformat = fh->v4l_settings.format->fourcc; 1623 fmt->fmt.pix.colorspace = fh->v4l_settings.format->colorspace; 1624 fmt->fmt.pix.bytesperline = fh->v4l_settings.bytesperline; 1625 if (BUZ_MAX_HEIGHT < (fh->v4l_settings.height * 2)) 1626 fmt->fmt.pix.field = V4L2_FIELD_INTERLACED; 1627 else 1628 fmt->fmt.pix.field = V4L2_FIELD_TOP; 1629 mutex_unlock(&zr->resource_lock); 1630 return 0; 1631 } 1632 1633 static int zoran_g_fmt_vid_overlay(struct file *file, void *__fh, 1634 struct v4l2_format *fmt) 1635 { 1636 struct zoran_fh *fh = __fh; 1637 struct zoran *zr = fh->zr; 1638 1639 mutex_lock(&zr->resource_lock); 1640 1641 fmt->fmt.win.w.left = fh->overlay_settings.x; 1642 fmt->fmt.win.w.top = fh->overlay_settings.y; 1643 fmt->fmt.win.w.width = fh->overlay_settings.width; 1644 fmt->fmt.win.w.height = fh->overlay_settings.height; 1645 if (fh->overlay_settings.width * 2 > BUZ_MAX_HEIGHT) 1646 fmt->fmt.win.field = V4L2_FIELD_INTERLACED; 1647 else 1648 fmt->fmt.win.field = V4L2_FIELD_TOP; 1649 1650 mutex_unlock(&zr->resource_lock); 1651 return 0; 1652 } 1653 1654 static int zoran_try_fmt_vid_overlay(struct file *file, void *__fh, 1655 struct v4l2_format *fmt) 1656 { 1657 struct zoran_fh *fh = __fh; 1658 struct zoran *zr = fh->zr; 1659 1660 mutex_lock(&zr->resource_lock); 1661 1662 if (fmt->fmt.win.w.width > BUZ_MAX_WIDTH) 1663 fmt->fmt.win.w.width = BUZ_MAX_WIDTH; 1664 if (fmt->fmt.win.w.width < BUZ_MIN_WIDTH) 1665 fmt->fmt.win.w.width = BUZ_MIN_WIDTH; 1666 if (fmt->fmt.win.w.height > BUZ_MAX_HEIGHT) 1667 fmt->fmt.win.w.height = BUZ_MAX_HEIGHT; 1668 if (fmt->fmt.win.w.height < BUZ_MIN_HEIGHT) 1669 fmt->fmt.win.w.height = BUZ_MIN_HEIGHT; 1670 1671 mutex_unlock(&zr->resource_lock); 1672 return 0; 1673 } 1674 1675 static int zoran_try_fmt_vid_out(struct file *file, void *__fh, 1676 struct v4l2_format *fmt) 1677 { 1678 struct zoran_fh *fh = __fh; 1679 struct zoran *zr = fh->zr; 1680 struct zoran_jpg_settings settings; 1681 int res = 0; 1682 1683 if (fmt->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG) 1684 return -EINVAL; 1685 1686 mutex_lock(&zr->resource_lock); 1687 settings = fh->jpg_settings; 1688 1689 /* we actually need to set 'real' parameters now */ 1690 if ((fmt->fmt.pix.height * 2) > BUZ_MAX_HEIGHT) 1691 settings.TmpDcm = 1; 1692 else 1693 settings.TmpDcm = 2; 1694 settings.decimation = 0; 1695 if (fmt->fmt.pix.height <= fh->jpg_settings.img_height / 2) 1696 settings.VerDcm = 2; 1697 else 1698 settings.VerDcm = 1; 1699 if (fmt->fmt.pix.width <= fh->jpg_settings.img_width / 4) 1700 settings.HorDcm = 4; 1701 else if (fmt->fmt.pix.width <= fh->jpg_settings.img_width / 2) 1702 settings.HorDcm = 2; 1703 else 1704 settings.HorDcm = 1; 1705 if (settings.TmpDcm == 1) 1706 settings.field_per_buff = 2; 1707 else 1708 settings.field_per_buff = 1; 1709 1710 if (settings.HorDcm > 1) { 1711 settings.img_x = (BUZ_MAX_WIDTH == 720) ? 8 : 0; 1712 settings.img_width = (BUZ_MAX_WIDTH == 720) ? 704 : BUZ_MAX_WIDTH; 1713 } else { 1714 settings.img_x = 0; 1715 settings.img_width = BUZ_MAX_WIDTH; 1716 } 1717 1718 /* check */ 1719 res = zoran_check_jpg_settings(zr, &settings, 1); 1720 if (res) 1721 goto tryfmt_unlock_and_return; 1722 1723 /* tell the user what we actually did */ 1724 fmt->fmt.pix.width = settings.img_width / settings.HorDcm; 1725 fmt->fmt.pix.height = settings.img_height * 2 / 1726 (settings.TmpDcm * settings.VerDcm); 1727 if (settings.TmpDcm == 1) 1728 fmt->fmt.pix.field = (fh->jpg_settings.odd_even ? 1729 V4L2_FIELD_SEQ_TB : V4L2_FIELD_SEQ_BT); 1730 else 1731 fmt->fmt.pix.field = (fh->jpg_settings.odd_even ? 1732 V4L2_FIELD_TOP : V4L2_FIELD_BOTTOM); 1733 1734 fmt->fmt.pix.sizeimage = zoran_v4l2_calc_bufsize(&settings); 1735 fmt->fmt.pix.bytesperline = 0; 1736 fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; 1737 tryfmt_unlock_and_return: 1738 mutex_unlock(&zr->resource_lock); 1739 return res; 1740 } 1741 1742 static int zoran_try_fmt_vid_cap(struct file *file, void *__fh, 1743 struct v4l2_format *fmt) 1744 { 1745 struct zoran_fh *fh = __fh; 1746 struct zoran *zr = fh->zr; 1747 int bpp; 1748 int i; 1749 1750 if (fmt->fmt.pix.pixelformat == V4L2_PIX_FMT_MJPEG) 1751 return zoran_try_fmt_vid_out(file, fh, fmt); 1752 1753 mutex_lock(&zr->resource_lock); 1754 1755 for (i = 0; i < NUM_FORMATS; i++) 1756 if (zoran_formats[i].fourcc == fmt->fmt.pix.pixelformat) 1757 break; 1758 1759 if (i == NUM_FORMATS) { 1760 mutex_unlock(&zr->resource_lock); 1761 return -EINVAL; 1762 } 1763 1764 bpp = DIV_ROUND_UP(zoran_formats[i].depth, 8); 1765 v4l_bound_align_image( 1766 &fmt->fmt.pix.width, BUZ_MIN_WIDTH, BUZ_MAX_WIDTH, bpp == 2 ? 1 : 2, 1767 &fmt->fmt.pix.height, BUZ_MIN_HEIGHT, BUZ_MAX_HEIGHT, 0, 0); 1768 mutex_unlock(&zr->resource_lock); 1769 1770 return 0; 1771 } 1772 1773 static int zoran_s_fmt_vid_overlay(struct file *file, void *__fh, 1774 struct v4l2_format *fmt) 1775 { 1776 struct zoran_fh *fh = __fh; 1777 struct zoran *zr = fh->zr; 1778 int res; 1779 1780 dprintk(3, "x=%d, y=%d, w=%d, h=%d, cnt=%d, map=0x%p\n", 1781 fmt->fmt.win.w.left, fmt->fmt.win.w.top, 1782 fmt->fmt.win.w.width, 1783 fmt->fmt.win.w.height, 1784 fmt->fmt.win.clipcount, 1785 fmt->fmt.win.bitmap); 1786 mutex_lock(&zr->resource_lock); 1787 res = setup_window(fh, fmt->fmt.win.w.left, fmt->fmt.win.w.top, 1788 fmt->fmt.win.w.width, fmt->fmt.win.w.height, 1789 (struct v4l2_clip __user *)fmt->fmt.win.clips, 1790 fmt->fmt.win.clipcount, fmt->fmt.win.bitmap); 1791 mutex_unlock(&zr->resource_lock); 1792 return res; 1793 } 1794 1795 static int zoran_s_fmt_vid_out(struct file *file, void *__fh, 1796 struct v4l2_format *fmt) 1797 { 1798 struct zoran_fh *fh = __fh; 1799 struct zoran *zr = fh->zr; 1800 __le32 printformat = __cpu_to_le32(fmt->fmt.pix.pixelformat); 1801 struct zoran_jpg_settings settings; 1802 int res = 0; 1803 1804 dprintk(3, "size=%dx%d, fmt=0x%x (%4.4s)\n", 1805 fmt->fmt.pix.width, fmt->fmt.pix.height, 1806 fmt->fmt.pix.pixelformat, 1807 (char *) &printformat); 1808 if (fmt->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG) 1809 return -EINVAL; 1810 1811 mutex_lock(&zr->resource_lock); 1812 1813 if (fh->buffers.allocated) { 1814 dprintk(1, KERN_ERR "%s: VIDIOC_S_FMT - cannot change capture mode\n", 1815 ZR_DEVNAME(zr)); 1816 res = -EBUSY; 1817 goto sfmtjpg_unlock_and_return; 1818 } 1819 1820 settings = fh->jpg_settings; 1821 1822 /* we actually need to set 'real' parameters now */ 1823 if (fmt->fmt.pix.height * 2 > BUZ_MAX_HEIGHT) 1824 settings.TmpDcm = 1; 1825 else 1826 settings.TmpDcm = 2; 1827 settings.decimation = 0; 1828 if (fmt->fmt.pix.height <= fh->jpg_settings.img_height / 2) 1829 settings.VerDcm = 2; 1830 else 1831 settings.VerDcm = 1; 1832 if (fmt->fmt.pix.width <= fh->jpg_settings.img_width / 4) 1833 settings.HorDcm = 4; 1834 else if (fmt->fmt.pix.width <= fh->jpg_settings.img_width / 2) 1835 settings.HorDcm = 2; 1836 else 1837 settings.HorDcm = 1; 1838 if (settings.TmpDcm == 1) 1839 settings.field_per_buff = 2; 1840 else 1841 settings.field_per_buff = 1; 1842 1843 if (settings.HorDcm > 1) { 1844 settings.img_x = (BUZ_MAX_WIDTH == 720) ? 8 : 0; 1845 settings.img_width = (BUZ_MAX_WIDTH == 720) ? 704 : BUZ_MAX_WIDTH; 1846 } else { 1847 settings.img_x = 0; 1848 settings.img_width = BUZ_MAX_WIDTH; 1849 } 1850 1851 /* check */ 1852 res = zoran_check_jpg_settings(zr, &settings, 0); 1853 if (res) 1854 goto sfmtjpg_unlock_and_return; 1855 1856 /* it's ok, so set them */ 1857 fh->jpg_settings = settings; 1858 1859 map_mode_jpg(fh, fmt->type == V4L2_BUF_TYPE_VIDEO_OUTPUT); 1860 fh->buffers.buffer_size = zoran_v4l2_calc_bufsize(&fh->jpg_settings); 1861 1862 /* tell the user what we actually did */ 1863 fmt->fmt.pix.width = settings.img_width / settings.HorDcm; 1864 fmt->fmt.pix.height = settings.img_height * 2 / 1865 (settings.TmpDcm * settings.VerDcm); 1866 if (settings.TmpDcm == 1) 1867 fmt->fmt.pix.field = (fh->jpg_settings.odd_even ? 1868 V4L2_FIELD_SEQ_TB : V4L2_FIELD_SEQ_BT); 1869 else 1870 fmt->fmt.pix.field = (fh->jpg_settings.odd_even ? 1871 V4L2_FIELD_TOP : V4L2_FIELD_BOTTOM); 1872 fmt->fmt.pix.bytesperline = 0; 1873 fmt->fmt.pix.sizeimage = fh->buffers.buffer_size; 1874 fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; 1875 1876 sfmtjpg_unlock_and_return: 1877 mutex_unlock(&zr->resource_lock); 1878 return res; 1879 } 1880 1881 static int zoran_s_fmt_vid_cap(struct file *file, void *__fh, 1882 struct v4l2_format *fmt) 1883 { 1884 struct zoran_fh *fh = __fh; 1885 struct zoran *zr = fh->zr; 1886 int i; 1887 int res = 0; 1888 1889 if (fmt->fmt.pix.pixelformat == V4L2_PIX_FMT_MJPEG) 1890 return zoran_s_fmt_vid_out(file, fh, fmt); 1891 1892 for (i = 0; i < NUM_FORMATS; i++) 1893 if (fmt->fmt.pix.pixelformat == zoran_formats[i].fourcc) 1894 break; 1895 if (i == NUM_FORMATS) { 1896 dprintk(1, KERN_ERR "%s: VIDIOC_S_FMT - unknown/unsupported format 0x%x\n", 1897 ZR_DEVNAME(zr), fmt->fmt.pix.pixelformat); 1898 return -EINVAL; 1899 } 1900 1901 mutex_lock(&zr->resource_lock); 1902 1903 if ((fh->map_mode != ZORAN_MAP_MODE_RAW && fh->buffers.allocated) || 1904 fh->buffers.active != ZORAN_FREE) { 1905 dprintk(1, KERN_ERR "%s: VIDIOC_S_FMT - cannot change capture mode\n", 1906 ZR_DEVNAME(zr)); 1907 res = -EBUSY; 1908 goto sfmtv4l_unlock_and_return; 1909 } 1910 if (fmt->fmt.pix.height > BUZ_MAX_HEIGHT) 1911 fmt->fmt.pix.height = BUZ_MAX_HEIGHT; 1912 if (fmt->fmt.pix.width > BUZ_MAX_WIDTH) 1913 fmt->fmt.pix.width = BUZ_MAX_WIDTH; 1914 1915 map_mode_raw(fh); 1916 1917 res = zoran_v4l_set_format(fh, fmt->fmt.pix.width, fmt->fmt.pix.height, 1918 &zoran_formats[i]); 1919 if (res) 1920 goto sfmtv4l_unlock_and_return; 1921 1922 /* tell the user the results/missing stuff */ 1923 fmt->fmt.pix.bytesperline = fh->v4l_settings.bytesperline; 1924 fmt->fmt.pix.sizeimage = fh->v4l_settings.height * fh->v4l_settings.bytesperline; 1925 fmt->fmt.pix.colorspace = fh->v4l_settings.format->colorspace; 1926 if (BUZ_MAX_HEIGHT < (fh->v4l_settings.height * 2)) 1927 fmt->fmt.pix.field = V4L2_FIELD_INTERLACED; 1928 else 1929 fmt->fmt.pix.field = V4L2_FIELD_TOP; 1930 1931 sfmtv4l_unlock_and_return: 1932 mutex_unlock(&zr->resource_lock); 1933 return res; 1934 } 1935 1936 static int zoran_g_fbuf(struct file *file, void *__fh, 1937 struct v4l2_framebuffer *fb) 1938 { 1939 struct zoran_fh *fh = __fh; 1940 struct zoran *zr = fh->zr; 1941 1942 memset(fb, 0, sizeof(*fb)); 1943 mutex_lock(&zr->resource_lock); 1944 fb->base = zr->vbuf_base; 1945 fb->fmt.width = zr->vbuf_width; 1946 fb->fmt.height = zr->vbuf_height; 1947 if (zr->overlay_settings.format) 1948 fb->fmt.pixelformat = fh->overlay_settings.format->fourcc; 1949 fb->fmt.bytesperline = zr->vbuf_bytesperline; 1950 mutex_unlock(&zr->resource_lock); 1951 fb->fmt.colorspace = V4L2_COLORSPACE_SRGB; 1952 fb->fmt.field = V4L2_FIELD_INTERLACED; 1953 fb->capability = V4L2_FBUF_CAP_LIST_CLIPPING; 1954 1955 return 0; 1956 } 1957 1958 static int zoran_s_fbuf(struct file *file, void *__fh, 1959 const struct v4l2_framebuffer *fb) 1960 { 1961 struct zoran_fh *fh = __fh; 1962 struct zoran *zr = fh->zr; 1963 int i, res = 0; 1964 __le32 printformat = __cpu_to_le32(fb->fmt.pixelformat); 1965 1966 for (i = 0; i < NUM_FORMATS; i++) 1967 if (zoran_formats[i].fourcc == fb->fmt.pixelformat) 1968 break; 1969 if (i == NUM_FORMATS) { 1970 dprintk(1, KERN_ERR "%s: VIDIOC_S_FBUF - format=0x%x (%4.4s) not allowed\n", 1971 ZR_DEVNAME(zr), fb->fmt.pixelformat, 1972 (char *)&printformat); 1973 return -EINVAL; 1974 } 1975 1976 mutex_lock(&zr->resource_lock); 1977 res = setup_fbuffer(fh, fb->base, &zoran_formats[i], fb->fmt.width, 1978 fb->fmt.height, fb->fmt.bytesperline); 1979 mutex_unlock(&zr->resource_lock); 1980 1981 return res; 1982 } 1983 1984 static int zoran_overlay(struct file *file, void *__fh, unsigned int on) 1985 { 1986 struct zoran_fh *fh = __fh; 1987 struct zoran *zr = fh->zr; 1988 int res; 1989 1990 mutex_lock(&zr->resource_lock); 1991 res = setup_overlay(fh, on); 1992 mutex_unlock(&zr->resource_lock); 1993 1994 return res; 1995 } 1996 1997 static int zoran_streamoff(struct file *file, void *__fh, enum v4l2_buf_type type); 1998 1999 static int zoran_reqbufs(struct file *file, void *__fh, struct v4l2_requestbuffers *req) 2000 { 2001 struct zoran_fh *fh = __fh; 2002 struct zoran *zr = fh->zr; 2003 int res = 0; 2004 2005 if (req->memory != V4L2_MEMORY_MMAP) { 2006 dprintk(2, 2007 KERN_ERR 2008 "%s: only MEMORY_MMAP capture is supported, not %d\n", 2009 ZR_DEVNAME(zr), req->memory); 2010 return -EINVAL; 2011 } 2012 2013 if (req->count == 0) 2014 return zoran_streamoff(file, fh, req->type); 2015 2016 mutex_lock(&zr->resource_lock); 2017 if (fh->buffers.allocated) { 2018 dprintk(2, 2019 KERN_ERR 2020 "%s: VIDIOC_REQBUFS - buffers already allocated\n", 2021 ZR_DEVNAME(zr)); 2022 res = -EBUSY; 2023 goto v4l2reqbuf_unlock_and_return; 2024 } 2025 2026 if (fh->map_mode == ZORAN_MAP_MODE_RAW && 2027 req->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) { 2028 /* control user input */ 2029 if (req->count < 2) 2030 req->count = 2; 2031 if (req->count > v4l_nbufs) 2032 req->count = v4l_nbufs; 2033 2034 /* The next mmap will map the V4L buffers */ 2035 map_mode_raw(fh); 2036 fh->buffers.num_buffers = req->count; 2037 2038 if (v4l_fbuffer_alloc(fh)) { 2039 res = -ENOMEM; 2040 goto v4l2reqbuf_unlock_and_return; 2041 } 2042 } else if (fh->map_mode == ZORAN_MAP_MODE_JPG_REC || 2043 fh->map_mode == ZORAN_MAP_MODE_JPG_PLAY) { 2044 /* we need to calculate size ourselves now */ 2045 if (req->count < 4) 2046 req->count = 4; 2047 if (req->count > jpg_nbufs) 2048 req->count = jpg_nbufs; 2049 2050 /* The next mmap will map the MJPEG buffers */ 2051 map_mode_jpg(fh, req->type == V4L2_BUF_TYPE_VIDEO_OUTPUT); 2052 fh->buffers.num_buffers = req->count; 2053 fh->buffers.buffer_size = zoran_v4l2_calc_bufsize(&fh->jpg_settings); 2054 2055 if (jpg_fbuffer_alloc(fh)) { 2056 res = -ENOMEM; 2057 goto v4l2reqbuf_unlock_and_return; 2058 } 2059 } else { 2060 dprintk(1, 2061 KERN_ERR 2062 "%s: VIDIOC_REQBUFS - unknown type %d\n", 2063 ZR_DEVNAME(zr), req->type); 2064 res = -EINVAL; 2065 goto v4l2reqbuf_unlock_and_return; 2066 } 2067 v4l2reqbuf_unlock_and_return: 2068 mutex_unlock(&zr->resource_lock); 2069 2070 return res; 2071 } 2072 2073 static int zoran_querybuf(struct file *file, void *__fh, struct v4l2_buffer *buf) 2074 { 2075 struct zoran_fh *fh = __fh; 2076 struct zoran *zr = fh->zr; 2077 int res; 2078 2079 mutex_lock(&zr->resource_lock); 2080 res = zoran_v4l2_buffer_status(fh, buf, buf->index); 2081 mutex_unlock(&zr->resource_lock); 2082 2083 return res; 2084 } 2085 2086 static int zoran_qbuf(struct file *file, void *__fh, struct v4l2_buffer *buf) 2087 { 2088 struct zoran_fh *fh = __fh; 2089 struct zoran *zr = fh->zr; 2090 int res = 0, codec_mode, buf_type; 2091 2092 mutex_lock(&zr->resource_lock); 2093 2094 switch (fh->map_mode) { 2095 case ZORAN_MAP_MODE_RAW: 2096 if (buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) { 2097 dprintk(1, KERN_ERR 2098 "%s: VIDIOC_QBUF - invalid buf->type=%d for map_mode=%d\n", 2099 ZR_DEVNAME(zr), buf->type, fh->map_mode); 2100 res = -EINVAL; 2101 goto qbuf_unlock_and_return; 2102 } 2103 2104 res = zoran_v4l_queue_frame(fh, buf->index); 2105 if (res) 2106 goto qbuf_unlock_and_return; 2107 if (!zr->v4l_memgrab_active && fh->buffers.active == ZORAN_LOCKED) 2108 zr36057_set_memgrab(zr, 1); 2109 break; 2110 2111 case ZORAN_MAP_MODE_JPG_REC: 2112 case ZORAN_MAP_MODE_JPG_PLAY: 2113 if (fh->map_mode == ZORAN_MAP_MODE_JPG_PLAY) { 2114 buf_type = V4L2_BUF_TYPE_VIDEO_OUTPUT; 2115 codec_mode = BUZ_MODE_MOTION_DECOMPRESS; 2116 } else { 2117 buf_type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 2118 codec_mode = BUZ_MODE_MOTION_COMPRESS; 2119 } 2120 2121 if (buf->type != buf_type) { 2122 dprintk(1, KERN_ERR 2123 "%s: VIDIOC_QBUF - invalid buf->type=%d for map_mode=%d\n", 2124 ZR_DEVNAME(zr), buf->type, fh->map_mode); 2125 res = -EINVAL; 2126 goto qbuf_unlock_and_return; 2127 } 2128 2129 res = zoran_jpg_queue_frame(fh, buf->index, codec_mode); 2130 if (res != 0) 2131 goto qbuf_unlock_and_return; 2132 if (zr->codec_mode == BUZ_MODE_IDLE && 2133 fh->buffers.active == ZORAN_LOCKED) 2134 zr36057_enable_jpg(zr, codec_mode); 2135 2136 break; 2137 2138 default: 2139 dprintk(1, KERN_ERR 2140 "%s: VIDIOC_QBUF - unsupported type %d\n", 2141 ZR_DEVNAME(zr), buf->type); 2142 res = -EINVAL; 2143 break; 2144 } 2145 qbuf_unlock_and_return: 2146 mutex_unlock(&zr->resource_lock); 2147 2148 return res; 2149 } 2150 2151 static int zoran_dqbuf(struct file *file, void *__fh, struct v4l2_buffer *buf) 2152 { 2153 struct zoran_fh *fh = __fh; 2154 struct zoran *zr = fh->zr; 2155 int res = 0, buf_type, num = -1; /* compiler borks here (?) */ 2156 2157 mutex_lock(&zr->resource_lock); 2158 2159 switch (fh->map_mode) { 2160 case ZORAN_MAP_MODE_RAW: 2161 if (buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) { 2162 dprintk(1, KERN_ERR 2163 "%s: VIDIOC_QBUF - invalid buf->type=%d for map_mode=%d\n", 2164 ZR_DEVNAME(zr), buf->type, fh->map_mode); 2165 res = -EINVAL; 2166 goto dqbuf_unlock_and_return; 2167 } 2168 2169 num = zr->v4l_pend[zr->v4l_sync_tail & V4L_MASK_FRAME]; 2170 if (file->f_flags & O_NONBLOCK && 2171 zr->v4l_buffers.buffer[num].state != BUZ_STATE_DONE) { 2172 res = -EAGAIN; 2173 goto dqbuf_unlock_and_return; 2174 } 2175 res = v4l_sync(fh, num); 2176 if (res) 2177 goto dqbuf_unlock_and_return; 2178 zr->v4l_sync_tail++; 2179 res = zoran_v4l2_buffer_status(fh, buf, num); 2180 break; 2181 2182 case ZORAN_MAP_MODE_JPG_REC: 2183 case ZORAN_MAP_MODE_JPG_PLAY: 2184 { 2185 struct zoran_sync bs; 2186 2187 if (fh->map_mode == ZORAN_MAP_MODE_JPG_PLAY) 2188 buf_type = V4L2_BUF_TYPE_VIDEO_OUTPUT; 2189 else 2190 buf_type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 2191 2192 if (buf->type != buf_type) { 2193 dprintk(1, KERN_ERR 2194 "%s: VIDIOC_QBUF - invalid buf->type=%d for map_mode=%d\n", 2195 ZR_DEVNAME(zr), buf->type, fh->map_mode); 2196 res = -EINVAL; 2197 goto dqbuf_unlock_and_return; 2198 } 2199 2200 num = zr->jpg_pend[zr->jpg_que_tail & BUZ_MASK_FRAME]; 2201 2202 if (file->f_flags & O_NONBLOCK && 2203 zr->jpg_buffers.buffer[num].state != BUZ_STATE_DONE) { 2204 res = -EAGAIN; 2205 goto dqbuf_unlock_and_return; 2206 } 2207 bs.frame = 0; /* suppress compiler warning */ 2208 res = jpg_sync(fh, &bs); 2209 if (res) 2210 goto dqbuf_unlock_and_return; 2211 res = zoran_v4l2_buffer_status(fh, buf, bs.frame); 2212 break; 2213 } 2214 2215 default: 2216 dprintk(1, KERN_ERR 2217 "%s: VIDIOC_DQBUF - unsupported type %d\n", 2218 ZR_DEVNAME(zr), buf->type); 2219 res = -EINVAL; 2220 break; 2221 } 2222 dqbuf_unlock_and_return: 2223 mutex_unlock(&zr->resource_lock); 2224 2225 return res; 2226 } 2227 2228 static int zoran_streamon(struct file *file, void *__fh, enum v4l2_buf_type type) 2229 { 2230 struct zoran_fh *fh = __fh; 2231 struct zoran *zr = fh->zr; 2232 int res = 0; 2233 2234 mutex_lock(&zr->resource_lock); 2235 2236 switch (fh->map_mode) { 2237 case ZORAN_MAP_MODE_RAW: /* raw capture */ 2238 if (zr->v4l_buffers.active != ZORAN_ACTIVE || 2239 fh->buffers.active != ZORAN_ACTIVE) { 2240 res = -EBUSY; 2241 goto strmon_unlock_and_return; 2242 } 2243 2244 zr->v4l_buffers.active = fh->buffers.active = ZORAN_LOCKED; 2245 zr->v4l_settings = fh->v4l_settings; 2246 2247 zr->v4l_sync_tail = zr->v4l_pend_tail; 2248 if (!zr->v4l_memgrab_active && 2249 zr->v4l_pend_head != zr->v4l_pend_tail) { 2250 zr36057_set_memgrab(zr, 1); 2251 } 2252 break; 2253 2254 case ZORAN_MAP_MODE_JPG_REC: 2255 case ZORAN_MAP_MODE_JPG_PLAY: 2256 /* what is the codec mode right now? */ 2257 if (zr->jpg_buffers.active != ZORAN_ACTIVE || 2258 fh->buffers.active != ZORAN_ACTIVE) { 2259 res = -EBUSY; 2260 goto strmon_unlock_and_return; 2261 } 2262 2263 zr->jpg_buffers.active = fh->buffers.active = ZORAN_LOCKED; 2264 2265 if (zr->jpg_que_head != zr->jpg_que_tail) { 2266 /* Start the jpeg codec when the first frame is queued */ 2267 jpeg_start(zr); 2268 } 2269 break; 2270 2271 default: 2272 dprintk(1, 2273 KERN_ERR 2274 "%s: VIDIOC_STREAMON - invalid map mode %d\n", 2275 ZR_DEVNAME(zr), fh->map_mode); 2276 res = -EINVAL; 2277 break; 2278 } 2279 strmon_unlock_and_return: 2280 mutex_unlock(&zr->resource_lock); 2281 2282 return res; 2283 } 2284 2285 static int zoran_streamoff(struct file *file, void *__fh, enum v4l2_buf_type type) 2286 { 2287 struct zoran_fh *fh = __fh; 2288 struct zoran *zr = fh->zr; 2289 int i, res = 0; 2290 unsigned long flags; 2291 2292 mutex_lock(&zr->resource_lock); 2293 2294 switch (fh->map_mode) { 2295 case ZORAN_MAP_MODE_RAW: /* raw capture */ 2296 if (fh->buffers.active == ZORAN_FREE && 2297 zr->v4l_buffers.active != ZORAN_FREE) { 2298 res = -EPERM; /* stay off other's settings! */ 2299 goto strmoff_unlock_and_return; 2300 } 2301 if (zr->v4l_buffers.active == ZORAN_FREE) 2302 goto strmoff_unlock_and_return; 2303 2304 spin_lock_irqsave(&zr->spinlock, flags); 2305 /* unload capture */ 2306 if (zr->v4l_memgrab_active) { 2307 2308 zr36057_set_memgrab(zr, 0); 2309 } 2310 2311 for (i = 0; i < fh->buffers.num_buffers; i++) 2312 zr->v4l_buffers.buffer[i].state = BUZ_STATE_USER; 2313 fh->buffers = zr->v4l_buffers; 2314 2315 zr->v4l_buffers.active = fh->buffers.active = ZORAN_FREE; 2316 2317 zr->v4l_grab_seq = 0; 2318 zr->v4l_pend_head = zr->v4l_pend_tail = 0; 2319 zr->v4l_sync_tail = 0; 2320 2321 spin_unlock_irqrestore(&zr->spinlock, flags); 2322 2323 break; 2324 2325 case ZORAN_MAP_MODE_JPG_REC: 2326 case ZORAN_MAP_MODE_JPG_PLAY: 2327 if (fh->buffers.active == ZORAN_FREE && 2328 zr->jpg_buffers.active != ZORAN_FREE) { 2329 res = -EPERM; /* stay off other's settings! */ 2330 goto strmoff_unlock_and_return; 2331 } 2332 if (zr->jpg_buffers.active == ZORAN_FREE) 2333 goto strmoff_unlock_and_return; 2334 2335 res = jpg_qbuf(fh, -1, 2336 (fh->map_mode == ZORAN_MAP_MODE_JPG_REC) ? 2337 BUZ_MODE_MOTION_COMPRESS : 2338 BUZ_MODE_MOTION_DECOMPRESS); 2339 if (res) 2340 goto strmoff_unlock_and_return; 2341 break; 2342 default: 2343 dprintk(1, KERN_ERR 2344 "%s: VIDIOC_STREAMOFF - invalid map mode %d\n", 2345 ZR_DEVNAME(zr), fh->map_mode); 2346 res = -EINVAL; 2347 break; 2348 } 2349 strmoff_unlock_and_return: 2350 mutex_unlock(&zr->resource_lock); 2351 2352 return res; 2353 } 2354 2355 static int zoran_queryctrl(struct file *file, void *__fh, 2356 struct v4l2_queryctrl *ctrl) 2357 { 2358 struct zoran_fh *fh = __fh; 2359 struct zoran *zr = fh->zr; 2360 2361 /* we only support hue/saturation/contrast/brightness */ 2362 if (ctrl->id < V4L2_CID_BRIGHTNESS || 2363 ctrl->id > V4L2_CID_HUE) 2364 return -EINVAL; 2365 2366 decoder_call(zr, core, queryctrl, ctrl); 2367 2368 return 0; 2369 } 2370 2371 static int zoran_g_ctrl(struct file *file, void *__fh, struct v4l2_control *ctrl) 2372 { 2373 struct zoran_fh *fh = __fh; 2374 struct zoran *zr = fh->zr; 2375 2376 /* we only support hue/saturation/contrast/brightness */ 2377 if (ctrl->id < V4L2_CID_BRIGHTNESS || 2378 ctrl->id > V4L2_CID_HUE) 2379 return -EINVAL; 2380 2381 mutex_lock(&zr->resource_lock); 2382 decoder_call(zr, core, g_ctrl, ctrl); 2383 mutex_unlock(&zr->resource_lock); 2384 2385 return 0; 2386 } 2387 2388 static int zoran_s_ctrl(struct file *file, void *__fh, struct v4l2_control *ctrl) 2389 { 2390 struct zoran_fh *fh = __fh; 2391 struct zoran *zr = fh->zr; 2392 2393 /* we only support hue/saturation/contrast/brightness */ 2394 if (ctrl->id < V4L2_CID_BRIGHTNESS || 2395 ctrl->id > V4L2_CID_HUE) 2396 return -EINVAL; 2397 2398 mutex_lock(&zr->resource_lock); 2399 decoder_call(zr, core, s_ctrl, ctrl); 2400 mutex_unlock(&zr->resource_lock); 2401 2402 return 0; 2403 } 2404 2405 static int zoran_g_std(struct file *file, void *__fh, v4l2_std_id *std) 2406 { 2407 struct zoran_fh *fh = __fh; 2408 struct zoran *zr = fh->zr; 2409 2410 mutex_lock(&zr->resource_lock); 2411 *std = zr->norm; 2412 mutex_unlock(&zr->resource_lock); 2413 return 0; 2414 } 2415 2416 static int zoran_s_std(struct file *file, void *__fh, v4l2_std_id std) 2417 { 2418 struct zoran_fh *fh = __fh; 2419 struct zoran *zr = fh->zr; 2420 int res = 0; 2421 2422 mutex_lock(&zr->resource_lock); 2423 res = zoran_set_norm(zr, std); 2424 if (res) 2425 goto sstd_unlock_and_return; 2426 2427 res = wait_grab_pending(zr); 2428 sstd_unlock_and_return: 2429 mutex_unlock(&zr->resource_lock); 2430 return res; 2431 } 2432 2433 static int zoran_enum_input(struct file *file, void *__fh, 2434 struct v4l2_input *inp) 2435 { 2436 struct zoran_fh *fh = __fh; 2437 struct zoran *zr = fh->zr; 2438 2439 if (inp->index >= zr->card.inputs) 2440 return -EINVAL; 2441 2442 strncpy(inp->name, zr->card.input[inp->index].name, 2443 sizeof(inp->name) - 1); 2444 inp->type = V4L2_INPUT_TYPE_CAMERA; 2445 inp->std = V4L2_STD_ALL; 2446 2447 /* Get status of video decoder */ 2448 mutex_lock(&zr->resource_lock); 2449 decoder_call(zr, video, g_input_status, &inp->status); 2450 mutex_unlock(&zr->resource_lock); 2451 return 0; 2452 } 2453 2454 static int zoran_g_input(struct file *file, void *__fh, unsigned int *input) 2455 { 2456 struct zoran_fh *fh = __fh; 2457 struct zoran *zr = fh->zr; 2458 2459 mutex_lock(&zr->resource_lock); 2460 *input = zr->input; 2461 mutex_unlock(&zr->resource_lock); 2462 2463 return 0; 2464 } 2465 2466 static int zoran_s_input(struct file *file, void *__fh, unsigned int input) 2467 { 2468 struct zoran_fh *fh = __fh; 2469 struct zoran *zr = fh->zr; 2470 int res; 2471 2472 mutex_lock(&zr->resource_lock); 2473 res = zoran_set_input(zr, input); 2474 if (res) 2475 goto sinput_unlock_and_return; 2476 2477 /* Make sure the changes come into effect */ 2478 res = wait_grab_pending(zr); 2479 sinput_unlock_and_return: 2480 mutex_unlock(&zr->resource_lock); 2481 return res; 2482 } 2483 2484 static int zoran_enum_output(struct file *file, void *__fh, 2485 struct v4l2_output *outp) 2486 { 2487 if (outp->index != 0) 2488 return -EINVAL; 2489 2490 outp->index = 0; 2491 outp->type = V4L2_OUTPUT_TYPE_ANALOGVGAOVERLAY; 2492 strncpy(outp->name, "Autodetect", sizeof(outp->name)-1); 2493 2494 return 0; 2495 } 2496 2497 static int zoran_g_output(struct file *file, void *__fh, unsigned int *output) 2498 { 2499 *output = 0; 2500 2501 return 0; 2502 } 2503 2504 static int zoran_s_output(struct file *file, void *__fh, unsigned int output) 2505 { 2506 if (output != 0) 2507 return -EINVAL; 2508 2509 return 0; 2510 } 2511 2512 /* cropping (sub-frame capture) */ 2513 static int zoran_cropcap(struct file *file, void *__fh, 2514 struct v4l2_cropcap *cropcap) 2515 { 2516 struct zoran_fh *fh = __fh; 2517 struct zoran *zr = fh->zr; 2518 int type = cropcap->type, res = 0; 2519 2520 memset(cropcap, 0, sizeof(*cropcap)); 2521 cropcap->type = type; 2522 2523 mutex_lock(&zr->resource_lock); 2524 2525 if (cropcap->type != V4L2_BUF_TYPE_VIDEO_OUTPUT && 2526 (cropcap->type != V4L2_BUF_TYPE_VIDEO_CAPTURE || 2527 fh->map_mode == ZORAN_MAP_MODE_RAW)) { 2528 dprintk(1, KERN_ERR 2529 "%s: VIDIOC_CROPCAP - subcapture only supported for compressed capture\n", 2530 ZR_DEVNAME(zr)); 2531 res = -EINVAL; 2532 goto cropcap_unlock_and_return; 2533 } 2534 2535 cropcap->bounds.top = cropcap->bounds.left = 0; 2536 cropcap->bounds.width = BUZ_MAX_WIDTH; 2537 cropcap->bounds.height = BUZ_MAX_HEIGHT; 2538 cropcap->defrect.top = cropcap->defrect.left = 0; 2539 cropcap->defrect.width = BUZ_MIN_WIDTH; 2540 cropcap->defrect.height = BUZ_MIN_HEIGHT; 2541 cropcap_unlock_and_return: 2542 mutex_unlock(&zr->resource_lock); 2543 return res; 2544 } 2545 2546 static int zoran_g_crop(struct file *file, void *__fh, struct v4l2_crop *crop) 2547 { 2548 struct zoran_fh *fh = __fh; 2549 struct zoran *zr = fh->zr; 2550 int type = crop->type, res = 0; 2551 2552 memset(crop, 0, sizeof(*crop)); 2553 crop->type = type; 2554 2555 mutex_lock(&zr->resource_lock); 2556 2557 if (crop->type != V4L2_BUF_TYPE_VIDEO_OUTPUT && 2558 (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE || 2559 fh->map_mode == ZORAN_MAP_MODE_RAW)) { 2560 dprintk(1, 2561 KERN_ERR 2562 "%s: VIDIOC_G_CROP - subcapture only supported for compressed capture\n", 2563 ZR_DEVNAME(zr)); 2564 res = -EINVAL; 2565 goto gcrop_unlock_and_return; 2566 } 2567 2568 crop->c.top = fh->jpg_settings.img_y; 2569 crop->c.left = fh->jpg_settings.img_x; 2570 crop->c.width = fh->jpg_settings.img_width; 2571 crop->c.height = fh->jpg_settings.img_height; 2572 2573 gcrop_unlock_and_return: 2574 mutex_unlock(&zr->resource_lock); 2575 2576 return res; 2577 } 2578 2579 static int zoran_s_crop(struct file *file, void *__fh, const struct v4l2_crop *crop) 2580 { 2581 struct zoran_fh *fh = __fh; 2582 struct zoran *zr = fh->zr; 2583 int res = 0; 2584 struct zoran_jpg_settings settings; 2585 2586 settings = fh->jpg_settings; 2587 2588 mutex_lock(&zr->resource_lock); 2589 2590 if (fh->buffers.allocated) { 2591 dprintk(1, KERN_ERR 2592 "%s: VIDIOC_S_CROP - cannot change settings while active\n", 2593 ZR_DEVNAME(zr)); 2594 res = -EBUSY; 2595 goto scrop_unlock_and_return; 2596 } 2597 2598 if (crop->type != V4L2_BUF_TYPE_VIDEO_OUTPUT && 2599 (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE || 2600 fh->map_mode == ZORAN_MAP_MODE_RAW)) { 2601 dprintk(1, KERN_ERR 2602 "%s: VIDIOC_G_CROP - subcapture only supported for compressed capture\n", 2603 ZR_DEVNAME(zr)); 2604 res = -EINVAL; 2605 goto scrop_unlock_and_return; 2606 } 2607 2608 /* move into a form that we understand */ 2609 settings.img_x = crop->c.left; 2610 settings.img_y = crop->c.top; 2611 settings.img_width = crop->c.width; 2612 settings.img_height = crop->c.height; 2613 2614 /* check validity */ 2615 res = zoran_check_jpg_settings(zr, &settings, 0); 2616 if (res) 2617 goto scrop_unlock_and_return; 2618 2619 /* accept */ 2620 fh->jpg_settings = settings; 2621 2622 scrop_unlock_and_return: 2623 mutex_unlock(&zr->resource_lock); 2624 return res; 2625 } 2626 2627 static int zoran_g_jpegcomp(struct file *file, void *__fh, 2628 struct v4l2_jpegcompression *params) 2629 { 2630 struct zoran_fh *fh = __fh; 2631 struct zoran *zr = fh->zr; 2632 memset(params, 0, sizeof(*params)); 2633 2634 mutex_lock(&zr->resource_lock); 2635 2636 params->quality = fh->jpg_settings.jpg_comp.quality; 2637 params->APPn = fh->jpg_settings.jpg_comp.APPn; 2638 memcpy(params->APP_data, 2639 fh->jpg_settings.jpg_comp.APP_data, 2640 fh->jpg_settings.jpg_comp.APP_len); 2641 params->APP_len = fh->jpg_settings.jpg_comp.APP_len; 2642 memcpy(params->COM_data, 2643 fh->jpg_settings.jpg_comp.COM_data, 2644 fh->jpg_settings.jpg_comp.COM_len); 2645 params->COM_len = fh->jpg_settings.jpg_comp.COM_len; 2646 params->jpeg_markers = 2647 fh->jpg_settings.jpg_comp.jpeg_markers; 2648 2649 mutex_unlock(&zr->resource_lock); 2650 2651 return 0; 2652 } 2653 2654 static int zoran_s_jpegcomp(struct file *file, void *__fh, 2655 const struct v4l2_jpegcompression *params) 2656 { 2657 struct zoran_fh *fh = __fh; 2658 struct zoran *zr = fh->zr; 2659 int res = 0; 2660 struct zoran_jpg_settings settings; 2661 2662 settings = fh->jpg_settings; 2663 2664 settings.jpg_comp = *params; 2665 2666 mutex_lock(&zr->resource_lock); 2667 2668 if (fh->buffers.active != ZORAN_FREE) { 2669 dprintk(1, KERN_WARNING 2670 "%s: VIDIOC_S_JPEGCOMP called while in playback/capture mode\n", 2671 ZR_DEVNAME(zr)); 2672 res = -EBUSY; 2673 goto sjpegc_unlock_and_return; 2674 } 2675 2676 res = zoran_check_jpg_settings(zr, &settings, 0); 2677 if (res) 2678 goto sjpegc_unlock_and_return; 2679 if (!fh->buffers.allocated) 2680 fh->buffers.buffer_size = 2681 zoran_v4l2_calc_bufsize(&fh->jpg_settings); 2682 fh->jpg_settings.jpg_comp = settings.jpg_comp; 2683 sjpegc_unlock_and_return: 2684 mutex_unlock(&zr->resource_lock); 2685 2686 return res; 2687 } 2688 2689 static unsigned int 2690 zoran_poll (struct file *file, 2691 poll_table *wait) 2692 { 2693 struct zoran_fh *fh = file->private_data; 2694 struct zoran *zr = fh->zr; 2695 int res = 0, frame; 2696 unsigned long flags; 2697 2698 /* we should check whether buffers are ready to be synced on 2699 * (w/o waits - O_NONBLOCK) here 2700 * if ready for read (sync), return POLLIN|POLLRDNORM, 2701 * if ready for write (sync), return POLLOUT|POLLWRNORM, 2702 * if error, return POLLERR, 2703 * if no buffers queued or so, return POLLNVAL 2704 */ 2705 2706 mutex_lock(&zr->resource_lock); 2707 2708 switch (fh->map_mode) { 2709 case ZORAN_MAP_MODE_RAW: 2710 poll_wait(file, &zr->v4l_capq, wait); 2711 frame = zr->v4l_pend[zr->v4l_sync_tail & V4L_MASK_FRAME]; 2712 2713 spin_lock_irqsave(&zr->spinlock, flags); 2714 dprintk(3, 2715 KERN_DEBUG 2716 "%s: %s() raw - active=%c, sync_tail=%lu/%c, pend_tail=%lu, pend_head=%lu\n", 2717 ZR_DEVNAME(zr), __func__, 2718 "FAL"[fh->buffers.active], zr->v4l_sync_tail, 2719 "UPMD"[zr->v4l_buffers.buffer[frame].state], 2720 zr->v4l_pend_tail, zr->v4l_pend_head); 2721 /* Process is the one capturing? */ 2722 if (fh->buffers.active != ZORAN_FREE && 2723 /* Buffer ready to DQBUF? */ 2724 zr->v4l_buffers.buffer[frame].state == BUZ_STATE_DONE) 2725 res = POLLIN | POLLRDNORM; 2726 spin_unlock_irqrestore(&zr->spinlock, flags); 2727 2728 break; 2729 2730 case ZORAN_MAP_MODE_JPG_REC: 2731 case ZORAN_MAP_MODE_JPG_PLAY: 2732 poll_wait(file, &zr->jpg_capq, wait); 2733 frame = zr->jpg_pend[zr->jpg_que_tail & BUZ_MASK_FRAME]; 2734 2735 spin_lock_irqsave(&zr->spinlock, flags); 2736 dprintk(3, 2737 KERN_DEBUG 2738 "%s: %s() jpg - active=%c, que_tail=%lu/%c, que_head=%lu, dma=%lu/%lu\n", 2739 ZR_DEVNAME(zr), __func__, 2740 "FAL"[fh->buffers.active], zr->jpg_que_tail, 2741 "UPMD"[zr->jpg_buffers.buffer[frame].state], 2742 zr->jpg_que_head, zr->jpg_dma_tail, zr->jpg_dma_head); 2743 if (fh->buffers.active != ZORAN_FREE && 2744 zr->jpg_buffers.buffer[frame].state == BUZ_STATE_DONE) { 2745 if (fh->map_mode == ZORAN_MAP_MODE_JPG_REC) 2746 res = POLLIN | POLLRDNORM; 2747 else 2748 res = POLLOUT | POLLWRNORM; 2749 } 2750 spin_unlock_irqrestore(&zr->spinlock, flags); 2751 2752 break; 2753 2754 default: 2755 dprintk(1, 2756 KERN_ERR 2757 "%s: %s - internal error, unknown map_mode=%d\n", 2758 ZR_DEVNAME(zr), __func__, fh->map_mode); 2759 res = POLLNVAL; 2760 } 2761 2762 mutex_unlock(&zr->resource_lock); 2763 2764 return res; 2765 } 2766 2767 2768 /* 2769 * This maps the buffers to user space. 2770 * 2771 * Depending on the state of fh->map_mode 2772 * the V4L or the MJPEG buffers are mapped 2773 * per buffer or all together 2774 * 2775 * Note that we need to connect to some 2776 * unmap signal event to unmap the de-allocate 2777 * the buffer accordingly (zoran_vm_close()) 2778 */ 2779 2780 static void 2781 zoran_vm_open (struct vm_area_struct *vma) 2782 { 2783 struct zoran_mapping *map = vma->vm_private_data; 2784 atomic_inc(&map->count); 2785 } 2786 2787 static void 2788 zoran_vm_close (struct vm_area_struct *vma) 2789 { 2790 struct zoran_mapping *map = vma->vm_private_data; 2791 struct zoran_fh *fh = map->fh; 2792 struct zoran *zr = fh->zr; 2793 int i; 2794 2795 if (!atomic_dec_and_mutex_lock(&map->count, &zr->resource_lock)) 2796 return; 2797 2798 dprintk(3, KERN_INFO "%s: %s - munmap(%s)\n", ZR_DEVNAME(zr), 2799 __func__, mode_name(fh->map_mode)); 2800 2801 for (i = 0; i < fh->buffers.num_buffers; i++) { 2802 if (fh->buffers.buffer[i].map == map) 2803 fh->buffers.buffer[i].map = NULL; 2804 } 2805 kfree(map); 2806 2807 /* Any buffers still mapped? */ 2808 for (i = 0; i < fh->buffers.num_buffers; i++) { 2809 if (fh->buffers.buffer[i].map) { 2810 mutex_unlock(&zr->resource_lock); 2811 return; 2812 } 2813 } 2814 2815 dprintk(3, KERN_INFO "%s: %s - free %s buffers\n", ZR_DEVNAME(zr), 2816 __func__, mode_name(fh->map_mode)); 2817 2818 2819 if (fh->map_mode == ZORAN_MAP_MODE_RAW) { 2820 if (fh->buffers.active != ZORAN_FREE) { 2821 unsigned long flags; 2822 2823 spin_lock_irqsave(&zr->spinlock, flags); 2824 zr36057_set_memgrab(zr, 0); 2825 zr->v4l_buffers.allocated = 0; 2826 zr->v4l_buffers.active = fh->buffers.active = ZORAN_FREE; 2827 spin_unlock_irqrestore(&zr->spinlock, flags); 2828 } 2829 v4l_fbuffer_free(fh); 2830 } else { 2831 if (fh->buffers.active != ZORAN_FREE) { 2832 jpg_qbuf(fh, -1, zr->codec_mode); 2833 zr->jpg_buffers.allocated = 0; 2834 zr->jpg_buffers.active = fh->buffers.active = ZORAN_FREE; 2835 } 2836 jpg_fbuffer_free(fh); 2837 } 2838 2839 mutex_unlock(&zr->resource_lock); 2840 } 2841 2842 static const struct vm_operations_struct zoran_vm_ops = { 2843 .open = zoran_vm_open, 2844 .close = zoran_vm_close, 2845 }; 2846 2847 static int 2848 zoran_mmap (struct file *file, 2849 struct vm_area_struct *vma) 2850 { 2851 struct zoran_fh *fh = file->private_data; 2852 struct zoran *zr = fh->zr; 2853 unsigned long size = (vma->vm_end - vma->vm_start); 2854 unsigned long offset = vma->vm_pgoff << PAGE_SHIFT; 2855 int i, j; 2856 unsigned long page, start = vma->vm_start, todo, pos, fraglen; 2857 int first, last; 2858 struct zoran_mapping *map; 2859 int res = 0; 2860 2861 dprintk(3, 2862 KERN_INFO "%s: %s(%s) of 0x%08lx-0x%08lx (size=%lu)\n", 2863 ZR_DEVNAME(zr), __func__, 2864 mode_name(fh->map_mode), vma->vm_start, vma->vm_end, size); 2865 2866 if (!(vma->vm_flags & VM_SHARED) || !(vma->vm_flags & VM_READ) || 2867 !(vma->vm_flags & VM_WRITE)) { 2868 dprintk(1, 2869 KERN_ERR 2870 "%s: %s - no MAP_SHARED/PROT_{READ,WRITE} given\n", 2871 ZR_DEVNAME(zr), __func__); 2872 return -EINVAL; 2873 } 2874 2875 mutex_lock(&zr->resource_lock); 2876 2877 if (!fh->buffers.allocated) { 2878 dprintk(1, 2879 KERN_ERR 2880 "%s: %s(%s) - buffers not yet allocated\n", 2881 ZR_DEVNAME(zr), __func__, mode_name(fh->map_mode)); 2882 res = -ENOMEM; 2883 goto mmap_unlock_and_return; 2884 } 2885 2886 first = offset / fh->buffers.buffer_size; 2887 last = first - 1 + size / fh->buffers.buffer_size; 2888 if (offset % fh->buffers.buffer_size != 0 || 2889 size % fh->buffers.buffer_size != 0 || first < 0 || 2890 last < 0 || first >= fh->buffers.num_buffers || 2891 last >= fh->buffers.buffer_size) { 2892 dprintk(1, 2893 KERN_ERR 2894 "%s: %s(%s) - offset=%lu or size=%lu invalid for bufsize=%d and numbufs=%d\n", 2895 ZR_DEVNAME(zr), __func__, mode_name(fh->map_mode), offset, size, 2896 fh->buffers.buffer_size, 2897 fh->buffers.num_buffers); 2898 res = -EINVAL; 2899 goto mmap_unlock_and_return; 2900 } 2901 2902 /* Check if any buffers are already mapped */ 2903 for (i = first; i <= last; i++) { 2904 if (fh->buffers.buffer[i].map) { 2905 dprintk(1, 2906 KERN_ERR 2907 "%s: %s(%s) - buffer %d already mapped\n", 2908 ZR_DEVNAME(zr), __func__, mode_name(fh->map_mode), i); 2909 res = -EBUSY; 2910 goto mmap_unlock_and_return; 2911 } 2912 } 2913 2914 /* map these buffers */ 2915 map = kmalloc(sizeof(struct zoran_mapping), GFP_KERNEL); 2916 if (!map) { 2917 res = -ENOMEM; 2918 goto mmap_unlock_and_return; 2919 } 2920 map->fh = fh; 2921 atomic_set(&map->count, 1); 2922 2923 vma->vm_ops = &zoran_vm_ops; 2924 vma->vm_flags |= VM_DONTEXPAND; 2925 vma->vm_private_data = map; 2926 2927 if (fh->map_mode == ZORAN_MAP_MODE_RAW) { 2928 for (i = first; i <= last; i++) { 2929 todo = size; 2930 if (todo > fh->buffers.buffer_size) 2931 todo = fh->buffers.buffer_size; 2932 page = fh->buffers.buffer[i].v4l.fbuffer_phys; 2933 if (remap_pfn_range(vma, start, page >> PAGE_SHIFT, 2934 todo, PAGE_SHARED)) { 2935 dprintk(1, 2936 KERN_ERR 2937 "%s: %s(V4L) - remap_pfn_range failed\n", 2938 ZR_DEVNAME(zr), __func__); 2939 res = -EAGAIN; 2940 goto mmap_unlock_and_return; 2941 } 2942 size -= todo; 2943 start += todo; 2944 fh->buffers.buffer[i].map = map; 2945 if (size == 0) 2946 break; 2947 } 2948 } else { 2949 for (i = first; i <= last; i++) { 2950 for (j = 0; 2951 j < fh->buffers.buffer_size / PAGE_SIZE; 2952 j++) { 2953 fraglen = 2954 (le32_to_cpu(fh->buffers.buffer[i].jpg. 2955 frag_tab[2 * j + 1]) & ~1) << 1; 2956 todo = size; 2957 if (todo > fraglen) 2958 todo = fraglen; 2959 pos = 2960 le32_to_cpu(fh->buffers. 2961 buffer[i].jpg.frag_tab[2 * j]); 2962 /* should just be pos on i386 */ 2963 page = virt_to_phys(bus_to_virt(pos)) 2964 >> PAGE_SHIFT; 2965 if (remap_pfn_range(vma, start, page, 2966 todo, PAGE_SHARED)) { 2967 dprintk(1, 2968 KERN_ERR 2969 "%s: %s(V4L) - remap_pfn_range failed\n", 2970 ZR_DEVNAME(zr), __func__); 2971 res = -EAGAIN; 2972 goto mmap_unlock_and_return; 2973 } 2974 size -= todo; 2975 start += todo; 2976 if (size == 0) 2977 break; 2978 if (le32_to_cpu(fh->buffers.buffer[i].jpg. 2979 frag_tab[2 * j + 1]) & 1) 2980 break; /* was last fragment */ 2981 } 2982 fh->buffers.buffer[i].map = map; 2983 if (size == 0) 2984 break; 2985 2986 } 2987 } 2988 2989 mmap_unlock_and_return: 2990 mutex_unlock(&zr->resource_lock); 2991 2992 return res; 2993 } 2994 2995 static const struct v4l2_ioctl_ops zoran_ioctl_ops = { 2996 .vidioc_querycap = zoran_querycap, 2997 .vidioc_cropcap = zoran_cropcap, 2998 .vidioc_s_crop = zoran_s_crop, 2999 .vidioc_g_crop = zoran_g_crop, 3000 .vidioc_enum_input = zoran_enum_input, 3001 .vidioc_g_input = zoran_g_input, 3002 .vidioc_s_input = zoran_s_input, 3003 .vidioc_enum_output = zoran_enum_output, 3004 .vidioc_g_output = zoran_g_output, 3005 .vidioc_s_output = zoran_s_output, 3006 .vidioc_g_fbuf = zoran_g_fbuf, 3007 .vidioc_s_fbuf = zoran_s_fbuf, 3008 .vidioc_g_std = zoran_g_std, 3009 .vidioc_s_std = zoran_s_std, 3010 .vidioc_g_jpegcomp = zoran_g_jpegcomp, 3011 .vidioc_s_jpegcomp = zoran_s_jpegcomp, 3012 .vidioc_overlay = zoran_overlay, 3013 .vidioc_reqbufs = zoran_reqbufs, 3014 .vidioc_querybuf = zoran_querybuf, 3015 .vidioc_qbuf = zoran_qbuf, 3016 .vidioc_dqbuf = zoran_dqbuf, 3017 .vidioc_streamon = zoran_streamon, 3018 .vidioc_streamoff = zoran_streamoff, 3019 .vidioc_enum_fmt_vid_cap = zoran_enum_fmt_vid_cap, 3020 .vidioc_enum_fmt_vid_out = zoran_enum_fmt_vid_out, 3021 .vidioc_enum_fmt_vid_overlay = zoran_enum_fmt_vid_overlay, 3022 .vidioc_g_fmt_vid_cap = zoran_g_fmt_vid_cap, 3023 .vidioc_g_fmt_vid_out = zoran_g_fmt_vid_out, 3024 .vidioc_g_fmt_vid_overlay = zoran_g_fmt_vid_overlay, 3025 .vidioc_s_fmt_vid_cap = zoran_s_fmt_vid_cap, 3026 .vidioc_s_fmt_vid_out = zoran_s_fmt_vid_out, 3027 .vidioc_s_fmt_vid_overlay = zoran_s_fmt_vid_overlay, 3028 .vidioc_try_fmt_vid_cap = zoran_try_fmt_vid_cap, 3029 .vidioc_try_fmt_vid_out = zoran_try_fmt_vid_out, 3030 .vidioc_try_fmt_vid_overlay = zoran_try_fmt_vid_overlay, 3031 .vidioc_queryctrl = zoran_queryctrl, 3032 .vidioc_s_ctrl = zoran_s_ctrl, 3033 .vidioc_g_ctrl = zoran_g_ctrl, 3034 }; 3035 3036 /* please use zr->resource_lock consistently and kill this wrapper */ 3037 static long zoran_ioctl(struct file *file, unsigned int cmd, 3038 unsigned long arg) 3039 { 3040 struct zoran_fh *fh = file->private_data; 3041 struct zoran *zr = fh->zr; 3042 int ret; 3043 3044 mutex_lock(&zr->other_lock); 3045 ret = video_ioctl2(file, cmd, arg); 3046 mutex_unlock(&zr->other_lock); 3047 3048 return ret; 3049 } 3050 3051 static const struct v4l2_file_operations zoran_fops = { 3052 .owner = THIS_MODULE, 3053 .open = zoran_open, 3054 .release = zoran_close, 3055 .unlocked_ioctl = zoran_ioctl, 3056 .read = zoran_read, 3057 .write = zoran_write, 3058 .mmap = zoran_mmap, 3059 .poll = zoran_poll, 3060 }; 3061 3062 struct video_device zoran_template = { 3063 .name = ZORAN_NAME, 3064 .fops = &zoran_fops, 3065 .ioctl_ops = &zoran_ioctl_ops, 3066 .release = &zoran_vdev_release, 3067 .tvnorms = V4L2_STD_NTSC | V4L2_STD_PAL | V4L2_STD_SECAM, 3068 }; 3069 3070