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