1/* 2 * This program is free software; you can redistribute it and/or modify 3 * it under the terms of the GNU General Public License as published by 4 * the Free Software Foundation; either version 2, or (at your option) 5 * any later version. 6 * 7 * This program is distributed in the hope that it will be useful, 8 * but WITHOUT ANY WARRANTY; without even the implied warranty of 9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 10 * GNU General Public License for more details. 11 * 12 * You should have received a copy of the GNU General Public License 13 * along with this program; if not, write to the Free Software 14 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 15 */ 16 17#include <linux/kernel.h> 18#include <linux/sched.h> 19#include <linux/list.h> 20#include <linux/slab.h> 21#define __NO_VERSION__ /* Temporary: usbvideo is not a module yet */ 22#include <linux/module.h> 23#include <linux/mm.h> 24#include <linux/smp_lock.h> 25#include <linux/vmalloc.h> 26#include <linux/wrapper.h> 27#include <linux/init.h> 28#include <linux/spinlock.h> 29 30#include <asm/io.h> 31 32#include "usbvideo.h" 33 34#if defined(MAP_NR) 35#define virt_to_page(v) MAP_NR(v) /* Kernels 2.2.x */ 36#endif 37 38static int video_nr = -1; 39MODULE_PARM(video_nr, "i"); 40 41/* 42 * Local prototypes. 43 */ 44#if USES_PROC_FS 45static void usbvideo_procfs_level1_create(struct usbvideo *ut); 46static void usbvideo_procfs_level1_destroy(struct usbvideo *ut); 47static void usbvideo_procfs_level2_create(struct uvd *uvd); 48static void usbvideo_procfs_level2_destroy(struct uvd *uvd); 49static int usbvideo_default_procfs_read_proc( 50 char *page, char **start, off_t off, int count, 51 int *eof, void *data); 52static int usbvideo_default_procfs_write_proc( 53 struct file *file, const char *buffer, 54 unsigned long count, void *data); 55#endif 56 57/*******************************/ 58/* Memory management functions */ 59/*******************************/ 60 61/* 62 * Here we want the physical address of the memory. 63 * This is used when initializing the contents of the area. 64 */ 65unsigned long usbvideo_kvirt_to_pa(unsigned long adr) 66{ 67 unsigned long kva, ret; 68 69 kva = (unsigned long) page_address(vmalloc_to_page((void *)adr)); 70 kva |= adr & (PAGE_SIZE-1); /* restore the offset */ 71 ret = __pa(kva); 72 return ret; 73} 74 75void *usbvideo_rvmalloc(unsigned long size) 76{ 77 void *mem; 78 unsigned long adr; 79 80 size = PAGE_ALIGN(size); 81 mem = vmalloc_32(size); 82 if (!mem) 83 return NULL; 84 85 memset(mem, 0, size); /* Clear the ram out, no junk to the user */ 86 adr = (unsigned long) mem; 87 while (size > 0) { 88 mem_map_reserve(vmalloc_to_page((void *)adr)); 89 adr += PAGE_SIZE; 90 size -= PAGE_SIZE; 91 } 92 93 return mem; 94} 95 96void usbvideo_rvfree(void *mem, unsigned long size) 97{ 98 unsigned long adr; 99 100 if (!mem) 101 return; 102 103 adr = (unsigned long) mem; 104 while ((long) size > 0) { 105 mem_map_unreserve(vmalloc_to_page((void *)adr)); 106 adr += PAGE_SIZE; 107 size -= PAGE_SIZE; 108 } 109 vfree(mem); 110} 111 112static void RingQueue_Initialize(struct RingQueue *rq) 113{ 114 assert(rq != NULL); 115 init_waitqueue_head(&rq->wqh); 116} 117 118static void RingQueue_Allocate(struct RingQueue *rq, int rqLen) 119{ 120 /* Make sure the requested size is a power of 2 and 121 round up if necessary. This allows index wrapping 122 using masks rather than modulo */ 123 124 int i = 1; 125 assert(rq != NULL); 126 assert(rqLen > 0); 127 128 while(rqLen >> i) 129 i++; 130 if(rqLen != 1 << (i-1)) 131 rqLen = 1 << i; 132 133 rq->length = rqLen; 134 rq->ri = rq->wi = 0; 135 rq->queue = usbvideo_rvmalloc(rq->length); 136 assert(rq->queue != NULL); 137} 138 139static int RingQueue_IsAllocated(const struct RingQueue *rq) 140{ 141 if (rq == NULL) 142 return 0; 143 return (rq->queue != NULL) && (rq->length > 0); 144} 145 146static void RingQueue_Free(struct RingQueue *rq) 147{ 148 assert(rq != NULL); 149 if (RingQueue_IsAllocated(rq)) { 150 usbvideo_rvfree(rq->queue, rq->length); 151 rq->queue = NULL; 152 rq->length = 0; 153 } 154} 155 156int RingQueue_Dequeue(struct RingQueue *rq, unsigned char *dst, int len) 157{ 158 int rql, toread; 159 160 assert(rq != NULL); 161 assert(dst != NULL); 162 163 rql = RingQueue_GetLength(rq); 164 if(!rql) 165 return 0; 166 167 /* Clip requested length to available data */ 168 if(len > rql) 169 len = rql; 170 171 toread = len; 172 if(rq->ri > rq->wi) { 173 /* Read data from tail */ 174 int read = (toread < (rq->length - rq->ri)) ? toread : rq->length - rq->ri; 175 memcpy(dst, rq->queue + rq->ri, read); 176 toread -= read; 177 dst += read; 178 rq->ri = (rq->ri + read) & (rq->length-1); 179 } 180 if(toread) { 181 /* Read data from head */ 182 memcpy(dst, rq->queue + rq->ri, toread); 183 rq->ri = (rq->ri + toread) & (rq->length-1); 184 } 185 return len; 186} 187 188int RingQueue_Enqueue(struct RingQueue *rq, const unsigned char *cdata, int n) 189{ 190 int enqueued = 0; 191 192 assert(rq != NULL); 193 assert(cdata != NULL); 194 assert(rq->length > 0); 195 while (n > 0) { 196 int m, q_avail; 197 198 /* Calculate the largest chunk that fits the tail of the ring */ 199 q_avail = rq->length - rq->wi; 200 if (q_avail <= 0) { 201 rq->wi = 0; 202 q_avail = rq->length; 203 } 204 m = n; 205 assert(q_avail > 0); 206 if (m > q_avail) 207 m = q_avail; 208 209 memcpy(rq->queue + rq->wi, cdata, m); 210 RING_QUEUE_ADVANCE_INDEX(rq, wi, m); 211 cdata += m; 212 enqueued += m; 213 n -= m; 214 } 215 return enqueued; 216} 217 218static void RingQueue_InterruptibleSleepOn(struct RingQueue *rq) 219{ 220 assert(rq != NULL); 221 interruptible_sleep_on(&rq->wqh); 222} 223 224void RingQueue_WakeUpInterruptible(struct RingQueue *rq) 225{ 226 assert(rq != NULL); 227 if (waitqueue_active(&rq->wqh)) 228 wake_up_interruptible(&rq->wqh); 229} 230 231void RingQueue_Flush(struct RingQueue *rq) 232{ 233 assert(rq != NULL); 234 rq->ri = 0; 235 rq->wi = 0; 236} 237 238 239/* 240 * usbvideo_VideosizeToString() 241 * 242 * This procedure converts given videosize value to readable string. 243 * 244 * History: 245 * 07-Aug-2000 Created. 246 * 19-Oct-2000 Reworked for usbvideo module. 247 */ 248void usbvideo_VideosizeToString(char *buf, int bufLen, videosize_t vs) 249{ 250 char tmp[40]; 251 int n; 252 253 n = 1 + sprintf(tmp, "%ldx%ld", VIDEOSIZE_X(vs), VIDEOSIZE_Y(vs)); 254 assert(n < sizeof(tmp)); 255 if ((buf == NULL) || (bufLen < n)) 256 err("usbvideo_VideosizeToString: buffer is too small."); 257 else 258 memmove(buf, tmp, n); 259} 260 261/* 262 * usbvideo_OverlayChar() 263 * 264 * History: 265 * 01-Feb-2000 Created. 266 */ 267void usbvideo_OverlayChar(struct uvd *uvd, struct usbvideo_frame *frame, 268 int x, int y, int ch) 269{ 270 static const unsigned short digits[16] = { 271 0xF6DE, /* 0 */ 272 0x2492, /* 1 */ 273 0xE7CE, /* 2 */ 274 0xE79E, /* 3 */ 275 0xB792, /* 4 */ 276 0xF39E, /* 5 */ 277 0xF3DE, /* 6 */ 278 0xF492, /* 7 */ 279 0xF7DE, /* 8 */ 280 0xF79E, /* 9 */ 281 0x77DA, /* a */ 282 0xD75C, /* b */ 283 0xF24E, /* c */ 284 0xD6DC, /* d */ 285 0xF34E, /* e */ 286 0xF348 /* f */ 287 }; 288 unsigned short digit; 289 int ix, iy; 290 291 if ((uvd == NULL) || (frame == NULL)) 292 return; 293 294 if (ch >= '0' && ch <= '9') 295 ch -= '0'; 296 else if (ch >= 'A' && ch <= 'F') 297 ch = 10 + (ch - 'A'); 298 else if (ch >= 'a' && ch <= 'f') 299 ch = 10 + (ch - 'a'); 300 else 301 return; 302 digit = digits[ch]; 303 304 for (iy=0; iy < 5; iy++) { 305 for (ix=0; ix < 3; ix++) { 306 if (digit & 0x8000) { 307 if (uvd->paletteBits & (1L << VIDEO_PALETTE_RGB24)) { 308/* TODO */ RGB24_PUTPIXEL(frame, x+ix, y+iy, 0xFF, 0xFF, 0xFF); 309 } 310 } 311 digit = digit << 1; 312 } 313 } 314} 315 316/* 317 * usbvideo_OverlayString() 318 * 319 * History: 320 * 01-Feb-2000 Created. 321 */ 322void usbvideo_OverlayString(struct uvd *uvd, struct usbvideo_frame *frame, 323 int x, int y, const char *str) 324{ 325 while (*str) { 326 usbvideo_OverlayChar(uvd, frame, x, y, *str); 327 str++; 328 x += 4; /* 3 pixels character + 1 space */ 329 } 330} 331 332/* 333 * usbvideo_OverlayStats() 334 * 335 * Overlays important debugging information. 336 * 337 * History: 338 * 01-Feb-2000 Created. 339 */ 340void usbvideo_OverlayStats(struct uvd *uvd, struct usbvideo_frame *frame) 341{ 342 const int y_diff = 8; 343 char tmp[16]; 344 int x = 10, y=10; 345 long i, j, barLength; 346 const int qi_x1 = 60, qi_y1 = 10; 347 const int qi_x2 = VIDEOSIZE_X(frame->request) - 10, qi_h = 10; 348 349 /* Call the user callback, see if we may proceed after that */ 350 if (VALID_CALLBACK(uvd, overlayHook)) { 351 if (GET_CALLBACK(uvd, overlayHook)(uvd, frame) < 0) 352 return; 353 } 354 355 /* 356 * We draw a (mostly) hollow rectangle with qi_xxx coordinates. 357 * Left edge symbolizes the queue index 0; right edge symbolizes 358 * the full capacity of the queue. 359 */ 360 barLength = qi_x2 - qi_x1 - 2; 361 if ((barLength > 10) && (uvd->paletteBits & (1L << VIDEO_PALETTE_RGB24))) { 362/* TODO */ long u_lo, u_hi, q_used; 363 long m_ri, m_wi, m_lo, m_hi; 364 365 /* 366 * Determine fill zones (used areas of the queue): 367 * 0 xxxxxxx u_lo ...... uvd->dp.ri xxxxxxxx u_hi ..... uvd->dp.length 368 * 369 * if u_lo < 0 then there is no first filler. 370 */ 371 372 q_used = RingQueue_GetLength(&uvd->dp); 373 if ((uvd->dp.ri + q_used) >= uvd->dp.length) { 374 u_hi = uvd->dp.length; 375 u_lo = (q_used + uvd->dp.ri) & (uvd->dp.length-1); 376 } else { 377 u_hi = (q_used + uvd->dp.ri); 378 u_lo = -1; 379 } 380 381 /* Convert byte indices into screen units */ 382 m_ri = qi_x1 + ((barLength * uvd->dp.ri) / uvd->dp.length); 383 m_wi = qi_x1 + ((barLength * uvd->dp.wi) / uvd->dp.length); 384 m_lo = (u_lo > 0) ? (qi_x1 + ((barLength * u_lo) / uvd->dp.length)) : -1; 385 m_hi = qi_x1 + ((barLength * u_hi) / uvd->dp.length); 386 387 for (j=qi_y1; j < (qi_y1 + qi_h); j++) { 388 for (i=qi_x1; i < qi_x2; i++) { 389 /* Draw border lines */ 390 if ((j == qi_y1) || (j == (qi_y1 + qi_h - 1)) || 391 (i == qi_x1) || (i == (qi_x2 - 1))) { 392 RGB24_PUTPIXEL(frame, i, j, 0xFF, 0xFF, 0xFF); 393 continue; 394 } 395 /* For all other points the Y coordinate does not matter */ 396 if ((i >= m_ri) && (i <= (m_ri + 3))) { 397 RGB24_PUTPIXEL(frame, i, j, 0x00, 0xFF, 0x00); 398 } else if ((i >= m_wi) && (i <= (m_wi + 3))) { 399 RGB24_PUTPIXEL(frame, i, j, 0xFF, 0x00, 0x00); 400 } else if ((i < m_lo) || ((i > m_ri) && (i < m_hi))) 401 RGB24_PUTPIXEL(frame, i, j, 0x00, 0x00, 0xFF); 402 } 403 } 404 } 405 406 sprintf(tmp, "%8lx", uvd->stats.frame_num); 407 usbvideo_OverlayString(uvd, frame, x, y, tmp); 408 y += y_diff; 409 410 sprintf(tmp, "%8lx", uvd->stats.urb_count); 411 usbvideo_OverlayString(uvd, frame, x, y, tmp); 412 y += y_diff; 413 414 sprintf(tmp, "%8lx", uvd->stats.urb_length); 415 usbvideo_OverlayString(uvd, frame, x, y, tmp); 416 y += y_diff; 417 418 sprintf(tmp, "%8lx", uvd->stats.data_count); 419 usbvideo_OverlayString(uvd, frame, x, y, tmp); 420 y += y_diff; 421 422 sprintf(tmp, "%8lx", uvd->stats.header_count); 423 usbvideo_OverlayString(uvd, frame, x, y, tmp); 424 y += y_diff; 425 426 sprintf(tmp, "%8lx", uvd->stats.iso_skip_count); 427 usbvideo_OverlayString(uvd, frame, x, y, tmp); 428 y += y_diff; 429 430 sprintf(tmp, "%8lx", uvd->stats.iso_err_count); 431 usbvideo_OverlayString(uvd, frame, x, y, tmp); 432 y += y_diff; 433 434 sprintf(tmp, "%8x", uvd->vpic.colour); 435 usbvideo_OverlayString(uvd, frame, x, y, tmp); 436 y += y_diff; 437 438 sprintf(tmp, "%8x", uvd->vpic.hue); 439 usbvideo_OverlayString(uvd, frame, x, y, tmp); 440 y += y_diff; 441 442 sprintf(tmp, "%8x", uvd->vpic.brightness >> 8); 443 usbvideo_OverlayString(uvd, frame, x, y, tmp); 444 y += y_diff; 445 446 sprintf(tmp, "%8x", uvd->vpic.contrast >> 12); 447 usbvideo_OverlayString(uvd, frame, x, y, tmp); 448 y += y_diff; 449 450 sprintf(tmp, "%8d", uvd->vpic.whiteness >> 8); 451 usbvideo_OverlayString(uvd, frame, x, y, tmp); 452 y += y_diff; 453} 454 455/* 456 * usbvideo_ReportStatistics() 457 * 458 * This procedure prints packet and transfer statistics. 459 * 460 * History: 461 * 14-Jan-2000 Corrected default multiplier. 462 */ 463void usbvideo_ReportStatistics(const struct uvd *uvd) 464{ 465 if ((uvd != NULL) && (uvd->stats.urb_count > 0)) { 466 unsigned long allPackets, badPackets, goodPackets, percent; 467 allPackets = uvd->stats.urb_count * CAMERA_URB_FRAMES; 468 badPackets = uvd->stats.iso_skip_count + uvd->stats.iso_err_count; 469 goodPackets = allPackets - badPackets; 470 /* Calculate percentage wisely, remember integer limits */ 471 assert(allPackets != 0); 472 if (goodPackets < (((unsigned long)-1)/100)) 473 percent = (100 * goodPackets) / allPackets; 474 else 475 percent = goodPackets / (allPackets / 100); 476 info("Packet Statistics: Total=%lu. Empty=%lu. Usage=%lu%%", 477 allPackets, badPackets, percent); 478 if (uvd->iso_packet_len > 0) { 479 unsigned long allBytes, xferBytes; 480 char multiplier = ' '; 481 allBytes = allPackets * uvd->iso_packet_len; 482 xferBytes = uvd->stats.data_count; 483 assert(allBytes != 0); 484 if (xferBytes < (((unsigned long)-1)/100)) 485 percent = (100 * xferBytes) / allBytes; 486 else 487 percent = xferBytes / (allBytes / 100); 488 /* Scale xferBytes for easy reading */ 489 if (xferBytes > 10*1024) { 490 xferBytes /= 1024; 491 multiplier = 'K'; 492 if (xferBytes > 10*1024) { 493 xferBytes /= 1024; 494 multiplier = 'M'; 495 if (xferBytes > 10*1024) { 496 xferBytes /= 1024; 497 multiplier = 'G'; 498 if (xferBytes > 10*1024) { 499 xferBytes /= 1024; 500 multiplier = 'T'; 501 } 502 } 503 } 504 } 505 info("Transfer Statistics: Transferred=%lu%cB Usage=%lu%%", 506 xferBytes, multiplier, percent); 507 } 508 } 509} 510 511/* 512 * usbvideo_DrawLine() 513 * 514 * A standard implementation of Bresenham's line drawing algorithm. 515 * This procedure is provided primarily for debugging or demo 516 * purposes. 517 */ 518void usbvideo_DrawLine( 519 struct usbvideo_frame *frame, 520 int x1, int y1, 521 int x2, int y2, 522 unsigned char cr, unsigned char cg, unsigned char cb) 523{ 524 int i, dx, dy, np, d; 525 int dinc1, dinc2, x, xinc1, xinc2, y, yinc1, yinc2; 526 527 if ((dx = x2 - x1) < 0) 528 dx = -dx; 529 if ((dy = y2 - y1) < 0) 530 dy = -dy; 531 if (dx >= dy) { 532 np = dx + 1; 533 d = (2 * dy) - dx; 534 dinc1 = dy << 1; 535 dinc2 = (dy - dx) << 1; 536 xinc1 = 1; 537 xinc2 = 1; 538 yinc1 = 0; 539 yinc2 = 1; 540 } else { 541 np = dy + 1; 542 d = (2 * dx) - dy; 543 dinc1 = dx << 1; 544 dinc2 = (dx - dy) << 1; 545 xinc1 = 0; 546 xinc2 = 1; 547 yinc1 = 1; 548 yinc2 = 1; 549 } 550 /* Make sure x and y move in the right directions */ 551 if (x1 > x2) { 552 xinc1 = -xinc1; 553 xinc2 = -xinc2; 554 } 555 if (y1 > y2) { 556 yinc1 = -yinc1; 557 yinc2 = -yinc2; 558 } 559 for (i=0, x=x1, y=y1; i < np; i++) { 560 if (frame->palette == VIDEO_PALETTE_RGB24) { 561/* TODO */ RGB24_PUTPIXEL(frame, x, y, cr, cg, cb); 562 } 563 if (d < 0) { 564 d += dinc1; 565 x += xinc1; 566 y += yinc1; 567 } else { 568 d += dinc2; 569 x += xinc2; 570 y += yinc2; 571 } 572 } 573} 574 575/* 576 * usbvideo_TestPattern() 577 * 578 * Procedure forms a test pattern (yellow grid on blue background). 579 * 580 * Parameters: 581 * fullframe: if TRUE then entire frame is filled, otherwise the procedure 582 * continues from the current scanline. 583 * pmode 0: fill the frame with solid blue color (like on VCR or TV) 584 * 1: Draw a colored grid 585 * 586 * History: 587 * 01-Feb-2000 Created. 588 */ 589void usbvideo_TestPattern(struct uvd *uvd, int fullframe, int pmode) 590{ 591 struct usbvideo_frame *frame; 592 int num_cell = 0; 593 int scan_length = 0; 594 static int num_pass = 0; 595 596 if (uvd == NULL) { 597 err("%s: uvd == NULL", __FUNCTION__); 598 return; 599 } 600 if ((uvd->curframe < 0) || (uvd->curframe >= USBVIDEO_NUMFRAMES)) { 601 err("%s: uvd->curframe=%d.", __FUNCTION__, uvd->curframe); 602 return; 603 } 604 605 /* Grab the current frame */ 606 frame = &uvd->frame[uvd->curframe]; 607 608 /* Optionally start at the beginning */ 609 if (fullframe) { 610 frame->curline = 0; 611 frame->seqRead_Length = 0; 612 } 613#if 0 614 { /* For debugging purposes only */ 615 char tmp[20]; 616 usbvideo_VideosizeToString(tmp, sizeof(tmp), frame->request); 617 info("testpattern: frame=%s", tmp); 618 } 619#endif 620 /* Form every scan line */ 621 for (; frame->curline < VIDEOSIZE_Y(frame->request); frame->curline++) { 622 int i; 623 unsigned char *f = frame->data + 624 (VIDEOSIZE_X(frame->request) * V4L_BYTES_PER_PIXEL * frame->curline); 625 for (i=0; i < VIDEOSIZE_X(frame->request); i++) { 626 unsigned char cb=0x80; 627 unsigned char cg = 0; 628 unsigned char cr = 0; 629 630 if (pmode == 1) { 631 if (frame->curline % 32 == 0) 632 cb = 0, cg = cr = 0xFF; 633 else if (i % 32 == 0) { 634 if (frame->curline % 32 == 1) 635 num_cell++; 636 cb = 0, cg = cr = 0xFF; 637 } else { 638 cb = ((num_cell*7) + num_pass) & 0xFF; 639 cg = ((num_cell*5) + num_pass*2) & 0xFF; 640 cr = ((num_cell*3) + num_pass*3) & 0xFF; 641 } 642 } else { 643 /* Just the blue screen */ 644 } 645 646 *f++ = cb; 647 *f++ = cg; 648 *f++ = cr; 649 scan_length += 3; 650 } 651 } 652 653 frame->frameState = FrameState_Done; 654 frame->seqRead_Length += scan_length; 655 ++num_pass; 656 657 /* We do this unconditionally, regardless of FLAGS_OVERLAY_STATS */ 658 usbvideo_OverlayStats(uvd, frame); 659} 660 661/* 662 * usbvideo_HexDump() 663 * 664 * A debugging tool. Prints hex dumps. 665 * 666 * History: 667 * 29-Jul-2000 Added printing of offsets. 668 */ 669void usbvideo_HexDump(const unsigned char *data, int len) 670{ 671 const int bytes_per_line = 32; 672 char tmp[128]; /* 32*3 + 5 */ 673 int i, k; 674 675 for (i=k=0; len > 0; i++, len--) { 676 if (i > 0 && ((i % bytes_per_line) == 0)) { 677 printk("%s\n", tmp); 678 k=0; 679 } 680 if ((i % bytes_per_line) == 0) 681 k += sprintf(&tmp[k], "%04x: ", i); 682 k += sprintf(&tmp[k], "%02x ", data[i]); 683 } 684 if (k > 0) 685 printk("%s\n", tmp); 686} 687 688/* Debugging aid */ 689void usbvideo_SayAndWait(const char *what) 690{ 691 wait_queue_head_t wq; 692 init_waitqueue_head(&wq); 693 info("Say: %s", what); 694 interruptible_sleep_on_timeout (&wq, HZ*3); /* Timeout */ 695} 696 697/* ******************************************************************** */ 698 699static void usbvideo_ClientIncModCount(struct uvd *uvd) 700{ 701 if (uvd == NULL) { 702 err("%s: uvd == NULL", __FUNCTION__); 703 return; 704 } 705 if (uvd->handle == NULL) { 706 err("%s: uvd->handle == NULL", __FUNCTION__); 707 return; 708 } 709 if (uvd->handle->md_module == NULL) { 710 err("%s: uvd->handle->md_module == NULL", __FUNCTION__); 711 return; 712 } 713 __MOD_INC_USE_COUNT(uvd->handle->md_module); 714} 715 716static void usbvideo_ClientDecModCount(struct uvd *uvd) 717{ 718 if (uvd == NULL) { 719 err("%s: uvd == NULL", __FUNCTION__); 720 return; 721 } 722 if (uvd->handle == NULL) { 723 err("%s: uvd->handle == NULL", __FUNCTION__); 724 return; 725 } 726 if (uvd->handle->md_module == NULL) { 727 err("%s: uvd->handle->md_module == NULL", __FUNCTION__); 728 return; 729 } 730 __MOD_DEC_USE_COUNT(uvd->handle->md_module); 731} 732 733int usbvideo_register( 734 struct usbvideo **pCams, 735 const int num_cams, 736 const int num_extra, 737 const char *driverName, 738 const struct usbvideo_cb *cbTbl, 739 struct module *md, 740 const struct usb_device_id *id_table) 741{ 742 struct usbvideo *cams; 743 int i, base_size; 744 745 /* Check parameters for sanity */ 746 if ((num_cams <= 0) || (pCams == NULL) || (cbTbl == NULL)) { 747 err("%s: Illegal call", __FUNCTION__); 748 return -EINVAL; 749 } 750 751 /* Check registration callback - must be set! */ 752 if (cbTbl->probe == NULL) { 753 err("%s: probe() is required!", __FUNCTION__); 754 return -EINVAL; 755 } 756 757 base_size = num_cams * sizeof(struct uvd) + sizeof(struct usbvideo); 758 cams = (struct usbvideo *) kmalloc(base_size, GFP_KERNEL); 759 if (cams == NULL) { 760 err("Failed to allocate %d. bytes for usbvideo struct", base_size); 761 return -ENOMEM; 762 } 763 dbg("%s: Allocated $%p (%d. bytes) for %d. cameras", 764 __FUNCTION__, cams, base_size, num_cams); 765 memset(cams, 0, base_size); 766 767 /* Copy callbacks, apply defaults for those that are not set */ 768 memmove(&cams->cb, cbTbl, sizeof(cams->cb)); 769 if (cams->cb.getFrame == NULL) 770 cams->cb.getFrame = usbvideo_GetFrame; 771 if (cams->cb.disconnect == NULL) 772 cams->cb.disconnect = usbvideo_Disconnect; 773 if (cams->cb.startDataPump == NULL) 774 cams->cb.startDataPump = usbvideo_StartDataPump; 775 if (cams->cb.stopDataPump == NULL) 776 cams->cb.stopDataPump = usbvideo_StopDataPump; 777#if USES_PROC_FS 778 /* 779 * If both /proc fs callbacks are NULL then we assume that the driver 780 * does not need procfs services at all. Leave them NULL. 781 */ 782 cams->uses_procfs = (cams->cb.procfs_read != NULL) || (cams->cb.procfs_write == NULL); 783 if (cams->uses_procfs) { 784 if (cams->cb.procfs_read == NULL) 785 cams->cb.procfs_read = usbvideo_default_procfs_read_proc; 786 if (cams->cb.procfs_write == NULL) 787 cams->cb.procfs_write = usbvideo_default_procfs_write_proc; 788 } 789#else /* !USES_PROC_FS */ 790 /* Report a warning so that user knows why there is no /proc entries */ 791 if ((cams->cb.procfs_read != NULL) || (cams->cb.procfs_write == NULL)) { 792 dbg("%s: /proc fs support requested but not configured!", __FUNCTION__); 793 } 794#endif 795 cams->num_cameras = num_cams; 796 cams->cam = (struct uvd *) &cams[1]; 797 cams->md_module = md; 798 if (cams->md_module == NULL) 799 warn("%s: module == NULL!", __FUNCTION__); 800 init_MUTEX(&cams->lock); /* to 1 == available */ 801 802 for (i = 0; i < num_cams; i++) { 803 struct uvd *up = &cams->cam[i]; 804 805 up->handle = cams; 806 807 /* Allocate user_data separately because of kmalloc's limits */ 808 if (num_extra > 0) { 809 up->user_size = num_cams * num_extra; 810 up->user_data = (char *) kmalloc(up->user_size, GFP_KERNEL); 811 if (up->user_data == NULL) { 812 up->user_size = 0; 813 err("%s: Failed to allocate user_data (%d. bytes)", 814 __FUNCTION__, up->user_size); 815 return -ENOMEM; 816 } 817 dbg("%s: Allocated cams[%d].user_data=$%p (%d. bytes)", 818 __FUNCTION__, i, up->user_data, up->user_size); 819 } 820 } 821 822 /* 823 * Register ourselves with USB stack. 824 */ 825 strcpy(cams->drvName, (driverName != NULL) ? driverName : "Unknown"); 826 cams->usbdrv.name = cams->drvName; 827 cams->usbdrv.probe = cams->cb.probe; 828 cams->usbdrv.disconnect = cams->cb.disconnect; 829 cams->usbdrv.id_table = id_table; 830 831#if USES_PROC_FS 832 if (cams->uses_procfs) { 833 dbg("%s: Creating /proc filesystem entries.", __FUNCTION__); 834 usbvideo_procfs_level1_create(cams); 835 } 836#endif 837 838 /* 839 * Update global handle to usbvideo. This is very important 840 * because probe() can be called before usb_register() returns. 841 * If the handle is not yet updated then the probe() will fail. 842 */ 843 *pCams = cams; 844 usb_register(&cams->usbdrv); 845 846 return 0; 847} 848 849/* 850 * usbvideo_Deregister() 851 * 852 * Procedure frees all usbvideo and user data structures. Be warned that 853 * if you had some dynamically allocated components in ->user field then 854 * you should free them before calling here. 855 */ 856void usbvideo_Deregister(struct usbvideo **pCams) 857{ 858 struct usbvideo *cams; 859 int i; 860 861 if (pCams == NULL) { 862 err("%s: pCams == NULL", __FUNCTION__); 863 return; 864 } 865 cams = *pCams; 866 if (cams == NULL) { 867 err("%s: cams == NULL", __FUNCTION__); 868 return; 869 } 870 871#if USES_PROC_FS 872 if (cams->uses_procfs) { 873 dbg("%s: Deregistering filesystem entries.", __FUNCTION__); 874 usbvideo_procfs_level1_destroy(cams); 875 } 876#endif 877 878 dbg("%s: Deregistering %s driver.", __FUNCTION__, cams->drvName); 879 usb_deregister(&cams->usbdrv); 880 881 dbg("%s: Deallocating cams=$%p (%d. cameras)", __FUNCTION__, cams, cams->num_cameras); 882 for (i=0; i < cams->num_cameras; i++) { 883 struct uvd *up = &cams->cam[i]; 884 int warning = 0; 885 886 if (up->user_data != NULL) { 887 if (up->user_size <= 0) 888 ++warning; 889 } else { 890 if (up->user_size > 0) 891 ++warning; 892 } 893 if (warning) { 894 err("%s: Warning: user_data=$%p user_size=%d.", 895 __FUNCTION__, up->user_data, up->user_size); 896 } else { 897 dbg("%s: Freeing %d. $%p->user_data=$%p", 898 __FUNCTION__, i, up, up->user_data); 899 kfree(up->user_data); 900 } 901 } 902 /* Whole array was allocated in one chunk */ 903 dbg("%s: Freed %d uvd structures", 904 __FUNCTION__, cams->num_cameras); 905 kfree(cams); 906 *pCams = NULL; 907} 908 909/* 910 * usbvideo_Disconnect() 911 * 912 * This procedure stops all driver activity. Deallocation of 913 * the interface-private structure (pointed by 'ptr') is done now 914 * (if we don't have any open files) or later, when those files 915 * are closed. After that driver should be removable. 916 * 917 * This code handles surprise removal. The uvd->user is a counter which 918 * increments on open() and decrements on close(). If we see here that 919 * this counter is not 0 then we have a client who still has us opened. 920 * We set uvd->remove_pending flag as early as possible, and after that 921 * all access to the camera will gracefully fail. These failures should 922 * prompt client to (eventually) close the video device, and then - in 923 * usbvideo_v4l_close() - we decrement uvd->uvd_used and usage counter. 924 * 925 * History: 926 * 22-Jan-2000 Added polling of MOD_IN_USE to delay removal until all users gone. 927 * 27-Jan-2000 Reworked to allow pending disconnects; see xxx_close() 928 * 24-May-2000 Corrected to prevent race condition (MOD_xxx_USE_COUNT). 929 * 19-Oct-2000 Moved to usbvideo module. 930 */ 931void usbvideo_Disconnect(struct usb_device *dev, void *ptr) 932{ 933 struct uvd *uvd = (struct uvd *) ptr; 934 int i; 935 936 if ((dev == NULL) || (uvd == NULL)) { 937 err("%s($%p,$%p): Illegal call.", __FUNCTION__, dev, ptr); 938 return; 939 } 940 usbvideo_ClientIncModCount(uvd); 941 if (uvd->debug > 0) 942 info("%s(%p,%p.)", __FUNCTION__, dev, ptr); 943 944 down(&uvd->lock); 945 uvd->remove_pending = 1; /* Now all ISO data will be ignored */ 946 947 /* At this time we ask to cancel outstanding URBs */ 948 GET_CALLBACK(uvd, stopDataPump)(uvd); 949 950 for (i=0; i < USBVIDEO_NUMSBUF; i++) 951 usb_free_urb(uvd->sbuf[i].urb); 952 953 usb_dec_dev_use(uvd->dev); 954 uvd->dev = NULL; /* USB device is no more */ 955 956 if (uvd->user) 957 info("%s: In use, disconnect pending.", __FUNCTION__); 958 else 959 usbvideo_CameraRelease(uvd); 960 up(&uvd->lock); 961 info("USB camera disconnected."); 962 963 usbvideo_ClientDecModCount(uvd); 964} 965 966/* 967 * usbvideo_CameraRelease() 968 * 969 * This code does final release of struct uvd. This happens 970 * after the device is disconnected -and- all clients 971 * closed their files. 972 * 973 * History: 974 * 27-Jan-2000 Created. 975 */ 976void usbvideo_CameraRelease(struct uvd *uvd) 977{ 978 if (uvd == NULL) { 979 err("%s: Illegal call", __FUNCTION__); 980 return; 981 } 982 video_unregister_device(&uvd->vdev); 983 if (uvd->debug > 0) 984 info("%s: Video unregistered.", __FUNCTION__); 985 986#if USES_PROC_FS 987 assert(uvd->handle != NULL); 988 if (uvd->handle->uses_procfs) { 989 dbg("%s: Removing /proc/%s/ filesystem entries.", __FUNCTION__, uvd->handle->drvName); 990 usbvideo_procfs_level2_destroy(uvd); 991 } 992#endif 993 994 RingQueue_Free(&uvd->dp); 995 if (VALID_CALLBACK(uvd, userFree)) 996 GET_CALLBACK(uvd, userFree)(uvd); 997 uvd->uvd_used = 0; /* This is atomic, no need to take mutex */ 998} 999 1000/* 1001 * usbvideo_find_struct() 1002 * 1003 * This code searches the array of preallocated (static) structures 1004 * and returns index of the first one that isn't in use. Returns -1 1005 * if there are no free structures. 1006 * 1007 * History: 1008 * 27-Jan-2000 Created. 1009 */ 1010static int usbvideo_find_struct(struct usbvideo *cams) 1011{ 1012 int u, rv = -1; 1013 1014 if (cams == NULL) { 1015 err("No usbvideo handle?"); 1016 return -1; 1017 } 1018 down(&cams->lock); 1019 for (u = 0; u < cams->num_cameras; u++) { 1020 struct uvd *uvd = &cams->cam[u]; 1021 if (!uvd->uvd_used) /* This one is free */ 1022 { 1023 uvd->uvd_used = 1; /* In use now */ 1024 init_MUTEX(&uvd->lock); /* to 1 == available */ 1025 uvd->dev = NULL; 1026 rv = u; 1027 break; 1028 } 1029 } 1030 up(&cams->lock); 1031 return rv; 1032} 1033 1034struct uvd *usbvideo_AllocateDevice(struct usbvideo *cams) 1035{ 1036 int i, devnum; 1037 struct uvd *uvd = NULL; 1038 1039 if (cams == NULL) { 1040 err("No usbvideo handle?"); 1041 return NULL; 1042 } 1043 1044 devnum = usbvideo_find_struct(cams); 1045 if (devnum == -1) { 1046 err("IBM USB camera driver: Too many devices!"); 1047 return NULL; 1048 } 1049 uvd = &cams->cam[devnum]; 1050 dbg("Device entry #%d. at $%p", devnum, uvd); 1051 1052 /* Not relying upon caller we increase module counter ourselves */ 1053 usbvideo_ClientIncModCount(uvd); 1054 1055 down(&uvd->lock); 1056 for (i=0; i < USBVIDEO_NUMSBUF; i++) { 1057 uvd->sbuf[i].urb = usb_alloc_urb(FRAMES_PER_DESC); 1058 if (uvd->sbuf[i].urb == NULL) { 1059 err("usb_alloc_urb(%d.) failed.", FRAMES_PER_DESC); 1060 uvd->uvd_used = 0; 1061 uvd = NULL; 1062 goto allocate_done; 1063 } 1064 } 1065 uvd->user=0; 1066 uvd->remove_pending = 0; 1067 uvd->last_error = 0; 1068 RingQueue_Initialize(&uvd->dp); 1069 1070 /* Initialize video device structure */ 1071 memset(&uvd->vdev, 0, sizeof(uvd->vdev)); 1072 i = sprintf(uvd->vdev.name, "%s USB Camera", cams->drvName); 1073 if (i >= sizeof(uvd->vdev.name)) { 1074 err("Wrote too much into uvd->vdev.name, expect trouble!"); 1075 } 1076 uvd->vdev.type = VID_TYPE_CAPTURE; 1077 uvd->vdev.hardware = VID_HARDWARE_CPIA; 1078 uvd->vdev.open = usbvideo_v4l_open; 1079 uvd->vdev.close = usbvideo_v4l_close; 1080 uvd->vdev.read = usbvideo_v4l_read; 1081 uvd->vdev.write = usbvideo_v4l_write; 1082 uvd->vdev.ioctl = usbvideo_v4l_ioctl; 1083 uvd->vdev.mmap = usbvideo_v4l_mmap; 1084 uvd->vdev.initialize = usbvideo_v4l_initialize; 1085 /* 1086 * The client is free to overwrite those because we 1087 * return control to the client's probe function right now. 1088 */ 1089allocate_done: 1090 up (&uvd->lock); 1091 usbvideo_ClientDecModCount(uvd); 1092 return uvd; 1093} 1094 1095int usbvideo_RegisterVideoDevice(struct uvd *uvd) 1096{ 1097 char tmp1[20], tmp2[20]; /* Buffers for printing */ 1098 1099 if (uvd == NULL) { 1100 err("%s: Illegal call.", __FUNCTION__); 1101 return -EINVAL; 1102 } 1103 if (uvd->video_endp == 0) { 1104 info("%s: No video endpoint specified; data pump disabled.", __FUNCTION__); 1105 } 1106 if (uvd->paletteBits == 0) { 1107 err("%s: No palettes specified!", __FUNCTION__); 1108 return -EINVAL; 1109 } 1110 if (uvd->defaultPalette == 0) { 1111 info("%s: No default palette!", __FUNCTION__); 1112 } 1113 1114 uvd->max_frame_size = VIDEOSIZE_X(uvd->canvas) * 1115 VIDEOSIZE_Y(uvd->canvas) * V4L_BYTES_PER_PIXEL; 1116 usbvideo_VideosizeToString(tmp1, sizeof(tmp1), uvd->videosize); 1117 usbvideo_VideosizeToString(tmp2, sizeof(tmp2), uvd->canvas); 1118 1119 if (uvd->debug > 0) { 1120 info("%s: iface=%d. endpoint=$%02x paletteBits=$%08lx", 1121 __FUNCTION__, uvd->iface, uvd->video_endp, uvd->paletteBits); 1122 } 1123 if (video_register_device(&uvd->vdev, VFL_TYPE_GRABBER, video_nr) == -1) { 1124 err("%s: video_register_device failed", __FUNCTION__); 1125 return -EPIPE; 1126 } 1127 if (uvd->debug > 1) { 1128 info("%s: video_register_device() successful", __FUNCTION__); 1129 } 1130 if (uvd->dev == NULL) { 1131 err("%s: uvd->dev == NULL", __FUNCTION__); 1132 return -EINVAL; 1133 } 1134 1135 info("%s on /dev/video%d: canvas=%s videosize=%s", 1136 (uvd->handle != NULL) ? uvd->handle->drvName : "???", 1137 uvd->vdev.minor, tmp2, tmp1); 1138 1139#if USES_PROC_FS 1140 assert(uvd->handle != NULL); 1141 if (uvd->handle->uses_procfs) { 1142 if (uvd->debug > 0) { 1143 info("%s: Creating /proc/video/%s/ filesystem entries.", 1144 __FUNCTION__, uvd->handle->drvName); 1145 } 1146 usbvideo_procfs_level2_create(uvd); 1147 } 1148#endif 1149 1150 usb_inc_dev_use(uvd->dev); 1151 return 0; 1152} 1153 1154/* ******************************************************************** */ 1155 1156int usbvideo_v4l_initialize(struct video_device *dev) 1157{ 1158 return 0; 1159} 1160 1161long usbvideo_v4l_write(struct video_device *dev, const char *buf, 1162 unsigned long count, int noblock) 1163{ 1164 return -EINVAL; 1165} 1166 1167int usbvideo_v4l_mmap(struct video_device *dev, const char *adr, unsigned long size) 1168{ 1169 struct uvd *uvd = (struct uvd *) dev; 1170 unsigned long start = (unsigned long) adr; 1171 unsigned long page, pos; 1172 1173 if (!CAMERA_IS_OPERATIONAL(uvd)) 1174 return -EFAULT; 1175 1176 if (size > (((USBVIDEO_NUMFRAMES * uvd->max_frame_size) + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1))) 1177 return -EINVAL; 1178 1179 pos = (unsigned long) uvd->fbuf; 1180 while (size > 0) { 1181 page = usbvideo_kvirt_to_pa(pos); 1182 if (remap_page_range(start, page, PAGE_SIZE, PAGE_SHARED)) 1183 return -EAGAIN; 1184 1185 start += PAGE_SIZE; 1186 pos += PAGE_SIZE; 1187 if (size > PAGE_SIZE) 1188 size -= PAGE_SIZE; 1189 else 1190 size = 0; 1191 } 1192 1193 return 0; 1194} 1195 1196/* 1197 * usbvideo_v4l_open() 1198 * 1199 * This is part of Video 4 Linux API. The driver can be opened by one 1200 * client only (checks internal counter 'uvdser'). The procedure 1201 * then allocates buffers needed for video processing. 1202 * 1203 * History: 1204 * 22-Jan-2000 Rewrote, moved scratch buffer allocation here. Now the 1205 * camera is also initialized here (once per connect), at 1206 * expense of V4L client (it waits on open() call). 1207 * 27-Jan-2000 Used USBVIDEO_NUMSBUF as number of URB buffers. 1208 * 24-May-2000 Corrected to prevent race condition (MOD_xxx_USE_COUNT). 1209 */ 1210int usbvideo_v4l_open(struct video_device *dev, int flags) 1211{ 1212 struct uvd *uvd = (struct uvd *) dev; 1213 const int sb_size = FRAMES_PER_DESC * uvd->iso_packet_len; 1214 int i, errCode = 0; 1215 1216 if (uvd->debug > 1) 1217 info("%s($%p,$%08x", __FUNCTION__, dev, flags); 1218 1219 usbvideo_ClientIncModCount(uvd); 1220 down(&uvd->lock); 1221 1222 if (uvd->user) { 1223 err("%s: Someone tried to open an already opened device!", __FUNCTION__); 1224 errCode = -EBUSY; 1225 } else { 1226 /* Clear statistics */ 1227 memset(&uvd->stats, 0, sizeof(uvd->stats)); 1228 1229 /* Clean pointers so we know if we allocated something */ 1230 for (i=0; i < USBVIDEO_NUMSBUF; i++) 1231 uvd->sbuf[i].data = NULL; 1232 1233 /* Allocate memory for the frame buffers */ 1234 uvd->fbuf_size = USBVIDEO_NUMFRAMES * uvd->max_frame_size; 1235 uvd->fbuf = usbvideo_rvmalloc(uvd->fbuf_size); 1236 RingQueue_Allocate(&uvd->dp, RING_QUEUE_SIZE); 1237 if ((uvd->fbuf == NULL) || 1238 (!RingQueue_IsAllocated(&uvd->dp))) { 1239 err("%s: Failed to allocate fbuf or dp", __FUNCTION__); 1240 errCode = -ENOMEM; 1241 } else { 1242 /* Allocate all buffers */ 1243 for (i=0; i < USBVIDEO_NUMFRAMES; i++) { 1244 uvd->frame[i].frameState = FrameState_Unused; 1245 uvd->frame[i].data = uvd->fbuf + i*(uvd->max_frame_size); 1246 /* 1247 * Set default sizes in case IOCTL (VIDIOCMCAPTURE) 1248 * is not used (using read() instead). 1249 */ 1250 uvd->frame[i].canvas = uvd->canvas; 1251 uvd->frame[i].seqRead_Index = 0; 1252 } 1253 for (i=0; i < USBVIDEO_NUMSBUF; i++) { 1254 uvd->sbuf[i].data = kmalloc(sb_size, GFP_KERNEL); 1255 if (uvd->sbuf[i].data == NULL) { 1256 errCode = -ENOMEM; 1257 break; 1258 } 1259 } 1260 } 1261 if (errCode != 0) { 1262 /* Have to free all that memory */ 1263 if (uvd->fbuf != NULL) { 1264 usbvideo_rvfree(uvd->fbuf, uvd->fbuf_size); 1265 uvd->fbuf = NULL; 1266 } 1267 RingQueue_Free(&uvd->dp); 1268 for (i=0; i < USBVIDEO_NUMSBUF; i++) { 1269 if (uvd->sbuf[i].data != NULL) { 1270 kfree (uvd->sbuf[i].data); 1271 uvd->sbuf[i].data = NULL; 1272 } 1273 } 1274 } 1275 } 1276 1277 /* If so far no errors then we shall start the camera */ 1278 if (errCode == 0) { 1279 /* Start data pump if we have valid endpoint */ 1280 if (uvd->video_endp != 0) 1281 errCode = GET_CALLBACK(uvd, startDataPump)(uvd); 1282 if (errCode == 0) { 1283 if (VALID_CALLBACK(uvd, setupOnOpen)) { 1284 if (uvd->debug > 1) 1285 info("%s: setupOnOpen callback", __FUNCTION__); 1286 errCode = GET_CALLBACK(uvd, setupOnOpen)(uvd); 1287 if (errCode < 0) { 1288 err("%s: setupOnOpen callback failed (%d.).", 1289 __FUNCTION__, errCode); 1290 } else if (uvd->debug > 1) { 1291 info("%s: setupOnOpen callback successful", __FUNCTION__); 1292 } 1293 } 1294 if (errCode == 0) { 1295 uvd->settingsAdjusted = 0; 1296 if (uvd->debug > 1) 1297 info("%s: Open succeeded.", __FUNCTION__); 1298 uvd->user++; 1299 } 1300 } 1301 } 1302 up(&uvd->lock); 1303 if (errCode != 0) 1304 usbvideo_ClientDecModCount(uvd); 1305 if (uvd->debug > 0) 1306 info("%s: Returning %d.", __FUNCTION__, errCode); 1307 return errCode; 1308} 1309 1310/* 1311 * usbvideo_v4l_close() 1312 * 1313 * This is part of Video 4 Linux API. The procedure 1314 * stops streaming and deallocates all buffers that were earlier 1315 * allocated in usbvideo_v4l_open(). 1316 * 1317 * History: 1318 * 22-Jan-2000 Moved scratch buffer deallocation here. 1319 * 27-Jan-2000 Used USBVIDEO_NUMSBUF as number of URB buffers. 1320 * 24-May-2000 Moved MOD_DEC_USE_COUNT outside of code that can sleep. 1321 */ 1322void usbvideo_v4l_close(struct video_device *dev) 1323{ 1324 struct uvd *uvd = (struct uvd *)dev; 1325 int i; 1326 1327 if (uvd->debug > 1) 1328 info("%s($%p)", __FUNCTION__, dev); 1329 1330 down(&uvd->lock); 1331 GET_CALLBACK(uvd, stopDataPump)(uvd); 1332 usbvideo_rvfree(uvd->fbuf, uvd->fbuf_size); 1333 uvd->fbuf = NULL; 1334 RingQueue_Free(&uvd->dp); 1335 1336 for (i=0; i < USBVIDEO_NUMSBUF; i++) { 1337 kfree(uvd->sbuf[i].data); 1338 uvd->sbuf[i].data = NULL; 1339 } 1340 1341#if USBVIDEO_REPORT_STATS 1342 usbvideo_ReportStatistics(uvd); 1343#endif 1344 1345 uvd->user--; 1346 if (uvd->remove_pending) { 1347 if (uvd->debug > 0) 1348 info("usbvideo_v4l_close: Final disconnect."); 1349 usbvideo_CameraRelease(uvd); 1350 } 1351 up(&uvd->lock); 1352 usbvideo_ClientDecModCount(uvd); 1353 1354 if (uvd->debug > 1) 1355 info("%s: Completed.", __FUNCTION__); 1356} 1357 1358/* 1359 * usbvideo_v4l_ioctl() 1360 * 1361 * This is part of Video 4 Linux API. The procedure handles ioctl() calls. 1362 * 1363 * History: 1364 * 22-Jan-2000 Corrected VIDIOCSPICT to reject unsupported settings. 1365 */ 1366int usbvideo_v4l_ioctl(struct video_device *dev, unsigned int cmd, void *arg) 1367{ 1368 struct uvd *uvd = (struct uvd *)dev; 1369 1370 if (!CAMERA_IS_OPERATIONAL(uvd)) 1371 return -EFAULT; 1372 1373 switch (cmd) { 1374 case VIDIOCGCAP: 1375 { 1376 if (copy_to_user(arg, &uvd->vcap, sizeof(uvd->vcap))) 1377 return -EFAULT; 1378 return 0; 1379 } 1380 case VIDIOCGCHAN: 1381 { 1382 if (copy_to_user(arg, &uvd->vchan, sizeof(uvd->vchan))) 1383 return -EFAULT; 1384 return 0; 1385 } 1386 case VIDIOCSCHAN: 1387 { /* Not used but we return success */ 1388 int v; 1389 if (copy_from_user(&v, arg, sizeof(v))) 1390 return -EFAULT; 1391 return 0; 1392 } 1393 case VIDIOCGPICT: 1394 { 1395 if (copy_to_user(arg, &uvd->vpic, sizeof(uvd->vpic))) 1396 return -EFAULT; 1397 return 0; 1398 } 1399 case VIDIOCSPICT: 1400 { 1401 struct video_picture tmp; 1402 /* 1403 * Use temporary 'video_picture' structure to preserve our 1404 * own settings (such as color depth, palette) that we 1405 * aren't allowing everyone (V4L client) to change. 1406 */ 1407 if (copy_from_user(&tmp, arg, sizeof(tmp))) 1408 return -EFAULT; 1409 uvd->vpic.brightness = tmp.brightness; 1410 uvd->vpic.hue = tmp.hue; 1411 uvd->vpic.colour = tmp.colour; 1412 uvd->vpic.contrast = tmp.contrast; 1413 uvd->settingsAdjusted = 0; /* Will force new settings */ 1414 return 0; 1415 } 1416 case VIDIOCSWIN: 1417 { 1418 struct video_window vw; 1419 1420 if (copy_from_user(&vw, arg, sizeof(vw))) 1421 return -EFAULT; 1422 if (VALID_CALLBACK(uvd, setVideoMode)) { 1423 return GET_CALLBACK(uvd, setVideoMode)(uvd, &vw); 1424 } 1425 if (vw.flags) 1426 return -EINVAL; 1427 if (vw.clipcount) 1428 return -EINVAL; 1429 if (vw.width != VIDEOSIZE_X(uvd->canvas)) 1430 return -EINVAL; 1431 if (vw.height != VIDEOSIZE_Y(uvd->canvas)) 1432 return -EINVAL; 1433 1434 return 0; 1435 } 1436 case VIDIOCGWIN: 1437 { 1438 struct video_window vw; 1439 1440 vw.x = 0; 1441 vw.y = 0; 1442 vw.width = VIDEOSIZE_X(uvd->videosize); 1443 vw.height = VIDEOSIZE_Y(uvd->videosize); 1444 vw.chromakey = 0; 1445 if (VALID_CALLBACK(uvd, getFPS)) 1446 vw.flags = GET_CALLBACK(uvd, getFPS)(uvd); 1447 else 1448 vw.flags = 10; /* FIXME: do better! */ 1449 1450 if (copy_to_user(arg, &vw, sizeof(vw))) 1451 return -EFAULT; 1452 1453 return 0; 1454 } 1455 case VIDIOCGMBUF: 1456 { 1457 struct video_mbuf vm; 1458 int i; 1459 1460 memset(&vm, 0, sizeof(vm)); 1461 vm.size = uvd->max_frame_size * USBVIDEO_NUMFRAMES; 1462 vm.frames = USBVIDEO_NUMFRAMES; 1463 for(i = 0; i < USBVIDEO_NUMFRAMES; i++) 1464 vm.offsets[i] = i * uvd->max_frame_size; 1465 1466 if (copy_to_user((void *)arg, (void *)&vm, sizeof(vm))) 1467 return -EFAULT; 1468 1469 return 0; 1470 } 1471 case VIDIOCMCAPTURE: 1472 { 1473 struct video_mmap vm; 1474 1475 if (copy_from_user((void *)&vm, (void *)arg, sizeof(vm))) { 1476 err("VIDIOCMCAPTURE: copy_from_user() failed."); 1477 return -EFAULT; 1478 } 1479 if (uvd->debug >= 1) { 1480 info("VIDIOCMCAPTURE: frame=%d. size=%dx%d, format=%d.", 1481 vm.frame, vm.width, vm.height, vm.format); 1482 } 1483 /* 1484 * Check if the requested size is supported. If the requestor 1485 * requests too big a frame then we may be tricked into accessing 1486 * outside of own preallocated frame buffer (in uvd->frame). 1487 * This will cause oops or a security hole. Theoretically, we 1488 * could only clamp the size down to acceptable bounds, but then 1489 * we'd need to figure out how to insert our smaller buffer into 1490 * larger caller's buffer... this is not an easy question. So we 1491 * here just flatly reject too large requests, assuming that the 1492 * caller will resubmit with smaller size. Callers should know 1493 * what size we support (returned by VIDIOCGCAP). However vidcat, 1494 * for one, does not care and allows to ask for any size. 1495 */ 1496 if ((vm.width > VIDEOSIZE_X(uvd->canvas)) || 1497 (vm.height > VIDEOSIZE_Y(uvd->canvas))) { 1498 if (uvd->debug > 0) { 1499 info("VIDIOCMCAPTURE: Size=%dx%d too large; " 1500 "allowed only up to %ldx%ld", vm.width, vm.height, 1501 VIDEOSIZE_X(uvd->canvas), VIDEOSIZE_Y(uvd->canvas)); 1502 } 1503 return -EINVAL; 1504 } 1505 /* Check if the palette is supported */ 1506 if (((1L << vm.format) & uvd->paletteBits) == 0) { 1507 if (uvd->debug > 0) { 1508 info("VIDIOCMCAPTURE: format=%d. not supported" 1509 " (paletteBits=$%08lx)", 1510 vm.format, uvd->paletteBits); 1511 } 1512 return -EINVAL; 1513 } 1514 if ((vm.frame < 0) && (vm.frame >= USBVIDEO_NUMFRAMES)) { 1515 err("VIDIOCMCAPTURE: vm.frame=%d. !E [0-%d]", vm.frame, USBVIDEO_NUMFRAMES-1); 1516 return -EINVAL; 1517 } 1518 if (uvd->frame[vm.frame].frameState == FrameState_Grabbing) { 1519 /* Not an error - can happen */ 1520 } 1521 uvd->frame[vm.frame].request = VIDEOSIZE(vm.width, vm.height); 1522 uvd->frame[vm.frame].palette = vm.format; 1523 1524 /* Mark it as ready */ 1525 uvd->frame[vm.frame].frameState = FrameState_Ready; 1526 1527 return usbvideo_NewFrame(uvd, vm.frame); 1528 } 1529 case VIDIOCSYNC: 1530 { 1531 int frameNum, ret; 1532 1533 if (copy_from_user((void *)&frameNum, arg, sizeof(frameNum))) { 1534 err("VIDIOCSYNC: copy_from_user() failed."); 1535 return -EFAULT; 1536 } 1537 if(frameNum < 0 || frameNum >= USBVIDEO_NUMFRAMES) 1538 return -EINVAL; 1539 1540 if (uvd->debug >= 1) 1541 info("VIDIOCSYNC: syncing to frame %d.", frameNum); 1542 if (uvd->flags & FLAGS_NO_DECODING) 1543 ret = usbvideo_GetFrame(uvd, frameNum); 1544 else if (VALID_CALLBACK(uvd, getFrame)) { 1545 ret = GET_CALLBACK(uvd, getFrame)(uvd, frameNum); 1546 if ((ret < 0) && (uvd->debug >= 1)) { 1547 err("VIDIOCSYNC: getFrame() returned %d.", ret); 1548 } 1549 } else { 1550 err("VIDIOCSYNC: getFrame is not set"); 1551 ret = -EFAULT; 1552 } 1553 1554 /* 1555 * The frame is in FrameState_Done_Hold state. Release it 1556 * right now because its data is already mapped into 1557 * the user space and it's up to the application to 1558 * make use of it until it asks for another frame. 1559 */ 1560 uvd->frame[frameNum].frameState = FrameState_Unused; 1561 return ret; 1562 } 1563 case VIDIOCGFBUF: 1564 { 1565 struct video_buffer vb; 1566 1567 memset(&vb, 0, sizeof(vb)); 1568 vb.base = NULL; /* frame buffer not supported, not used */ 1569 1570 if (copy_to_user((void *)arg, (void *)&vb, sizeof(vb))) 1571 return -EFAULT; 1572 1573 return 0; 1574 } 1575 case VIDIOCKEY: 1576 return 0; 1577 1578 case VIDIOCCAPTURE: 1579 return -EINVAL; 1580 1581 case VIDIOCSFBUF: 1582 1583 case VIDIOCGTUNER: 1584 case VIDIOCSTUNER: 1585 1586 case VIDIOCGFREQ: 1587 case VIDIOCSFREQ: 1588 1589 case VIDIOCGAUDIO: 1590 case VIDIOCSAUDIO: 1591 return -EINVAL; 1592 1593 default: 1594 return -ENOIOCTLCMD; 1595 } 1596 return 0; 1597} 1598 1599/* 1600 * usbvideo_v4l_read() 1601 * 1602 * This is mostly boring stuff. We simply ask for a frame and when it 1603 * arrives copy all the video data from it into user space. There is 1604 * no obvious need to override this method. 1605 * 1606 * History: 1607 * 20-Oct-2000 Created. 1608 * 01-Nov-2000 Added mutex (uvd->lock). 1609 */ 1610long usbvideo_v4l_read(struct video_device *dev, char *buf, unsigned long count, int noblock) 1611{ 1612 struct uvd *uvd = (struct uvd *) dev; 1613 int frmx = -1, i; 1614 struct usbvideo_frame *frame; 1615 1616 if (!CAMERA_IS_OPERATIONAL(uvd) || (buf == NULL)) 1617 return -EFAULT; 1618 1619 if (uvd->debug >= 1) 1620 info("%s: %ld. bytes, noblock=%d.", __FUNCTION__, count, noblock); 1621 1622 down(&uvd->lock); 1623 1624 /* See if a frame is completed, then use it. */ 1625 for(i = 0; i < USBVIDEO_NUMFRAMES; i++) { 1626 if ((uvd->frame[i].frameState == FrameState_Done) || 1627 (uvd->frame[i].frameState == FrameState_Done_Hold) || 1628 (uvd->frame[i].frameState == FrameState_Error)) { 1629 frmx = i; 1630 break; 1631 } 1632 } 1633 1634 /* FIXME: If we don't start a frame here then who ever does? */ 1635 if (noblock && (frmx == -1)) { 1636 count = -EAGAIN; 1637 goto read_done; 1638 } 1639 1640 /* 1641 * If no FrameState_Done, look for a FrameState_Grabbing state. 1642 * See if a frame is in process (grabbing), then use it. 1643 * We will need to wait until it becomes cooked, of course. 1644 */ 1645 if (frmx == -1) { 1646 for(i = 0; i < USBVIDEO_NUMFRAMES; i++) { 1647 if (uvd->frame[i].frameState == FrameState_Grabbing) { 1648 frmx = i; 1649 break; 1650 } 1651 } 1652 } 1653 1654 /* 1655 * If no frame is active, start one. We don't care which one 1656 * it will be, so #0 is as good as any. 1657 * In read access mode we don't have convenience of VIDIOCMCAPTURE 1658 * to specify the requested palette (video format) on per-frame 1659 * basis. This means that we have to return data in -some- format 1660 * and just hope that the client knows what to do with it. 1661 * The default format is configured in uvd->defaultPalette field 1662 * as one of VIDEO_PALETTE_xxx values. We stuff it into the new 1663 * frame and initiate the frame filling process. 1664 */ 1665 if (frmx == -1) { 1666 if (uvd->defaultPalette == 0) { 1667 err("%s: No default palette; don't know what to do!", __FUNCTION__); 1668 count = -EFAULT; 1669 goto read_done; 1670 } 1671 frmx = 0; 1672 /* 1673 * We have no per-frame control over video size. 1674 * Therefore we only can use whatever size was 1675 * specified as default. 1676 */ 1677 uvd->frame[frmx].request = uvd->videosize; 1678 uvd->frame[frmx].palette = uvd->defaultPalette; 1679 uvd->frame[frmx].frameState = FrameState_Ready; 1680 usbvideo_NewFrame(uvd, frmx); 1681 /* Now frame 0 is supposed to start filling... */ 1682 } 1683 1684 /* 1685 * Get a pointer to the active frame. It is either previously 1686 * completed frame or frame in progress but not completed yet. 1687 */ 1688 frame = &uvd->frame[frmx]; 1689 1690 /* 1691 * Sit back & wait until the frame gets filled and postprocessed. 1692 * If we fail to get the picture [in time] then return the error. 1693 * In this call we specify that we want the frame to be waited for, 1694 * postprocessed and switched into FrameState_Done_Hold state. This 1695 * state is used to hold the frame as "fully completed" between 1696 * subsequent partial reads of the same frame. 1697 */ 1698 if (frame->frameState != FrameState_Done_Hold) { 1699 long rv = -EFAULT; 1700 if (uvd->flags & FLAGS_NO_DECODING) 1701 rv = usbvideo_GetFrame(uvd, frmx); 1702 else if (VALID_CALLBACK(uvd, getFrame)) 1703 rv = GET_CALLBACK(uvd, getFrame)(uvd, frmx); 1704 else 1705 err("getFrame is not set"); 1706 if ((rv != 0) || (frame->frameState != FrameState_Done_Hold)) { 1707 count = rv; 1708 goto read_done; 1709 } 1710 } 1711 1712 /* 1713 * Copy bytes to user space. We allow for partial reads, which 1714 * means that the user application can request read less than 1715 * the full frame size. It is up to the application to issue 1716 * subsequent calls until entire frame is read. 1717 * 1718 * First things first, make sure we don't copy more than we 1719 * have - even if the application wants more. That would be 1720 * a big security embarassment! 1721 */ 1722 1723 if (count + frame->seqRead_Index < count) 1724 { 1725 count = -EINVAL; 1726 goto read_done; 1727 } 1728 if ((count + frame->seqRead_Index) > frame->seqRead_Length) 1729 count = frame->seqRead_Length - frame->seqRead_Index; 1730 1731 /* 1732 * Copy requested amount of data to user space. We start 1733 * copying from the position where we last left it, which 1734 * will be zero for a new frame (not read before). 1735 */ 1736 if (copy_to_user(buf, frame->data + frame->seqRead_Index, count)) { 1737 count = -EFAULT; 1738 goto read_done; 1739 } 1740 1741 /* Update last read position */ 1742 frame->seqRead_Index += count; 1743 if (uvd->debug >= 1) { 1744 err("%s: {copy} count used=%ld, new seqRead_Index=%ld", 1745 __FUNCTION__, count, frame->seqRead_Index); 1746 } 1747 1748 /* Finally check if the frame is done with and "release" it */ 1749 if (frame->seqRead_Index >= frame->seqRead_Length) { 1750 /* All data has been read */ 1751 frame->seqRead_Index = 0; 1752 1753 /* Mark it as available to be used again. */ 1754 uvd->frame[frmx].frameState = FrameState_Unused; 1755 if (usbvideo_NewFrame(uvd, (frmx + 1) % USBVIDEO_NUMFRAMES)) { 1756 err("%s: usbvideo_NewFrame failed.", __FUNCTION__); 1757 } 1758 } 1759read_done: 1760 up(&uvd->lock); 1761 return count; 1762} 1763 1764/* 1765 * Make all of the blocks of data contiguous 1766 */ 1767static int usbvideo_CompressIsochronous(struct uvd *uvd, struct urb *urb) 1768{ 1769 char *cdata; 1770 int i, totlen = 0; 1771 1772 for (i = 0; i < urb->number_of_packets; i++) { 1773 int n = urb->iso_frame_desc[i].actual_length; 1774 int st = urb->iso_frame_desc[i].status; 1775 1776 cdata = urb->transfer_buffer + urb->iso_frame_desc[i].offset; 1777 1778 /* Detect and ignore errored packets */ 1779 if (st < 0) { 1780 if (uvd->debug >= 1) 1781 err("Data error: packet=%d. len=%d. status=%d.", i, n, st); 1782 uvd->stats.iso_err_count++; 1783 continue; 1784 } 1785 1786 /* Detect and ignore empty packets */ 1787 if (n <= 0) { 1788 uvd->stats.iso_skip_count++; 1789 continue; 1790 } 1791 totlen += n; /* Little local accounting */ 1792 RingQueue_Enqueue(&uvd->dp, cdata, n); 1793 } 1794 return totlen; 1795} 1796 1797static void usbvideo_IsocIrq(struct urb *urb) 1798{ 1799 int i, len; 1800 struct uvd *uvd = urb->context; 1801 1802 /* We don't want to do anything if we are about to be removed! */ 1803 if (!CAMERA_IS_OPERATIONAL(uvd)) 1804 return; 1805#if 0 1806 if (urb->actual_length > 0) { 1807 info("urb=$%p status=%d. errcount=%d. length=%d.", 1808 urb, urb->status, urb->error_count, urb->actual_length); 1809 } else { 1810 static int c = 0; 1811 if (c++ % 100 == 0) 1812 info("No Isoc data"); 1813 } 1814#endif 1815 1816 if (!uvd->streaming) { 1817 if (uvd->debug >= 1) 1818 info("Not streaming, but interrupt!"); 1819 return; 1820 } 1821 1822 uvd->stats.urb_count++; 1823 if (urb->actual_length <= 0) 1824 goto urb_done_with; 1825 1826 /* Copy the data received into ring queue */ 1827 len = usbvideo_CompressIsochronous(uvd, urb); 1828 uvd->stats.urb_length = len; 1829 if (len <= 0) 1830 goto urb_done_with; 1831 1832 /* Here we got some data */ 1833 uvd->stats.data_count += len; 1834 RingQueue_WakeUpInterruptible(&uvd->dp); 1835 1836urb_done_with: 1837 for (i = 0; i < FRAMES_PER_DESC; i++) { 1838 urb->iso_frame_desc[i].status = 0; 1839 urb->iso_frame_desc[i].actual_length = 0; 1840 } 1841 return; 1842} 1843 1844/* 1845 * usbvideo_StartDataPump() 1846 * 1847 * History: 1848 * 27-Jan-2000 Used ibmcam->iface, ibmcam->ifaceAltActive instead 1849 * of hardcoded values. Simplified by using for loop, 1850 * allowed any number of URBs. 1851 */ 1852int usbvideo_StartDataPump(struct uvd *uvd) 1853{ 1854 struct usb_device *dev = uvd->dev; 1855 int i, errFlag; 1856 1857 if (uvd->debug > 1) 1858 info("%s($%p)", __FUNCTION__, uvd); 1859 1860 if (!CAMERA_IS_OPERATIONAL(uvd)) { 1861 err("%s: Camera is not operational", __FUNCTION__); 1862 return -EFAULT; 1863 } 1864 uvd->curframe = -1; 1865 1866 /* Alternate interface 1 is is the biggest frame size */ 1867 i = usb_set_interface(dev, uvd->iface, uvd->ifaceAltActive); 1868 if (i < 0) { 1869 err("%s: usb_set_interface error", __FUNCTION__); 1870 uvd->last_error = i; 1871 return -EBUSY; 1872 } 1873 if (VALID_CALLBACK(uvd, videoStart)) 1874 GET_CALLBACK(uvd, videoStart)(uvd); 1875 else 1876 err("%s: videoStart not set", __FUNCTION__); 1877 1878 /* We double buffer the Iso lists */ 1879 for (i=0; i < USBVIDEO_NUMSBUF; i++) { 1880 int j, k; 1881 struct urb *urb = uvd->sbuf[i].urb; 1882 urb->dev = dev; 1883 urb->context = uvd; 1884 urb->pipe = usb_rcvisocpipe(dev, uvd->video_endp); 1885 urb->transfer_flags = USB_ISO_ASAP; 1886 urb->transfer_buffer = uvd->sbuf[i].data; 1887 urb->complete = usbvideo_IsocIrq; 1888 urb->number_of_packets = FRAMES_PER_DESC; 1889 urb->transfer_buffer_length = uvd->iso_packet_len * FRAMES_PER_DESC; 1890 for (j=k=0; j < FRAMES_PER_DESC; j++, k += uvd->iso_packet_len) { 1891 urb->iso_frame_desc[j].offset = k; 1892 urb->iso_frame_desc[j].length = uvd->iso_packet_len; 1893 } 1894 } 1895 1896 /* Link URBs into a ring so that they invoke each other infinitely */ 1897 for (i=0; i < USBVIDEO_NUMSBUF; i++) { 1898 if ((i+1) < USBVIDEO_NUMSBUF) 1899 uvd->sbuf[i].urb->next = uvd->sbuf[i+1].urb; 1900 else 1901 uvd->sbuf[i].urb->next = uvd->sbuf[0].urb; 1902 } 1903 1904 /* Submit all URBs */ 1905 for (i=0; i < USBVIDEO_NUMSBUF; i++) { 1906 errFlag = usb_submit_urb(uvd->sbuf[i].urb); 1907 if (errFlag) 1908 err("%s: usb_submit_isoc(%d) ret %d", __FUNCTION__, i, errFlag); 1909 } 1910 1911 uvd->streaming = 1; 1912 if (uvd->debug > 1) 1913 info("%s: streaming=1 video_endp=$%02x", __FUNCTION__, uvd->video_endp); 1914 return 0; 1915} 1916 1917/* 1918 * usbvideo_StopDataPump() 1919 * 1920 * This procedure stops streaming and deallocates URBs. Then it 1921 * activates zero-bandwidth alt. setting of the video interface. 1922 * 1923 * History: 1924 * 22-Jan-2000 Corrected order of actions to work after surprise removal. 1925 * 27-Jan-2000 Used uvd->iface, uvd->ifaceAltInactive instead of hardcoded values. 1926 */ 1927void usbvideo_StopDataPump(struct uvd *uvd) 1928{ 1929 int i, j; 1930 1931 if (uvd->debug > 1) 1932 info("%s($%p)", __FUNCTION__, uvd); 1933 1934 if ((uvd == NULL) || (!uvd->streaming) || (uvd->dev == NULL)) 1935 return; 1936 1937 /* Unschedule all of the iso td's */ 1938 for (i=0; i < USBVIDEO_NUMSBUF; i++) { 1939 j = usb_unlink_urb(uvd->sbuf[i].urb); 1940 if (j < 0) 1941 err("%s: usb_unlink_urb() error %d.", __FUNCTION__, j); 1942 } 1943 if (uvd->debug > 1) 1944 info("%s: streaming=0", __FUNCTION__); 1945 uvd->streaming = 0; 1946 1947 if (!uvd->remove_pending) { 1948 /* Invoke minidriver's magic to stop the camera */ 1949 if (VALID_CALLBACK(uvd, videoStop)) 1950 GET_CALLBACK(uvd, videoStop)(uvd); 1951 else 1952 err("%s: videoStop not set", __FUNCTION__); 1953 1954 /* Set packet size to 0 */ 1955 j = usb_set_interface(uvd->dev, uvd->iface, uvd->ifaceAltInactive); 1956 if (j < 0) { 1957 err("%s: usb_set_interface() error %d.", __FUNCTION__, j); 1958 uvd->last_error = j; 1959 } 1960 } 1961} 1962 1963/* 1964 * usbvideo_NewFrame() 1965 * 1966 * History: 1967 * 29-Mar-00 Added copying of previous frame into the current one. 1968 * 6-Aug-00 Added model 3 video sizes, removed redundant width, height. 1969 */ 1970int usbvideo_NewFrame(struct uvd *uvd, int framenum) 1971{ 1972 struct usbvideo_frame *frame; 1973 int n; 1974 1975 if (uvd->debug > 1) 1976 info("usbvideo_NewFrame($%p,%d.)", uvd, framenum); 1977 1978 /* If we're not grabbing a frame right now and the other frame is */ 1979 /* ready to be grabbed into, then use it instead */ 1980 if (uvd->curframe != -1) 1981 return 0; 1982 1983 /* If necessary we adjust picture settings between frames */ 1984 if (!uvd->settingsAdjusted) { 1985 if (VALID_CALLBACK(uvd, adjustPicture)) 1986 GET_CALLBACK(uvd, adjustPicture)(uvd); 1987 uvd->settingsAdjusted = 1; 1988 } 1989 1990 n = (framenum + 1) % USBVIDEO_NUMFRAMES; 1991 if (uvd->frame[n].frameState == FrameState_Ready) 1992 framenum = n; 1993 1994 frame = &uvd->frame[framenum]; 1995 1996 frame->frameState = FrameState_Grabbing; 1997 frame->scanstate = ScanState_Scanning; 1998 frame->seqRead_Length = 0; /* Accumulated in xxx_parse_data() */ 1999 frame->deinterlace = Deinterlace_None; 2000 frame->flags = 0; /* No flags yet, up to minidriver (or us) to set them */ 2001 uvd->curframe = framenum; 2002 2003 /* 2004 * Normally we would want to copy previous frame into the current one 2005 * before we even start filling it with data; this allows us to stop 2006 * filling at any moment; top portion of the frame will be new and 2007 * bottom portion will stay as it was in previous frame. If we don't 2008 * do that then missing chunks of video stream will result in flickering 2009 * portions of old data whatever it was before. 2010 * 2011 * If we choose not to copy previous frame (to, for example, save few 2012 * bus cycles - the frame can be pretty large!) then we have an option 2013 * to clear the frame before using. If we experience losses in this 2014 * mode then missing picture will be black (no flickering). 2015 * 2016 * Finally, if user chooses not to clean the current frame before 2017 * filling it with data then the old data will be visible if we fail 2018 * to refill entire frame with new data. 2019 */ 2020 if (!(uvd->flags & FLAGS_SEPARATE_FRAMES)) { 2021 /* This copies previous frame into this one to mask losses */ 2022 int prev = (framenum - 1 + USBVIDEO_NUMFRAMES) % USBVIDEO_NUMFRAMES; 2023 memmove(frame->data, uvd->frame[prev].data, uvd->max_frame_size); 2024 } else { 2025 if (uvd->flags & FLAGS_CLEAN_FRAMES) { 2026 /* This provides a "clean" frame but slows things down */ 2027 memset(frame->data, 0, uvd->max_frame_size); 2028 } 2029 } 2030 return 0; 2031} 2032 2033/* 2034 * usbvideo_CollectRawData() 2035 * 2036 * This procedure can be used instead of 'processData' callback if you 2037 * only want to dump the raw data from the camera into the output 2038 * device (frame buffer). You can look at it with V4L client, but the 2039 * image will be unwatchable. The main purpose of this code and of the 2040 * mode FLAGS_NO_DECODING is debugging and capturing of datastreams from 2041 * new, unknown cameras. This procedure will be automatically invoked 2042 * instead of the specified callback handler when uvd->flags has bit 2043 * FLAGS_NO_DECODING set. Therefore, any regular build of any driver 2044 * based on usbvideo can use this feature at any time. 2045 */ 2046void usbvideo_CollectRawData(struct uvd *uvd, struct usbvideo_frame *frame) 2047{ 2048 int n; 2049 2050 assert(uvd != NULL); 2051 assert(frame != NULL); 2052 2053 /* Try to move data from queue into frame buffer */ 2054 n = RingQueue_GetLength(&uvd->dp); 2055 if (n > 0) { 2056 int m; 2057 /* See how much space we have left */ 2058 m = uvd->max_frame_size - frame->seqRead_Length; 2059 if (n > m) 2060 n = m; 2061 /* Now move that much data into frame buffer */ 2062 RingQueue_Dequeue( 2063 &uvd->dp, 2064 frame->data + frame->seqRead_Length, 2065 m); 2066 frame->seqRead_Length += m; 2067 } 2068 /* See if we filled the frame */ 2069 if (frame->seqRead_Length >= uvd->max_frame_size) { 2070 frame->frameState = FrameState_Done; 2071 uvd->curframe = -1; 2072 uvd->stats.frame_num++; 2073 } 2074} 2075 2076int usbvideo_GetFrame(struct uvd *uvd, int frameNum) 2077{ 2078 struct usbvideo_frame *frame = &uvd->frame[frameNum]; 2079 2080 if (uvd->debug >= 2) 2081 info("%s($%p,%d.)", __FUNCTION__, uvd, frameNum); 2082 2083 switch (frame->frameState) { 2084 case FrameState_Unused: 2085 if (uvd->debug >= 2) 2086 info("%s: FrameState_Unused", __FUNCTION__); 2087 return -EINVAL; 2088 case FrameState_Ready: 2089 case FrameState_Grabbing: 2090 case FrameState_Error: 2091 { 2092 int ntries, signalPending; 2093 redo: 2094 if (!CAMERA_IS_OPERATIONAL(uvd)) { 2095 if (uvd->debug >= 2) 2096 info("%s: Camera is not operational (1)", __FUNCTION__); 2097 return -EIO; 2098 } 2099 ntries = 0; 2100 do { 2101 RingQueue_InterruptibleSleepOn(&uvd->dp); 2102 signalPending = signal_pending(current); 2103 if (!CAMERA_IS_OPERATIONAL(uvd)) { 2104 if (uvd->debug >= 2) 2105 info("%s: Camera is not operational (2)", __FUNCTION__); 2106 return -EIO; 2107 } 2108 assert(uvd->fbuf != NULL); 2109 if (signalPending) { 2110 if (uvd->debug >= 2) 2111 info("%s: Signal=$%08x", __FUNCTION__, signalPending); 2112 if (uvd->flags & FLAGS_RETRY_VIDIOCSYNC) { 2113 usbvideo_TestPattern(uvd, 1, 0); 2114 uvd->curframe = -1; 2115 uvd->stats.frame_num++; 2116 if (uvd->debug >= 2) 2117 info("%s: Forced test pattern screen", __FUNCTION__); 2118 return 0; 2119 } else { 2120 /* Standard answer: Interrupted! */ 2121 if (uvd->debug >= 2) 2122 info("%s: Interrupted!", __FUNCTION__); 2123 return -EINTR; 2124 } 2125 } else { 2126 /* No signals - we just got new data in dp queue */ 2127 if (uvd->flags & FLAGS_NO_DECODING) 2128 usbvideo_CollectRawData(uvd, frame); 2129 else if (VALID_CALLBACK(uvd, processData)) 2130 GET_CALLBACK(uvd, processData)(uvd, frame); 2131 else 2132 err("%s: processData not set", __FUNCTION__); 2133 } 2134 } while (frame->frameState == FrameState_Grabbing); 2135 if (uvd->debug >= 2) { 2136 info("%s: Grabbing done; state=%d. (%lu. bytes)", 2137 __FUNCTION__, frame->frameState, frame->seqRead_Length); 2138 } 2139 if (frame->frameState == FrameState_Error) { 2140 int ret = usbvideo_NewFrame(uvd, frameNum); 2141 if (ret < 0) { 2142 err("%s: usbvideo_NewFrame() failed (%d.)", __FUNCTION__, ret); 2143 return ret; 2144 } 2145 goto redo; 2146 } 2147 /* Note that we fall through to meet our destiny below */ 2148 } 2149 case FrameState_Done: 2150 /* 2151 * Do all necessary postprocessing of data prepared in 2152 * "interrupt" code and the collecting code above. The 2153 * frame gets marked as FrameState_Done by queue parsing code. 2154 * This status means that we collected enough data and 2155 * most likely processed it as we went through. However 2156 * the data may need postprocessing, such as deinterlacing 2157 * or picture adjustments implemented in software (horror!) 2158 * 2159 * As soon as the frame becomes "final" it gets promoted to 2160 * FrameState_Done_Hold status where it will remain until the 2161 * caller consumed all the video data from the frame. Then 2162 * the empty shell of ex-frame is thrown out for dogs to eat. 2163 * But we, worried about pets, will recycle the frame! 2164 */ 2165 uvd->stats.frame_num++; 2166 if ((uvd->flags & FLAGS_NO_DECODING) == 0) { 2167 if (VALID_CALLBACK(uvd, postProcess)) 2168 GET_CALLBACK(uvd, postProcess)(uvd, frame); 2169 if (frame->flags & USBVIDEO_FRAME_FLAG_SOFTWARE_CONTRAST) 2170 usbvideo_SoftwareContrastAdjustment(uvd, frame); 2171 } 2172 frame->frameState = FrameState_Done_Hold; 2173 if (uvd->debug >= 2) 2174 info("%s: Entered FrameState_Done_Hold state.", __FUNCTION__); 2175 return 0; 2176 2177 case FrameState_Done_Hold: 2178 /* 2179 * We stay in this state indefinitely until someone external, 2180 * like ioctl() or read() call finishes digesting the frame 2181 * data. Then it will mark the frame as FrameState_Unused and 2182 * it will be released back into the wild to roam freely. 2183 */ 2184 if (uvd->debug >= 2) 2185 info("%s: FrameState_Done_Hold state.", __FUNCTION__); 2186 return 0; 2187 } 2188 2189 /* Catch-all for other cases. We shall not be here. */ 2190 err("%s: Invalid state %d.", __FUNCTION__, frame->frameState); 2191 frame->frameState = FrameState_Unused; 2192 return 0; 2193} 2194 2195/* 2196 * usbvideo_DeinterlaceFrame() 2197 * 2198 * This procedure deinterlaces the given frame. Some cameras produce 2199 * only half of scanlines - sometimes only even lines, sometimes only 2200 * odd lines. The deinterlacing method is stored in frame->deinterlace 2201 * variable. 2202 * 2203 * Here we scan the frame vertically and replace missing scanlines with 2204 * average between surrounding ones - before and after. If we have no 2205 * line above then we just copy next line. Similarly, if we need to 2206 * create a last line then preceding line is used. 2207 */ 2208void usbvideo_DeinterlaceFrame(struct uvd *uvd, struct usbvideo_frame *frame) 2209{ 2210 if ((uvd == NULL) || (frame == NULL)) 2211 return; 2212 2213 if ((frame->deinterlace == Deinterlace_FillEvenLines) || 2214 (frame->deinterlace == Deinterlace_FillOddLines)) 2215 { 2216 const int v4l_linesize = VIDEOSIZE_X(frame->request) * V4L_BYTES_PER_PIXEL; 2217 int i = (frame->deinterlace == Deinterlace_FillEvenLines) ? 0 : 1; 2218 2219 for (; i < VIDEOSIZE_Y(frame->request); i += 2) { 2220 const unsigned char *fs1, *fs2; 2221 unsigned char *fd; 2222 int ip, in, j; /* Previous and next lines */ 2223 2224 /* 2225 * Need to average lines before and after 'i'. 2226 * If we go out of bounds seeking those lines then 2227 * we point back to existing line. 2228 */ 2229 ip = i - 1; /* First, get rough numbers */ 2230 in = i + 1; 2231 2232 /* Now validate */ 2233 if (ip < 0) 2234 ip = in; 2235 if (in >= VIDEOSIZE_Y(frame->request)) 2236 in = ip; 2237 2238 /* Sanity check */ 2239 if ((ip < 0) || (in < 0) || 2240 (ip >= VIDEOSIZE_Y(frame->request)) || 2241 (in >= VIDEOSIZE_Y(frame->request))) 2242 { 2243 err("Error: ip=%d. in=%d. req.height=%ld.", 2244 ip, in, VIDEOSIZE_Y(frame->request)); 2245 break; 2246 } 2247 2248 /* Now we need to average lines 'ip' and 'in' to produce line 'i' */ 2249 fs1 = frame->data + (v4l_linesize * ip); 2250 fs2 = frame->data + (v4l_linesize * in); 2251 fd = frame->data + (v4l_linesize * i); 2252 2253 /* Average lines around destination */ 2254 for (j=0; j < v4l_linesize; j++) { 2255 fd[j] = (unsigned char)((((unsigned) fs1[j]) + 2256 ((unsigned)fs2[j])) >> 1); 2257 } 2258 } 2259 } 2260 2261 /* Optionally display statistics on the screen */ 2262 if (uvd->flags & FLAGS_OVERLAY_STATS) 2263 usbvideo_OverlayStats(uvd, frame); 2264} 2265 2266/* 2267 * usbvideo_SoftwareContrastAdjustment() 2268 * 2269 * This code adjusts the contrast of the frame, assuming RGB24 format. 2270 * As most software image processing, this job is CPU-intensive. 2271 * Get a camera that supports hardware adjustment! 2272 * 2273 * History: 2274 * 09-Feb-2001 Created. 2275 */ 2276void usbvideo_SoftwareContrastAdjustment(struct uvd *uvd, struct usbvideo_frame *frame) 2277{ 2278 int i, j, v4l_linesize; 2279 signed long adj; 2280 const int ccm = 128; /* Color correction median - see below */ 2281 2282 if ((uvd == NULL) || (frame == NULL)) { 2283 err("%s: Illegal call.", __FUNCTION__); 2284 return; 2285 } 2286 adj = (uvd->vpic.contrast - 0x8000) >> 8; /* -128..+127 = -ccm..+(ccm-1)*/ 2287 RESTRICT_TO_RANGE(adj, -ccm, ccm+1); 2288 if (adj == 0) { 2289 /* In rare case of no adjustment */ 2290 return; 2291 } 2292 v4l_linesize = VIDEOSIZE_X(frame->request) * V4L_BYTES_PER_PIXEL; 2293 for (i=0; i < VIDEOSIZE_Y(frame->request); i++) { 2294 unsigned char *fd = frame->data + (v4l_linesize * i); 2295 for (j=0; j < v4l_linesize; j++) { 2296 signed long v = (signed long) fd[j]; 2297 /* Magnify up to 2 times, reduce down to zero */ 2298 v = 128 + ((ccm + adj) * (v - 128)) / ccm; 2299 RESTRICT_TO_RANGE(v, 0, 0xFF); /* Must flatten tails */ 2300 fd[j] = (unsigned char) v; 2301 } 2302 } 2303} 2304 2305/* 2306 * /proc interface 2307 * 2308 * We will be creating directories and entries under /proc/video using 2309 * external 'video_proc_entry' directory which is exported by videodev.o 2310 * module. Within that directory we will create $driver/ directory to 2311 * uniquely and uniformly refer to our specific $driver. Within that 2312 * directory we will finally create an entry that is named after the 2313 * video device node - video3, for example. The format of that file 2314 * is determined by callbacks that the minidriver may provide. If no 2315 * callbacks are provided (neither read nor write) then we don't create 2316 * the entry. 2317 * 2318 * Here is a sample directory entry: /proc/video/ibmcam/video3 2319 * 2320 * The "file" video3 (in example above) is readable and writeable, in 2321 * theory. If the minidriver provides callbacks to do reading and 2322 * writing then both those procedures are supported. However if the 2323 * driver leaves callbacks in default (NULL) state the default 2324 * read and write handlers are used. The default read handler reports 2325 * that the driver does not support /proc fs. The default write handler 2326 * returns error code on any write attempt. 2327 */ 2328 2329#if USES_PROC_FS 2330 2331extern struct proc_dir_entry *video_proc_entry; 2332 2333static void usbvideo_procfs_level1_create(struct usbvideo *ut) 2334{ 2335 if (ut == NULL) { 2336 err("%s: ut == NULL", __FUNCTION__); 2337 return; 2338 } 2339 if (video_proc_entry == NULL) { 2340 err("%s: /proc/video/ doesn't exist.", __FUNCTION__); 2341 return; 2342 } 2343 ut->procfs_dEntry = create_proc_entry(ut->drvName, S_IFDIR, video_proc_entry); 2344 if (ut->procfs_dEntry != NULL) { 2345 if (ut->md_module != NULL) 2346 ut->procfs_dEntry->owner = ut->md_module; 2347 } else { 2348 err("%s: Unable to initialize /proc/video/%s", __FUNCTION__, ut->drvName); 2349 } 2350} 2351 2352static void usbvideo_procfs_level1_destroy(struct usbvideo *ut) 2353{ 2354 if (ut == NULL) { 2355 err("%s: ut == NULL", __FUNCTION__); 2356 return; 2357 } 2358 if (ut->procfs_dEntry != NULL) { 2359 remove_proc_entry(ut->drvName, video_proc_entry); 2360 ut->procfs_dEntry = NULL; 2361 } 2362} 2363 2364static void usbvideo_procfs_level2_create(struct uvd *uvd) 2365{ 2366 if (uvd == NULL) { 2367 err("%s: uvd == NULL", __FUNCTION__); 2368 return; 2369 } 2370 assert(uvd->handle != NULL); 2371 if (uvd->handle->procfs_dEntry == NULL) { 2372 err("%s: uvd->handle->procfs_dEntry == NULL", __FUNCTION__); 2373 return; 2374 } 2375 2376 sprintf(uvd->videoName, "video%d", uvd->vdev.minor); 2377 uvd->procfs_vEntry = create_proc_entry( 2378 uvd->videoName, 2379 S_IFREG | S_IRUGO | S_IWUSR, 2380 uvd->handle->procfs_dEntry); 2381 if (uvd->procfs_vEntry != NULL) { 2382 uvd->procfs_vEntry->data = uvd; 2383 uvd->procfs_vEntry->read_proc = uvd->handle->cb.procfs_read; 2384 uvd->procfs_vEntry->write_proc = uvd->handle->cb.procfs_write; 2385 } else { 2386 err("%s: Failed to create entry \"%s\"", __FUNCTION__, uvd->videoName); 2387 } 2388} 2389 2390static void usbvideo_procfs_level2_destroy(struct uvd *uvd) 2391{ 2392 if (uvd == NULL) { 2393 err("%s: uvd == NULL", __FUNCTION__); 2394 return; 2395 } 2396 if (uvd->procfs_vEntry != NULL) { 2397 remove_proc_entry(uvd->videoName, uvd->procfs_vEntry); 2398 uvd->procfs_vEntry = NULL; 2399 } 2400} 2401 2402static int usbvideo_default_procfs_read_proc( 2403 char *page, char **start, off_t off, int count, 2404 int *eof, void *data) 2405{ 2406 char *out = page; 2407 int len; 2408 2409 /* Stay under PAGE_SIZE or else */ 2410 out += sprintf(out, "This driver does not support /proc services.\n"); 2411 len = out - page; 2412 len -= off; 2413 if (len < count) { 2414 *eof = 1; 2415 if (len <= 0) 2416 return 0; 2417 } else 2418 len = count; 2419 *start = page + off; 2420 return len; 2421} 2422 2423static int usbvideo_default_procfs_write_proc( 2424 struct file *file, const char *buffer, 2425 unsigned long count, void *data) 2426{ 2427 return -EINVAL; 2428} 2429 2430#endif /* USES_PROC_FS */ 2431MODULE_LICENSE("GPL"); 2432