/* * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2, or (at your option) * any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include #include #include #include #define __NO_VERSION__ /* Temporary: usbvideo is not a module yet */ #include #include #include #include #include #include #include #include #include "usbvideo.h" #if defined(MAP_NR) #define virt_to_page(v) MAP_NR(v) /* Kernels 2.2.x */ #endif static int video_nr = -1; MODULE_PARM(video_nr, "i"); /* * Local prototypes. */ #if USES_PROC_FS static void usbvideo_procfs_level1_create(usbvideo_t *ut); static void usbvideo_procfs_level1_destroy(usbvideo_t *ut); static void usbvideo_procfs_level2_create(uvd_t *uvd); static void usbvideo_procfs_level2_destroy(uvd_t *uvd); static int usbvideo_default_procfs_read_proc( char *page, char **start, off_t off, int count, int *eof, void *data); static int usbvideo_default_procfs_write_proc( struct file *file, const char *buffer, unsigned long count, void *data); #endif /*******************************/ /* Memory management functions */ /*******************************/ #define MDEBUG(x) do { } while(0) /* Debug memory management */ /* Given PGD from the address space's page table, return the kernel * virtual mapping of the physical memory mapped at ADR. */ unsigned long usbvideo_uvirt_to_kva(pgd_t *pgd, unsigned long adr) { unsigned long ret = 0UL; pmd_t *pmd; pte_t *ptep, pte; if (!pgd_none(*pgd)) { pmd = pmd_offset(pgd, adr); if (!pmd_none(*pmd)) { ptep = pte_offset(pmd, adr); pte = *ptep; if (pte_present(pte)) { ret = (unsigned long) page_address(pte_page(pte)); ret |= (adr & (PAGE_SIZE-1)); } } } MDEBUG(printk("uv2kva(%lx-->%lx)", adr, ret)); return ret; } /* * Here we want the physical address of the memory. * This is used when initializing the contents of the * area and marking the pages as reserved. */ unsigned long usbvideo_kvirt_to_pa(unsigned long adr) { unsigned long va, kva, ret; va = VMALLOC_VMADDR(adr); kva = usbvideo_uvirt_to_kva(pgd_offset_k(va), va); ret = __pa(kva); MDEBUG(printk("kv2pa(%lx-->%lx)", adr, ret)); return ret; } void *usbvideo_rvmalloc(unsigned long size) { void *mem; unsigned long adr, page; /* Round it off to PAGE_SIZE */ size += (PAGE_SIZE - 1); size &= ~(PAGE_SIZE - 1); mem = vmalloc_32(size); if (!mem) return NULL; memset(mem, 0, size); /* Clear the ram out, no junk to the user */ adr = (unsigned long) mem; while (size > 0) { page = usbvideo_kvirt_to_pa(adr); mem_map_reserve(virt_to_page(__va(page))); adr += PAGE_SIZE; if (size > PAGE_SIZE) size -= PAGE_SIZE; else size = 0; } return mem; } void usbvideo_rvfree(void *mem, unsigned long size) { unsigned long adr, page; if (!mem) return; size += (PAGE_SIZE - 1); size &= ~(PAGE_SIZE - 1); adr=(unsigned long) mem; while (size > 0) { page = usbvideo_kvirt_to_pa(adr); mem_map_unreserve(virt_to_page(__va(page))); adr += PAGE_SIZE; if (size > PAGE_SIZE) size -= PAGE_SIZE; else size = 0; } vfree(mem); } void RingQueue_Initialize(RingQueue_t *rq) { assert(rq != NULL); init_waitqueue_head(&rq->wqh); } void RingQueue_Allocate(RingQueue_t *rq, int rqLen) { assert(rq != NULL); assert(rqLen > 0); rq->length = rqLen; rq->queue = usbvideo_rvmalloc(rq->length); assert(rq->queue != NULL); } int RingQueue_IsAllocated(const RingQueue_t *rq) { if (rq == NULL) return 0; return (rq->queue != NULL) && (rq->length > 0); } void RingQueue_Free(RingQueue_t *rq) { assert(rq != NULL); if (RingQueue_IsAllocated(rq)) { usbvideo_rvfree(rq->queue, rq->length); rq->queue = NULL; rq->length = 0; } } int RingQueue_Dequeue(RingQueue_t *rq, unsigned char *dst, int len) { int i; assert(rq != NULL); assert(dst != NULL); for (i=0; i < len; i++) { dst[i] = rq->queue[rq->ri]; RING_QUEUE_DEQUEUE_BYTES(rq,1); } return len; } int RingQueue_Enqueue(RingQueue_t *rq, const unsigned char *cdata, int n) { int enqueued = 0; assert(rq != NULL); assert(cdata != NULL); assert(rq->length > 0); while (n > 0) { int m, q_avail; /* Calculate the largest chunk that fits the tail of the ring */ q_avail = rq->length - rq->wi; if (q_avail <= 0) { rq->wi = 0; q_avail = rq->length; } m = n; assert(q_avail > 0); if (m > q_avail) m = q_avail; memmove(rq->queue + rq->wi, cdata, m); RING_QUEUE_ADVANCE_INDEX(rq, wi, m); cdata += m; enqueued += m; n -= m; } return enqueued; } int RingQueue_GetLength(const RingQueue_t *rq) { int ri, wi; assert(rq != NULL); ri = rq->ri; wi = rq->wi; if (ri == wi) return 0; else if (ri < wi) return wi - ri; else return wi + (rq->length - ri); } void RingQueue_InterruptibleSleepOn(RingQueue_t *rq) { assert(rq != NULL); interruptible_sleep_on(&rq->wqh); } void RingQueue_WakeUpInterruptible(RingQueue_t *rq) { assert(rq != NULL); if (waitqueue_active(&rq->wqh)) wake_up_interruptible(&rq->wqh); } /* * usbvideo_VideosizeToString() * * This procedure converts given videosize value to readable string. * * History: * 07-Aug-2000 Created. * 19-Oct-2000 Reworked for usbvideo module. */ void usbvideo_VideosizeToString(char *buf, int bufLen, videosize_t vs) { char tmp[40]; int n; n = 1 + sprintf(tmp, "%ldx%ld", VIDEOSIZE_X(vs), VIDEOSIZE_Y(vs)); assert(n < sizeof(tmp)); if ((buf == NULL) || (bufLen < n)) err("usbvideo_VideosizeToString: buffer is too small."); else memmove(buf, tmp, n); } /* * usbvideo_OverlayChar() * * History: * 01-Feb-2000 Created. */ void usbvideo_OverlayChar(uvd_t *uvd, usbvideo_frame_t *frame, int x, int y, int ch) { static const unsigned short digits[16] = { 0xF6DE, /* 0 */ 0x2492, /* 1 */ 0xE7CE, /* 2 */ 0xE79E, /* 3 */ 0xB792, /* 4 */ 0xF39E, /* 5 */ 0xF3DE, /* 6 */ 0xF492, /* 7 */ 0xF7DE, /* 8 */ 0xF79E, /* 9 */ 0x77DA, /* a */ 0xD75C, /* b */ 0xF24E, /* c */ 0xD6DC, /* d */ 0xF34E, /* e */ 0xF348 /* f */ }; unsigned short digit; int ix, iy; if ((uvd == NULL) || (frame == NULL)) return; if (ch >= '0' && ch <= '9') ch -= '0'; else if (ch >= 'A' && ch <= 'F') ch = 10 + (ch - 'A'); else if (ch >= 'a' && ch <= 'f') ch = 10 + (ch - 'a'); else return; digit = digits[ch]; for (iy=0; iy < 5; iy++) { for (ix=0; ix < 3; ix++) { if (digit & 0x8000) { if (uvd->paletteBits & (1L << VIDEO_PALETTE_RGB24)) { /* TODO */ RGB24_PUTPIXEL(frame, x+ix, y+iy, 0xFF, 0xFF, 0xFF); } } digit = digit << 1; } } } /* * usbvideo_OverlayString() * * History: * 01-Feb-2000 Created. */ void usbvideo_OverlayString(uvd_t *uvd, usbvideo_frame_t *frame, int x, int y, const char *str) { while (*str) { usbvideo_OverlayChar(uvd, frame, x, y, *str); str++; x += 4; /* 3 pixels character + 1 space */ } } /* * usbvideo_OverlayStats() * * Overlays important debugging information. * * History: * 01-Feb-2000 Created. */ void usbvideo_OverlayStats(uvd_t *uvd, usbvideo_frame_t *frame) { const int y_diff = 8; char tmp[16]; int x = 10, y=10; long i, j, barLength; const int qi_x1 = 60, qi_y1 = 10; const int qi_x2 = VIDEOSIZE_X(frame->request) - 10, qi_h = 10; /* Call the user callback, see if we may proceed after that */ if (VALID_CALLBACK(uvd, overlayHook)) { if (GET_CALLBACK(uvd, overlayHook)(uvd, frame) < 0) return; } /* * We draw a (mostly) hollow rectangle with qi_xxx coordinates. * Left edge symbolizes the queue index 0; right edge symbolizes * the full capacity of the queue. */ barLength = qi_x2 - qi_x1 - 2; if ((barLength > 10) && (uvd->paletteBits & (1L << VIDEO_PALETTE_RGB24))) { /* TODO */ long u_lo, u_hi, q_used; long m_ri, m_wi, m_lo, m_hi; /* * Determine fill zones (used areas of the queue): * 0 xxxxxxx u_lo ...... uvd->dp.ri xxxxxxxx u_hi ..... uvd->dp.length * * if u_lo < 0 then there is no first filler. */ q_used = RingQueue_GetLength(&uvd->dp); if ((uvd->dp.ri + q_used) >= uvd->dp.length) { u_hi = uvd->dp.length; u_lo = (q_used + uvd->dp.ri) % uvd->dp.length; } else { u_hi = (q_used + uvd->dp.ri); u_lo = -1; } /* Convert byte indices into screen units */ m_ri = qi_x1 + ((barLength * uvd->dp.ri) / uvd->dp.length); m_wi = qi_x1 + ((barLength * uvd->dp.wi) / uvd->dp.length); m_lo = (u_lo > 0) ? (qi_x1 + ((barLength * u_lo) / uvd->dp.length)) : -1; m_hi = qi_x1 + ((barLength * u_hi) / uvd->dp.length); for (j=qi_y1; j < (qi_y1 + qi_h); j++) { for (i=qi_x1; i < qi_x2; i++) { /* Draw border lines */ if ((j == qi_y1) || (j == (qi_y1 + qi_h - 1)) || (i == qi_x1) || (i == (qi_x2 - 1))) { RGB24_PUTPIXEL(frame, i, j, 0xFF, 0xFF, 0xFF); continue; } /* For all other points the Y coordinate does not matter */ if ((i >= m_ri) && (i <= (m_ri + 3))) { RGB24_PUTPIXEL(frame, i, j, 0x00, 0xFF, 0x00); } else if ((i >= m_wi) && (i <= (m_wi + 3))) { RGB24_PUTPIXEL(frame, i, j, 0xFF, 0x00, 0x00); } else if ((i < m_lo) || ((i > m_ri) && (i < m_hi))) RGB24_PUTPIXEL(frame, i, j, 0x00, 0x00, 0xFF); } } } sprintf(tmp, "%8lx", uvd->stats.frame_num); usbvideo_OverlayString(uvd, frame, x, y, tmp); y += y_diff; sprintf(tmp, "%8lx", uvd->stats.urb_count); usbvideo_OverlayString(uvd, frame, x, y, tmp); y += y_diff; sprintf(tmp, "%8lx", uvd->stats.urb_length); usbvideo_OverlayString(uvd, frame, x, y, tmp); y += y_diff; sprintf(tmp, "%8lx", uvd->stats.data_count); usbvideo_OverlayString(uvd, frame, x, y, tmp); y += y_diff; sprintf(tmp, "%8lx", uvd->stats.header_count); usbvideo_OverlayString(uvd, frame, x, y, tmp); y += y_diff; sprintf(tmp, "%8lx", uvd->stats.iso_skip_count); usbvideo_OverlayString(uvd, frame, x, y, tmp); y += y_diff; sprintf(tmp, "%8lx", uvd->stats.iso_err_count); usbvideo_OverlayString(uvd, frame, x, y, tmp); y += y_diff; sprintf(tmp, "%8x", uvd->vpic.colour); usbvideo_OverlayString(uvd, frame, x, y, tmp); y += y_diff; sprintf(tmp, "%8x", uvd->vpic.hue); usbvideo_OverlayString(uvd, frame, x, y, tmp); y += y_diff; sprintf(tmp, "%8x", uvd->vpic.brightness >> 8); usbvideo_OverlayString(uvd, frame, x, y, tmp); y += y_diff; sprintf(tmp, "%8x", uvd->vpic.contrast >> 12); usbvideo_OverlayString(uvd, frame, x, y, tmp); y += y_diff; sprintf(tmp, "%8d", uvd->vpic.whiteness >> 8); usbvideo_OverlayString(uvd, frame, x, y, tmp); y += y_diff; } /* * usbvideo_ReportStatistics() * * This procedure prints packet and transfer statistics. * * History: * 14-Jan-2000 Corrected default multiplier. */ void usbvideo_ReportStatistics(const uvd_t *uvd) { if ((uvd != NULL) && (uvd->stats.urb_count > 0)) { unsigned long allPackets, badPackets, goodPackets, percent; allPackets = uvd->stats.urb_count * CAMERA_URB_FRAMES; badPackets = uvd->stats.iso_skip_count + uvd->stats.iso_err_count; goodPackets = allPackets - badPackets; /* Calculate percentage wisely, remember integer limits */ assert(allPackets != 0); if (goodPackets < (((unsigned long)-1)/100)) percent = (100 * goodPackets) / allPackets; else percent = goodPackets / (allPackets / 100); info("Packet Statistics: Total=%lu. Empty=%lu. Usage=%lu%%", allPackets, badPackets, percent); if (uvd->iso_packet_len > 0) { unsigned long allBytes, xferBytes; char multiplier = ' '; allBytes = allPackets * uvd->iso_packet_len; xferBytes = uvd->stats.data_count; assert(allBytes != 0); if (xferBytes < (((unsigned long)-1)/100)) percent = (100 * xferBytes) / allBytes; else percent = xferBytes / (allBytes / 100); /* Scale xferBytes for easy reading */ if (xferBytes > 10*1024) { xferBytes /= 1024; multiplier = 'K'; if (xferBytes > 10*1024) { xferBytes /= 1024; multiplier = 'M'; if (xferBytes > 10*1024) { xferBytes /= 1024; multiplier = 'G'; if (xferBytes > 10*1024) { xferBytes /= 1024; multiplier = 'T'; } } } } info("Transfer Statistics: Transferred=%lu%cB Usage=%lu%%", xferBytes, multiplier, percent); } } } /* * usbvideo_DrawLine() * * A standard implementation of Bresenham's line drawing algorithm. * This procedure is provided primarily for debugging or demo * purposes. */ void usbvideo_DrawLine( usbvideo_frame_t *frame, int x1, int y1, int x2, int y2, unsigned char cr, unsigned char cg, unsigned char cb) { int i, dx, dy, np, d; int dinc1, dinc2, x, xinc1, xinc2, y, yinc1, yinc2; if ((dx = x2 - x1) < 0) dx = -dx; if ((dy = y2 - y1) < 0) dy = -dy; if (dx >= dy) { np = dx + 1; d = (2 * dy) - dx; dinc1 = dy << 1; dinc2 = (dy - dx) << 1; xinc1 = 1; xinc2 = 1; yinc1 = 0; yinc2 = 1; } else { np = dy + 1; d = (2 * dx) - dy; dinc1 = dx << 1; dinc2 = (dx - dy) << 1; xinc1 = 0; xinc2 = 1; yinc1 = 1; yinc2 = 1; } /* Make sure x and y move in the right directions */ if (x1 > x2) { xinc1 = -xinc1; xinc2 = -xinc2; } if (y1 > y2) { yinc1 = -yinc1; yinc2 = -yinc2; } for (i=0, x=x1, y=y1; i < np; i++) { if (frame->palette == VIDEO_PALETTE_RGB24) { /* TODO */ RGB24_PUTPIXEL(frame, x, y, cr, cg, cb); } if (d < 0) { d += dinc1; x += xinc1; y += yinc1; } else { d += dinc2; x += xinc2; y += yinc2; } } } /* * usbvideo_TestPattern() * * Procedure forms a test pattern (yellow grid on blue background). * * Parameters: * fullframe: if TRUE then entire frame is filled, otherwise the procedure * continues from the current scanline. * pmode 0: fill the frame with solid blue color (like on VCR or TV) * 1: Draw a colored grid * * History: * 01-Feb-2000 Created. */ void usbvideo_TestPattern(uvd_t *uvd, int fullframe, int pmode) { static const char proc[] = "usbvideo_TestPattern"; usbvideo_frame_t *frame; int num_cell = 0; int scan_length = 0; static int num_pass = 0; if (uvd == NULL) { err("%s: uvd == NULL", proc); return; } if ((uvd->curframe < 0) || (uvd->curframe >= USBVIDEO_NUMFRAMES)) { err("%s: uvd->curframe=%d.", proc, uvd->curframe); return; } /* Grab the current frame */ frame = &uvd->frame[uvd->curframe]; /* Optionally start at the beginning */ if (fullframe) { frame->curline = 0; frame->seqRead_Length = 0; } #if 0 { /* For debugging purposes only */ char tmp[20]; usbvideo_VideosizeToString(tmp, sizeof(tmp), frame->request); info("testpattern: frame=%s", tmp); } #endif /* Form every scan line */ for (; frame->curline < VIDEOSIZE_Y(frame->request); frame->curline++) { int i; unsigned char *f = frame->data + (VIDEOSIZE_X(frame->request) * V4L_BYTES_PER_PIXEL * frame->curline); for (i=0; i < VIDEOSIZE_X(frame->request); i++) { unsigned char cb=0x80; unsigned char cg = 0; unsigned char cr = 0; if (pmode == 1) { if (frame->curline % 32 == 0) cb = 0, cg = cr = 0xFF; else if (i % 32 == 0) { if (frame->curline % 32 == 1) num_cell++; cb = 0, cg = cr = 0xFF; } else { cb = ((num_cell*7) + num_pass) & 0xFF; cg = ((num_cell*5) + num_pass*2) & 0xFF; cr = ((num_cell*3) + num_pass*3) & 0xFF; } } else { /* Just the blue screen */ } *f++ = cb; *f++ = cg; *f++ = cr; scan_length += 3; } } frame->frameState = FrameState_Done; frame->seqRead_Length += scan_length; ++num_pass; /* We do this unconditionally, regardless of FLAGS_OVERLAY_STATS */ usbvideo_OverlayStats(uvd, frame); } /* * usbvideo_HexDump() * * A debugging tool. Prints hex dumps. * * History: * 29-Jul-2000 Added printing of offsets. */ void usbvideo_HexDump(const unsigned char *data, int len) { const int bytes_per_line = 32; char tmp[128]; /* 32*3 + 5 */ int i, k; for (i=k=0; len > 0; i++, len--) { if (i > 0 && ((i % bytes_per_line) == 0)) { printk("%s\n", tmp); k=0; } if ((i % bytes_per_line) == 0) k += sprintf(&tmp[k], "%04x: ", i); k += sprintf(&tmp[k], "%02x ", data[i]); } if (k > 0) printk("%s\n", tmp); } /* Debugging aid */ void usbvideo_SayAndWait(const char *what) { wait_queue_head_t wq; init_waitqueue_head(&wq); info("Say: %s", what); interruptible_sleep_on_timeout (&wq, HZ*3); /* Timeout */ } /* ******************************************************************** */ static void usbvideo_ClientIncModCount(uvd_t *uvd) { static const char proc[] = "usbvideo_ClientIncModCount"; if (uvd == NULL) { err("%s: uvd == NULL", proc); return; } if (uvd->handle == NULL) { err("%s: uvd->handle == NULL", proc); return; } if (uvd->handle->md_module == NULL) { err("%s: uvd->handle->md_module == NULL", proc); return; } __MOD_INC_USE_COUNT(uvd->handle->md_module); } static void usbvideo_ClientDecModCount(uvd_t *uvd) { static const char proc[] = "usbvideo_ClientDecModCount"; if (uvd == NULL) { err("%s: uvd == NULL", proc); return; } if (uvd->handle == NULL) { err("%s: uvd->handle == NULL", proc); return; } if (uvd->handle->md_module == NULL) { err("%s: uvd->handle->md_module == NULL", proc); return; } __MOD_DEC_USE_COUNT(uvd->handle->md_module); } int usbvideo_register( usbvideo_t **pCams, const int num_cams, const int num_extra, const char *driverName, const usbvideo_cb_t *cbTbl, struct module *md ) { static const char proc[] = "usbvideo_register"; usbvideo_t *cams; int i, base_size; /* Check parameters for sanity */ if ((num_cams <= 0) || (pCams == NULL) || (cbTbl == NULL)) { err("%s: Illegal call", proc); return -EINVAL; } /* Check registration callback - must be set! */ if (cbTbl->probe == NULL) { err("%s: probe() is required!", proc); return -EINVAL; } base_size = num_cams * sizeof(uvd_t) + sizeof(usbvideo_t); cams = (usbvideo_t *) kmalloc(base_size, GFP_KERNEL); if (cams == NULL) { err("Failed to allocate %d. bytes for usbvideo_t", base_size); return -ENOMEM; } dbg("%s: Allocated $%p (%d. bytes) for %d. cameras", proc, cams, base_size, num_cams); memset(cams, 0, base_size); /* Copy callbacks, apply defaults for those that are not set */ memmove(&cams->cb, cbTbl, sizeof(cams->cb)); if (cams->cb.getFrame == NULL) cams->cb.getFrame = usbvideo_GetFrame; if (cams->cb.disconnect == NULL) cams->cb.disconnect = usbvideo_Disconnect; #if USES_PROC_FS /* * If both /proc fs callbacks are NULL then we assume that the driver * does not need procfs services at all. Leave them NULL. */ cams->uses_procfs = (cams->cb.procfs_read != NULL) || (cams->cb.procfs_write == NULL); if (cams->uses_procfs) { if (cams->cb.procfs_read == NULL) cams->cb.procfs_read = usbvideo_default_procfs_read_proc; if (cams->cb.procfs_write == NULL) cams->cb.procfs_write = usbvideo_default_procfs_write_proc; } #else /* !USES_PROC_FS */ /* Report a warning so that user knows why there is no /proc entries */ if ((cams->cb.procfs_read != NULL) || (cams->cb.procfs_write == NULL)) { dbg("%s: /proc fs support requested but not configured!", proc); } #endif cams->num_cameras = num_cams; cams->cam = (uvd_t *) &cams[1]; cams->md_module = md; if (cams->md_module == NULL) warn("%s: module == NULL!", proc); init_MUTEX(&cams->lock); /* to 1 == available */ for (i = 0; i < num_cams; i++) { uvd_t *up = &cams->cam[i]; up->handle = cams; /* Allocate user_data separately because of kmalloc's limits */ if (num_extra > 0) { up->user_size = num_cams * num_extra; up->user_data = (char *) kmalloc(up->user_size, GFP_KERNEL); if (up->user_data == NULL) { up->user_size = 0; err("%s: Failed to allocate user_data (%d. bytes)", proc, up->user_size); return -ENOMEM; } dbg("%s: Allocated cams[%d].user_data=$%p (%d. bytes)", proc, i, up->user_data, up->user_size); } } /* * Register ourselves with USB stack. */ strcpy(cams->drvName, (driverName != NULL) ? driverName : "Unknown"); cams->usbdrv.name = cams->drvName; cams->usbdrv.probe = cams->cb.probe; cams->usbdrv.disconnect = cams->cb.disconnect; #if USES_PROC_FS if (cams->uses_procfs) { dbg("%s: Creating /proc filesystem entries.", proc); usbvideo_procfs_level1_create(cams); } #endif /* * Update global handle to usbvideo. This is very important * because probe() can be called before usb_register() returns. * If the handle is not yet updated then the probe() will fail. */ *pCams = cams; usb_register(&cams->usbdrv); return 0; } /* * usbvideo_Deregister() * * Procedure frees all usbvideo and user data structures. Be warned that * if you had some dynamically allocated components in ->user field then * you should free them before calling here. */ void usbvideo_Deregister(usbvideo_t **pCams) { static const char proc[] = "usbvideo_deregister"; usbvideo_t *cams; int i; if (pCams == NULL) { err("%s: pCams == NULL", proc); return; } cams = *pCams; if (cams == NULL) { err("%s: cams == NULL", proc); return; } #if USES_PROC_FS if (cams->uses_procfs) { dbg("%s: Deregistering filesystem entries.", proc); usbvideo_procfs_level1_destroy(cams); } #endif dbg("%s: Deregistering %s driver.", proc, cams->drvName); usb_deregister(&cams->usbdrv); dbg("%s: Deallocating cams=$%p (%d. cameras)", proc, cams, cams->num_cameras); for (i=0; i < cams->num_cameras; i++) { uvd_t *up = &cams->cam[i]; int warning = 0; if (up->user_data != NULL) { if (up->user_size <= 0) ++warning; } else { if (up->user_size > 0) ++warning; } if (warning) { err("%s: Warning: user_data=$%p user_size=%d.", proc, up->user_data, up->user_size); } else { dbg("%s: Freeing %d. $%p->user_data=$%p", proc, i, up, up->user_data); kfree(up->user_data); } } /* Whole array was allocated in one chunk */ dbg("%s: Freed %d uvd_t structures", proc, cams->num_cameras); kfree(cams); *pCams = NULL; } /* * usbvideo_Disconnect() * * This procedure stops all driver activity. Deallocation of * the interface-private structure (pointed by 'ptr') is done now * (if we don't have any open files) or later, when those files * are closed. After that driver should be removable. * * This code handles surprise removal. The uvd->user is a counter which * increments on open() and decrements on close(). If we see here that * this counter is not 0 then we have a client who still has us opened. * We set uvd->remove_pending flag as early as possible, and after that * all access to the camera will gracefully fail. These failures should * prompt client to (eventually) close the video device, and then - in * usbvideo_v4l_close() - we decrement uvd->uvd_used and usage counter. * * History: * 22-Jan-2000 Added polling of MOD_IN_USE to delay removal until all users gone. * 27-Jan-2000 Reworked to allow pending disconnects; see xxx_close() * 24-May-2000 Corrected to prevent race condition (MOD_xxx_USE_COUNT). * 19-Oct-2000 Moved to usbvideo module. */ void usbvideo_Disconnect(struct usb_device *dev, void *ptr) { static const char proc[] = "usbvideo_Disconnect"; uvd_t *uvd = (uvd_t *) ptr; int i; if ((dev == NULL) || (uvd == NULL)) { err("%s($%p,$%p): Illegal call.", proc, dev, ptr); return; } usbvideo_ClientIncModCount(uvd); if (uvd->debug > 0) info("%s(%p,%p.)", proc, dev, ptr); down(&uvd->lock); uvd->remove_pending = 1; /* Now all ISO data will be ignored */ /* At this time we ask to cancel outstanding URBs */ usbvideo_StopDataPump(uvd); for (i=0; i < USBVIDEO_NUMSBUF; i++) usb_free_urb(uvd->sbuf[i].urb); usb_dec_dev_use(uvd->dev); uvd->dev = NULL; /* USB device is no more */ if (uvd->user) info("%s: In use, disconnect pending.", proc); else usbvideo_CameraRelease(uvd); up(&uvd->lock); info("USB camera disconnected."); usbvideo_ClientDecModCount(uvd); } /* * usbvideo_CameraRelease() * * This code does final release of uvd_t. This happens * after the device is disconnected -and- all clients * closed their files. * * History: * 27-Jan-2000 Created. */ void usbvideo_CameraRelease(uvd_t *uvd) { static const char proc[] = "usbvideo_CameraRelease"; if (uvd == NULL) { err("%s: Illegal call", proc); return; } video_unregister_device(&uvd->vdev); if (uvd->debug > 0) info("%s: Video unregistered.", proc); #if USES_PROC_FS assert(uvd->handle != NULL); if (uvd->handle->uses_procfs) { dbg("%s: Removing /proc/%s/ filesystem entries.", proc, uvd->handle->drvName); usbvideo_procfs_level2_destroy(uvd); } #endif RingQueue_Free(&uvd->dp); if (VALID_CALLBACK(uvd, userFree)) GET_CALLBACK(uvd, userFree)(uvd); uvd->uvd_used = 0; /* This is atomic, no need to take mutex */ } /* * usbvideo_find_struct() * * This code searches the array of preallocated (static) structures * and returns index of the first one that isn't in use. Returns -1 * if there are no free structures. * * History: * 27-Jan-2000 Created. */ static int usbvideo_find_struct(usbvideo_t *cams) { int u, rv = -1; if (cams == NULL) { err("No usbvideo_t handle?"); return -1; } down(&cams->lock); for (u = 0; u < cams->num_cameras; u++) { uvd_t *uvd = &cams->cam[u]; if (!uvd->uvd_used) /* This one is free */ { uvd->uvd_used = 1; /* In use now */ init_MUTEX(&uvd->lock); /* to 1 == available */ uvd->dev = NULL; rv = u; break; } } up(&cams->lock); return rv; } uvd_t *usbvideo_AllocateDevice(usbvideo_t *cams) { int i, devnum; uvd_t *uvd = NULL; if (cams == NULL) { err("No usbvideo_t handle?"); return NULL; } devnum = usbvideo_find_struct(cams); if (devnum == -1) { err("IBM USB camera driver: Too many devices!"); return NULL; } uvd = &cams->cam[devnum]; dbg("Device entry #%d. at $%p", devnum, uvd); /* Not relying upon caller we increase module counter ourselves */ usbvideo_ClientIncModCount(uvd); down(&uvd->lock); for (i=0; i < USBVIDEO_NUMSBUF; i++) { uvd->sbuf[i].urb = usb_alloc_urb(FRAMES_PER_DESC); if (uvd->sbuf[i].urb == NULL) { err("usb_alloc_urb(%d.) failed.", FRAMES_PER_DESC); uvd->uvd_used = 0; uvd = NULL; goto allocate_done; } } uvd->user=0; uvd->remove_pending = 0; uvd->last_error = 0; RingQueue_Initialize(&uvd->dp); /* Initialize video device structure */ memset(&uvd->vdev, 0, sizeof(uvd->vdev)); i = sprintf(uvd->vdev.name, "%s USB Camera", cams->drvName); if (i >= sizeof(uvd->vdev.name)) { err("Wrote too much into uvd->vdev.name, expect trouble!"); } uvd->vdev.type = VID_TYPE_CAPTURE; uvd->vdev.hardware = VID_HARDWARE_CPIA; uvd->vdev.open = usbvideo_v4l_open; uvd->vdev.close = usbvideo_v4l_close; uvd->vdev.read = usbvideo_v4l_read; uvd->vdev.write = usbvideo_v4l_write; uvd->vdev.ioctl = usbvideo_v4l_ioctl; uvd->vdev.mmap = usbvideo_v4l_mmap; uvd->vdev.initialize = usbvideo_v4l_initialize; /* * The client is free to overwrite those because we * return control to the client's probe function right now. */ allocate_done: up (&uvd->lock); usbvideo_ClientDecModCount(uvd); return uvd; } int usbvideo_RegisterVideoDevice(uvd_t *uvd) { static const char proc[] = "usbvideo_RegisterVideoDevice"; char tmp1[20], tmp2[20]; /* Buffers for printing */ if (uvd == NULL) { err("%s: Illegal call.", proc); return -EINVAL; } if (uvd->video_endp == 0) { info("%s: No video endpoint specified; data pump disabled.", proc); } if (uvd->paletteBits == 0) { err("%s: No palettes specified!", proc); return -EINVAL; } if (uvd->defaultPalette == 0) { info("%s: No default palette!", proc); } uvd->max_frame_size = VIDEOSIZE_X(uvd->canvas) * VIDEOSIZE_Y(uvd->canvas) * V4L_BYTES_PER_PIXEL; usbvideo_VideosizeToString(tmp1, sizeof(tmp1), uvd->videosize); usbvideo_VideosizeToString(tmp2, sizeof(tmp2), uvd->canvas); if (uvd->debug > 0) { info("%s: iface=%d. endpoint=$%02x paletteBits=$%08lx", proc, uvd->iface, uvd->video_endp, uvd->paletteBits); } if (video_register_device(&uvd->vdev, VFL_TYPE_GRABBER, video_nr) == -1) { err("%s: video_register_device failed", proc); return -EPIPE; } if (uvd->debug > 1) { info("%s: video_register_device() successful", proc); } if (uvd->dev == NULL) { err("%s: uvd->dev == NULL", proc); return -EINVAL; } info("%s on /dev/video%d: canvas=%s videosize=%s", (uvd->handle != NULL) ? uvd->handle->drvName : "???", uvd->vdev.minor, tmp2, tmp1); #if USES_PROC_FS assert(uvd->handle != NULL); if (uvd->handle->uses_procfs) { if (uvd->debug > 0) { info("%s: Creating /proc/video/%s/ filesystem entries.", proc, uvd->handle->drvName); } usbvideo_procfs_level2_create(uvd); } #endif usb_inc_dev_use(uvd->dev); return 0; } /* ******************************************************************** */ int usbvideo_v4l_initialize(struct video_device *dev) { return 0; } long usbvideo_v4l_write(struct video_device *dev, const char *buf, unsigned long count, int noblock) { return -EINVAL; } int usbvideo_v4l_mmap(struct video_device *dev, const char *adr, unsigned long size) { uvd_t *uvd = (uvd_t *) dev; unsigned long start = (unsigned long) adr; unsigned long page, pos; if (!CAMERA_IS_OPERATIONAL(uvd)) return -EFAULT; if (size > (((2 * uvd->max_frame_size) + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1))) return -EINVAL; pos = (unsigned long) uvd->fbuf; while (size > 0) { page = usbvideo_kvirt_to_pa(pos); if (remap_page_range(start, page, PAGE_SIZE, PAGE_SHARED)) return -EAGAIN; start += PAGE_SIZE; pos += PAGE_SIZE; if (size > PAGE_SIZE) size -= PAGE_SIZE; else size = 0; } return 0; } /* * usbvideo_v4l_open() * * This is part of Video 4 Linux API. The driver can be opened by one * client only (checks internal counter 'uvdser'). The procedure * then allocates buffers needed for video processing. * * History: * 22-Jan-2000 Rewrote, moved scratch buffer allocation here. Now the * camera is also initialized here (once per connect), at * expense of V4L client (it waits on open() call). * 27-Jan-2000 Used USBVIDEO_NUMSBUF as number of URB buffers. * 24-May-2000 Corrected to prevent race condition (MOD_xxx_USE_COUNT). */ int usbvideo_v4l_open(struct video_device *dev, int flags) { static const char proc[] = "usbvideo_v4l_open"; uvd_t *uvd = (uvd_t *) dev; const int sb_size = FRAMES_PER_DESC * uvd->iso_packet_len; int i, errCode = 0; if (uvd->debug > 1) info("%s($%p,$%08x", proc, dev, flags); usbvideo_ClientIncModCount(uvd); down(&uvd->lock); if (uvd->user) { err("%s: Someone tried to open an already opened device!", proc); errCode = -EBUSY; } else { /* Clear statistics */ memset(&uvd->stats, 0, sizeof(uvd->stats)); /* Clean pointers so we know if we allocated something */ for (i=0; i < USBVIDEO_NUMSBUF; i++) uvd->sbuf[i].data = NULL; /* Allocate memory for the frame buffers */ uvd->fbuf_size = USBVIDEO_NUMFRAMES * uvd->max_frame_size; uvd->fbuf = usbvideo_rvmalloc(uvd->fbuf_size); RingQueue_Allocate(&uvd->dp, 128*1024); /* FIXME #define */ if ((uvd->fbuf == NULL) || (!RingQueue_IsAllocated(&uvd->dp))) { err("%s: Failed to allocate fbuf or dp", proc); errCode = -ENOMEM; } else { /* Allocate all buffers */ for (i=0; i < USBVIDEO_NUMFRAMES; i++) { uvd->frame[i].frameState = FrameState_Unused; uvd->frame[i].data = uvd->fbuf + i*(uvd->max_frame_size); /* * Set default sizes in case IOCTL (VIDIOCMCAPTURE) * is not used (using read() instead). */ uvd->frame[i].canvas = uvd->canvas; uvd->frame[i].seqRead_Index = 0; } for (i=0; i < USBVIDEO_NUMSBUF; i++) { uvd->sbuf[i].data = kmalloc(sb_size, GFP_KERNEL); if (uvd->sbuf[i].data == NULL) { errCode = -ENOMEM; break; } } } if (errCode != 0) { /* Have to free all that memory */ if (uvd->fbuf != NULL) { usbvideo_rvfree(uvd->fbuf, uvd->fbuf_size); uvd->fbuf = NULL; } RingQueue_Free(&uvd->dp); for (i=0; i < USBVIDEO_NUMSBUF; i++) { if (uvd->sbuf[i].data != NULL) { kfree (uvd->sbuf[i].data); uvd->sbuf[i].data = NULL; } } } } /* If so far no errors then we shall start the camera */ if (errCode == 0) { /* Start data pump if we have valid endpoint */ if (uvd->video_endp != 0) errCode = usbvideo_StartDataPump(uvd); if (errCode == 0) { if (VALID_CALLBACK(uvd, setupOnOpen)) { if (uvd->debug > 1) info("%s: setupOnOpen callback", proc); errCode = GET_CALLBACK(uvd, setupOnOpen)(uvd); if (errCode < 0) { err("%s: setupOnOpen callback failed (%d.).", proc, errCode); } else if (uvd->debug > 1) { info("%s: setupOnOpen callback successful", proc); } } if (errCode == 0) { uvd->settingsAdjusted = 0; if (uvd->debug > 1) info("%s: Open succeeded.", proc); uvd->user++; } } } up(&uvd->lock); if (errCode != 0) usbvideo_ClientDecModCount(uvd); if (uvd->debug > 0) info("%s: Returning %d.", proc, errCode); return errCode; } /* * usbvideo_v4l_close() * * This is part of Video 4 Linux API. The procedure * stops streaming and deallocates all buffers that were earlier * allocated in usbvideo_v4l_open(). * * History: * 22-Jan-2000 Moved scratch buffer deallocation here. * 27-Jan-2000 Used USBVIDEO_NUMSBUF as number of URB buffers. * 24-May-2000 Moved MOD_DEC_USE_COUNT outside of code that can sleep. */ void usbvideo_v4l_close(struct video_device *dev) { static const char proc[] = "usbvideo_v4l_close"; uvd_t *uvd = (uvd_t *)dev; int i; if (uvd->debug > 1) info("%s($%p)", proc, dev); down(&uvd->lock); usbvideo_StopDataPump(uvd); usbvideo_rvfree(uvd->fbuf, uvd->fbuf_size); uvd->fbuf = NULL; RingQueue_Free(&uvd->dp); for (i=0; i < USBVIDEO_NUMSBUF; i++) { kfree(uvd->sbuf[i].data); uvd->sbuf[i].data = NULL; } #if USBVIDEO_REPORT_STATS usbvideo_ReportStatistics(uvd); #endif uvd->user--; if (uvd->remove_pending) { if (uvd->debug > 0) info("usbvideo_v4l_close: Final disconnect."); usbvideo_CameraRelease(uvd); } up(&uvd->lock); usbvideo_ClientDecModCount(uvd); if (uvd->debug > 1) info("%s: Completed.", proc); } /* * usbvideo_v4l_ioctl() * * This is part of Video 4 Linux API. The procedure handles ioctl() calls. * * History: * 22-Jan-2000 Corrected VIDIOCSPICT to reject unsupported settings. */ int usbvideo_v4l_ioctl(struct video_device *dev, unsigned int cmd, void *arg) { uvd_t *uvd = (uvd_t *)dev; if (!CAMERA_IS_OPERATIONAL(uvd)) return -EFAULT; switch (cmd) { case VIDIOCGCAP: { if (copy_to_user(arg, &uvd->vcap, sizeof(uvd->vcap))) return -EFAULT; return 0; } case VIDIOCGCHAN: { if (copy_to_user(arg, &uvd->vchan, sizeof(uvd->vchan))) return -EFAULT; return 0; } case VIDIOCSCHAN: { /* Not used but we return success */ int v; if (copy_from_user(&v, arg, sizeof(v))) return -EFAULT; return 0; } case VIDIOCGPICT: { if (copy_to_user(arg, &uvd->vpic, sizeof(uvd->vpic))) return -EFAULT; return 0; } case VIDIOCSPICT: { struct video_picture tmp; /* * Use temporary 'video_picture' structure to preserve our * own settings (such as color depth, palette) that we * aren't allowing everyone (V4L client) to change. */ if (copy_from_user(&tmp, arg, sizeof(tmp))) return -EFAULT; uvd->vpic.brightness = tmp.brightness; uvd->vpic.hue = tmp.hue; uvd->vpic.colour = tmp.colour; uvd->vpic.contrast = tmp.contrast; uvd->settingsAdjusted = 0; /* Will force new settings */ return 0; } case VIDIOCSWIN: { struct video_window vw; if (copy_from_user(&vw, arg, sizeof(vw))) return -EFAULT; if (vw.flags) return -EINVAL; if (vw.clipcount) return -EINVAL; if (vw.width != VIDEOSIZE_X(uvd->canvas)) return -EINVAL; if (vw.height != VIDEOSIZE_Y(uvd->canvas)) return -EINVAL; return 0; } case VIDIOCGWIN: { struct video_window vw; vw.x = 0; vw.y = 0; vw.width = VIDEOSIZE_X(uvd->canvas); vw.height = VIDEOSIZE_Y(uvd->canvas); vw.chromakey = 0; if (VALID_CALLBACK(uvd, getFPS)) vw.flags = GET_CALLBACK(uvd, getFPS)(uvd); else vw.flags = 10; /* FIXME: do better! */ if (copy_to_user(arg, &vw, sizeof(vw))) return -EFAULT; return 0; } case VIDIOCGMBUF: { struct video_mbuf vm; memset(&vm, 0, sizeof(vm)); vm.size = uvd->max_frame_size * 2; vm.frames = 2; vm.offsets[0] = 0; vm.offsets[1] = uvd->max_frame_size; if (copy_to_user((void *)arg, (void *)&vm, sizeof(vm))) return -EFAULT; return 0; } case VIDIOCMCAPTURE: { struct video_mmap vm; if (copy_from_user((void *)&vm, (void *)arg, sizeof(vm))) { err("VIDIOCMCAPTURE: copy_from_user() failed."); return -EFAULT; } if (uvd->debug >= 1) { info("VIDIOCMCAPTURE: frame=%d. size=%dx%d, format=%d.", vm.frame, vm.width, vm.height, vm.format); } /* * Check if the requested size is supported. If the requestor * requests too big a frame then we may be tricked into accessing * outside of own preallocated frame buffer (in uvd->frame). * This will cause oops or a security hole. Theoretically, we * could only clamp the size down to acceptable bounds, but then * we'd need to figure out how to insert our smaller buffer into * larger caller's buffer... this is not an easy question. So we * here just flatly reject too large requests, assuming that the * caller will resubmit with smaller size. Callers should know * what size we support (returned by VIDIOCGCAP). However vidcat, * for one, does not care and allows to ask for any size. */ if ((vm.width > VIDEOSIZE_X(uvd->canvas)) || (vm.height > VIDEOSIZE_Y(uvd->canvas))) { if (uvd->debug > 0) { info("VIDIOCMCAPTURE: Size=%dx%d too large; " "allowed only up to %ldx%ld", vm.width, vm.height, VIDEOSIZE_X(uvd->canvas), VIDEOSIZE_Y(uvd->canvas)); } return -EINVAL; } /* Check if the palette is supported */ if (((1L << vm.format) & uvd->paletteBits) == 0) { if (uvd->debug > 0) { info("VIDIOCMCAPTURE: format=%d. not supported" " (paletteBits=$%08lx)", vm.format, uvd->paletteBits); } return -EINVAL; } if ((vm.frame != 0) && (vm.frame != 1)) { err("VIDIOCMCAPTURE: vm.frame=%d. !E [0,1]", vm.frame); return -EINVAL; } if (uvd->frame[vm.frame].frameState == FrameState_Grabbing) { /* Not an error - can happen */ } uvd->frame[vm.frame].request = VIDEOSIZE(vm.width, vm.height); uvd->frame[vm.frame].palette = vm.format; /* Mark it as ready */ uvd->frame[vm.frame].frameState = FrameState_Ready; return usbvideo_NewFrame(uvd, vm.frame); } case VIDIOCSYNC: { int frameNum, ret; if (copy_from_user((void *)&frameNum, arg, sizeof(frameNum))) { err("VIDIOCSYNC: copy_from_user() failed."); return -EFAULT; } if(frameNum < 0 || frameNum >= USBVIDEO_NUMFRAMES) return -EINVAL; if (uvd->debug >= 1) info("VIDIOCSYNC: syncing to frame %d.", frameNum); if (uvd->flags & FLAGS_NO_DECODING) ret = usbvideo_GetFrame(uvd, frameNum); else if (VALID_CALLBACK(uvd, getFrame)) { ret = GET_CALLBACK(uvd, getFrame)(uvd, frameNum); if ((ret < 0) && (uvd->debug >= 1)) { err("VIDIOCSYNC: getFrame() returned %d.", ret); } } else { err("VIDIOCSYNC: getFrame is not set"); ret = -EFAULT; } /* * The frame is in FrameState_Done_Hold state. Release it * right now because its data is already mapped into * the user space and it's up to the application to * make use of it until it asks for another frame. */ uvd->frame[frameNum].frameState = FrameState_Unused; return ret; } case VIDIOCGFBUF: { struct video_buffer vb; memset(&vb, 0, sizeof(vb)); vb.base = NULL; /* frame buffer not supported, not used */ if (copy_to_user((void *)arg, (void *)&vb, sizeof(vb))) return -EFAULT; return 0; } case VIDIOCKEY: return 0; case VIDIOCCAPTURE: return -EINVAL; case VIDIOCSFBUF: case VIDIOCGTUNER: case VIDIOCSTUNER: case VIDIOCGFREQ: case VIDIOCSFREQ: case VIDIOCGAUDIO: case VIDIOCSAUDIO: return -EINVAL; default: return -ENOIOCTLCMD; } return 0; } /* * usbvideo_v4l_read() * * This is mostly boring stuff. We simply ask for a frame and when it * arrives copy all the video data from it into user space. There is * no obvious need to override this method. * * History: * 20-Oct-2000 Created. * 01-Nov-2000 Added mutex (uvd->lock). */ long usbvideo_v4l_read(struct video_device *dev, char *buf, unsigned long count, int noblock) { static const char proc[] = "usbvideo_v4l_read"; uvd_t *uvd = (uvd_t *) dev; int frmx = -1; usbvideo_frame_t *frame; if (!CAMERA_IS_OPERATIONAL(uvd) || (buf == NULL)) return -EFAULT; if (uvd->debug >= 1) info("%s: %ld. bytes, noblock=%d.", proc, count, noblock); down(&uvd->lock); /* See if a frame is completed, then use it. */ if ((uvd->frame[0].frameState == FrameState_Done) || (uvd->frame[0].frameState == FrameState_Done_Hold) || (uvd->frame[0].frameState == FrameState_Error)) { frmx = 0; } else if ((uvd->frame[1].frameState >= FrameState_Done) || (uvd->frame[1].frameState == FrameState_Done_Hold) || (uvd->frame[1].frameState >= FrameState_Done)) { frmx = 1; } /* FIXME: If we don't start a frame here then who ever does? */ if (noblock && (frmx == -1)) { count = -EAGAIN; goto read_done; } /* * If no FrameState_Done, look for a FrameState_Grabbing state. * See if a frame is in process (grabbing), then use it. * We will need to wait until it becomes cooked, of course. */ if (frmx == -1) { if (uvd->frame[0].frameState == FrameState_Grabbing) frmx = 0; else if (uvd->frame[1].frameState == FrameState_Grabbing) frmx = 1; } /* * If no frame is active, start one. We don't care which one * it will be, so #0 is as good as any. * In read access mode we don't have convenience of VIDIOCMCAPTURE * to specify the requested palette (video format) on per-frame * basis. This means that we have to return data in -some- format * and just hope that the client knows what to do with it. * The default format is configured in uvd->defaultPalette field * as one of VIDEO_PALETTE_xxx values. We stuff it into the new * frame and initiate the frame filling process. */ if (frmx == -1) { if (uvd->defaultPalette == 0) { err("%s: No default palette; don't know what to do!", proc); count = -EFAULT; goto read_done; } frmx = 0; /* * We have no per-frame control over video size. * Therefore we only can use whatever size was * specified as default. */ uvd->frame[frmx].request = uvd->videosize; uvd->frame[frmx].palette = uvd->defaultPalette; uvd->frame[frmx].frameState = FrameState_Ready; usbvideo_NewFrame(uvd, frmx); /* Now frame 0 is supposed to start filling... */ } /* * Get a pointer to the active frame. It is either previously * completed frame or frame in progress but not completed yet. */ frame = &uvd->frame[frmx]; /* * Sit back & wait until the frame gets filled and postprocessed. * If we fail to get the picture [in time] then return the error. * In this call we specify that we want the frame to be waited for, * postprocessed and switched into FrameState_Done_Hold state. This * state is used to hold the frame as "fully completed" between * subsequent partial reads of the same frame. */ if (frame->frameState != FrameState_Done_Hold) { long rv = -EFAULT; if (uvd->flags & FLAGS_NO_DECODING) rv = usbvideo_GetFrame(uvd, frmx); else if (VALID_CALLBACK(uvd, getFrame)) rv = GET_CALLBACK(uvd, getFrame)(uvd, frmx); else err("getFrame is not set"); if ((rv != 0) || (frame->frameState != FrameState_Done_Hold)) { count = rv; goto read_done; } } /* * Copy bytes to user space. We allow for partial reads, which * means that the user application can request read less than * the full frame size. It is up to the application to issue * subsequent calls until entire frame is read. * * First things first, make sure we don't copy more than we * have - even if the application wants more. That would be * a big security embarassment! */ if ((count + frame->seqRead_Index) > frame->seqRead_Length) count = frame->seqRead_Length - frame->seqRead_Index; /* * Copy requested amount of data to user space. We start * copying from the position where we last left it, which * will be zero for a new frame (not read before). */ if (copy_to_user(buf, frame->data + frame->seqRead_Index, count)) { count = -EFAULT; goto read_done; } /* Update last read position */ frame->seqRead_Index += count; if (uvd->debug >= 1) { err("%s: {copy} count used=%ld, new seqRead_Index=%ld", proc, count, frame->seqRead_Index); } /* Finally check if the frame is done with and "release" it */ if (frame->seqRead_Index >= frame->seqRead_Length) { /* All data has been read */ frame->seqRead_Index = 0; /* Mark it as available to be used again. */ uvd->frame[frmx].frameState = FrameState_Unused; if (usbvideo_NewFrame(uvd, frmx ? 0 : 1)) { err("%s: usbvideo_NewFrame failed.", proc); } } read_done: up(&uvd->lock); return count; } /* * Make all of the blocks of data contiguous */ static int usbvideo_CompressIsochronous(uvd_t *uvd, urb_t *urb) { char *cdata; int i, totlen = 0; for (i = 0; i < urb->number_of_packets; i++) { int n = urb->iso_frame_desc[i].actual_length; int st = urb->iso_frame_desc[i].status; cdata = urb->transfer_buffer + urb->iso_frame_desc[i].offset; /* Detect and ignore errored packets */ if (st < 0) { if (uvd->debug >= 1) err("Data error: packet=%d. len=%d. status=%d.", i, n, st); uvd->stats.iso_err_count++; continue; } /* Detect and ignore empty packets */ if (n <= 0) { uvd->stats.iso_skip_count++; continue; } totlen += n; /* Little local accounting */ RingQueue_Enqueue(&uvd->dp, cdata, n); } return totlen; } static void usbvideo_IsocIrq(struct urb *urb) { int i, len; uvd_t *uvd = urb->context; /* We don't want to do anything if we are about to be removed! */ if (!CAMERA_IS_OPERATIONAL(uvd)) return; #if 0 if (urb->actual_length > 0) { info("urb=$%p status=%d. errcount=%d. length=%d.", urb, urb->status, urb->error_count, urb->actual_length); } else { static int c = 0; if (c++ % 100 == 0) info("No Isoc data"); } #endif if (!uvd->streaming) { if (uvd->debug >= 1) info("Not streaming, but interrupt!"); return; } uvd->stats.urb_count++; if (urb->actual_length <= 0) goto urb_done_with; /* Copy the data received into ring queue */ len = usbvideo_CompressIsochronous(uvd, urb); uvd->stats.urb_length = len; if (len <= 0) goto urb_done_with; /* Here we got some data */ uvd->stats.data_count += len; RingQueue_WakeUpInterruptible(&uvd->dp); urb_done_with: for (i = 0; i < FRAMES_PER_DESC; i++) { urb->iso_frame_desc[i].status = 0; urb->iso_frame_desc[i].actual_length = 0; } return; } /* * usbvideo_StartDataPump() * * History: * 27-Jan-2000 Used ibmcam->iface, ibmcam->ifaceAltActive instead * of hardcoded values. Simplified by using for loop, * allowed any number of URBs. */ int usbvideo_StartDataPump(uvd_t *uvd) { static const char proc[] = "usbvideo_StartDataPump"; struct usb_device *dev = uvd->dev; int i, errFlag; if (uvd->debug > 1) info("%s($%p)", proc, uvd); if (!CAMERA_IS_OPERATIONAL(uvd)) { err("%s: Camera is not operational",proc); return -EFAULT; } uvd->curframe = -1; /* Alternate interface 1 is is the biggest frame size */ i = usb_set_interface(dev, uvd->iface, uvd->ifaceAltActive); if (i < 0) { err("%s: usb_set_interface error", proc); uvd->last_error = i; return -EBUSY; } if (VALID_CALLBACK(uvd, videoStart)) GET_CALLBACK(uvd, videoStart)(uvd); else err("%s: videoStart not set", proc); /* We double buffer the Iso lists */ for (i=0; i < USBVIDEO_NUMSBUF; i++) { int j, k; urb_t *urb = uvd->sbuf[i].urb; urb->dev = dev; urb->context = uvd; urb->pipe = usb_rcvisocpipe(dev, uvd->video_endp); urb->transfer_flags = USB_ISO_ASAP; urb->transfer_buffer = uvd->sbuf[i].data; urb->complete = usbvideo_IsocIrq; urb->number_of_packets = FRAMES_PER_DESC; urb->transfer_buffer_length = uvd->iso_packet_len * FRAMES_PER_DESC; for (j=k=0; j < FRAMES_PER_DESC; j++, k += uvd->iso_packet_len) { urb->iso_frame_desc[j].offset = k; urb->iso_frame_desc[j].length = uvd->iso_packet_len; } } /* Link URBs into a ring so that they invoke each other infinitely */ for (i=0; i < USBVIDEO_NUMSBUF; i++) { if ((i+1) < USBVIDEO_NUMSBUF) uvd->sbuf[i].urb->next = uvd->sbuf[i+1].urb; else uvd->sbuf[i].urb->next = uvd->sbuf[0].urb; } /* Submit all URBs */ for (i=0; i < USBVIDEO_NUMSBUF; i++) { errFlag = usb_submit_urb(uvd->sbuf[i].urb); if (errFlag) err("%s: usb_submit_isoc(%d) ret %d", proc, i, errFlag); } uvd->streaming = 1; if (uvd->debug > 1) info("%s: streaming=1 video_endp=$%02x", proc, uvd->video_endp); return 0; } /* * usbvideo_StopDataPump() * * This procedure stops streaming and deallocates URBs. Then it * activates zero-bandwidth alt. setting of the video interface. * * History: * 22-Jan-2000 Corrected order of actions to work after surprise removal. * 27-Jan-2000 Used uvd->iface, uvd->ifaceAltInactive instead of hardcoded values. */ void usbvideo_StopDataPump(uvd_t *uvd) { static const char proc[] = "usbvideo_StopDataPump"; int i, j; if (uvd->debug > 1) info("%s($%p)", proc, uvd); if ((uvd == NULL) || (!uvd->streaming) || (uvd->dev == NULL)) return; /* Unschedule all of the iso td's */ for (i=0; i < USBVIDEO_NUMSBUF; i++) { j = usb_unlink_urb(uvd->sbuf[i].urb); if (j < 0) err("%s: usb_unlink_urb() error %d.", proc, j); } if (uvd->debug > 1) info("%s: streaming=0", proc); uvd->streaming = 0; if (!uvd->remove_pending) { /* Invoke minidriver's magic to stop the camera */ if (VALID_CALLBACK(uvd, videoStop)) GET_CALLBACK(uvd, videoStop)(uvd); else err("%s: videoStop not set" ,proc); /* Set packet size to 0 */ j = usb_set_interface(uvd->dev, uvd->iface, uvd->ifaceAltInactive); if (j < 0) { err("%s: usb_set_interface() error %d.", proc, j); uvd->last_error = j; } } } /* * usbvideo_NewFrame() * * History: * 29-Mar-00 Added copying of previous frame into the current one. * 6-Aug-00 Added model 3 video sizes, removed redundant width, height. */ int usbvideo_NewFrame(uvd_t *uvd, int framenum) { usbvideo_frame_t *frame; int n; if (uvd->debug > 1) info("usbvideo_NewFrame($%p,%d.)", uvd, framenum); /* If we're not grabbing a frame right now and the other frame is */ /* ready to be grabbed into, then use it instead */ if (uvd->curframe != -1) return 0; /* If necessary we adjust picture settings between frames */ if (!uvd->settingsAdjusted) { if (VALID_CALLBACK(uvd, adjustPicture)) GET_CALLBACK(uvd, adjustPicture)(uvd); uvd->settingsAdjusted = 1; } n = (framenum - 1 + USBVIDEO_NUMFRAMES) % USBVIDEO_NUMFRAMES; if (uvd->frame[n].frameState == FrameState_Ready) framenum = n; frame = &uvd->frame[framenum]; frame->frameState = FrameState_Grabbing; frame->scanstate = ScanState_Scanning; frame->seqRead_Length = 0; /* Accumulated in xxx_parse_data() */ frame->deinterlace = Deinterlace_None; frame->flags = 0; /* No flags yet, up to minidriver (or us) to set them */ uvd->curframe = framenum; /* * Normally we would want to copy previous frame into the current one * before we even start filling it with data; this allows us to stop * filling at any moment; top portion of the frame will be new and * bottom portion will stay as it was in previous frame. If we don't * do that then missing chunks of video stream will result in flickering * portions of old data whatever it was before. * * If we choose not to copy previous frame (to, for example, save few * bus cycles - the frame can be pretty large!) then we have an option * to clear the frame before using. If we experience losses in this * mode then missing picture will be black (no flickering). * * Finally, if user chooses not to clean the current frame before * filling it with data then the old data will be visible if we fail * to refill entire frame with new data. */ if (!(uvd->flags & FLAGS_SEPARATE_FRAMES)) { /* This copies previous frame into this one to mask losses */ memmove(frame->data, uvd->frame[1-framenum].data, uvd->max_frame_size); } else { if (uvd->flags & FLAGS_CLEAN_FRAMES) { /* This provides a "clean" frame but slows things down */ memset(frame->data, 0, uvd->max_frame_size); } } return 0; } /* * usbvideo_CollectRawData() * * This procedure can be used instead of 'processData' callback if you * only want to dump the raw data from the camera into the output * device (frame buffer). You can look at it with V4L client, but the * image will be unwatchable. The main purpose of this code and of the * mode FLAGS_NO_DECODING is debugging and capturing of datastreams from * new, unknown cameras. This procedure will be automatically invoked * instead of the specified callback handler when uvd->flags has bit * FLAGS_NO_DECODING set. Therefore, any regular build of any driver * based on usbvideo can use this feature at any time. */ void usbvideo_CollectRawData(uvd_t *uvd, usbvideo_frame_t *frame) { int n; assert(uvd != NULL); assert(frame != NULL); /* Try to move data from queue into frame buffer */ n = RingQueue_GetLength(&uvd->dp); if (n > 0) { int m; /* See how much space we have left */ m = uvd->max_frame_size - frame->seqRead_Length; if (n > m) n = m; /* Now move that much data into frame buffer */ RingQueue_Dequeue( &uvd->dp, frame->data + frame->seqRead_Length, m); frame->seqRead_Length += m; } /* See if we filled the frame */ if (frame->seqRead_Length >= uvd->max_frame_size) { frame->frameState = FrameState_Done; uvd->curframe = -1; uvd->stats.frame_num++; } } int usbvideo_GetFrame(uvd_t *uvd, int frameNum) { static const char proc[] = "usbvideo_GetFrame"; usbvideo_frame_t *frame = &uvd->frame[frameNum]; if (uvd->debug >= 2) info("%s($%p,%d.)", proc, uvd, frameNum); switch (frame->frameState) { case FrameState_Unused: if (uvd->debug >= 2) info("%s: FrameState_Unused", proc); return -EINVAL; case FrameState_Ready: case FrameState_Grabbing: case FrameState_Error: { int ntries, signalPending; redo: if (!CAMERA_IS_OPERATIONAL(uvd)) { if (uvd->debug >= 2) info("%s: Camera is not operational (1)", proc); return -EIO; } ntries = 0; do { RingQueue_InterruptibleSleepOn(&uvd->dp); signalPending = signal_pending(current); if (!CAMERA_IS_OPERATIONAL(uvd)) { if (uvd->debug >= 2) info("%s: Camera is not operational (2)", proc); return -EIO; } assert(uvd->fbuf != NULL); if (signalPending) { if (uvd->debug >= 2) info("%s: Signal=$%08x", proc, signalPending); if (uvd->flags & FLAGS_RETRY_VIDIOCSYNC) { usbvideo_TestPattern(uvd, 1, 0); uvd->curframe = -1; uvd->stats.frame_num++; if (uvd->debug >= 2) info("%s: Forced test pattern screen", proc); return 0; } else { /* Standard answer: Interrupted! */ if (uvd->debug >= 2) info("%s: Interrupted!", proc); return -EINTR; } } else { /* No signals - we just got new data in dp queue */ if (uvd->flags & FLAGS_NO_DECODING) usbvideo_CollectRawData(uvd, frame); else if (VALID_CALLBACK(uvd, processData)) GET_CALLBACK(uvd, processData)(uvd, frame); else err("%s: processData not set", proc); } } while (frame->frameState == FrameState_Grabbing); if (uvd->debug >= 2) { info("%s: Grabbing done; state=%d. (%lu. bytes)", proc, frame->frameState, frame->seqRead_Length); } if (frame->frameState == FrameState_Error) { int ret = usbvideo_NewFrame(uvd, frameNum); if (ret < 0) { err("%s: usbvideo_NewFrame() failed (%d.)", proc, ret); return ret; } goto redo; } /* Note that we fall through to meet our destiny below */ } case FrameState_Done: /* * Do all necessary postprocessing of data prepared in * "interrupt" code and the collecting code above. The * frame gets marked as FrameState_Done by queue parsing code. * This status means that we collected enough data and * most likely processed it as we went through. However * the data may need postprocessing, such as deinterlacing * or picture adjustments implemented in software (horror!) * * As soon as the frame becomes "final" it gets promoted to * FrameState_Done_Hold status where it will remain until the * caller consumed all the video data from the frame. Then * the empty shell of ex-frame is thrown out for dogs to eat. * But we, worried about pets, will recycle the frame! */ uvd->stats.frame_num++; if ((uvd->flags & FLAGS_NO_DECODING) == 0) { if (VALID_CALLBACK(uvd, postProcess)) GET_CALLBACK(uvd, postProcess)(uvd, frame); if (frame->flags & USBVIDEO_FRAME_FLAG_SOFTWARE_CONTRAST) usbvideo_SoftwareContrastAdjustment(uvd, frame); } frame->frameState = FrameState_Done_Hold; if (uvd->debug >= 2) info("%s: Entered FrameState_Done_Hold state.", proc); return 0; case FrameState_Done_Hold: /* * We stay in this state indefinitely until someone external, * like ioctl() or read() call finishes digesting the frame * data. Then it will mark the frame as FrameState_Unused and * it will be released back into the wild to roam freely. */ if (uvd->debug >= 2) info("%s: FrameState_Done_Hold state.", proc); return 0; } /* Catch-all for other cases. We shall not be here. */ err("%s: Invalid state %d.", proc, frame->frameState); frame->frameState = FrameState_Unused; return 0; } /* * usbvideo_DeinterlaceFrame() * * This procedure deinterlaces the given frame. Some cameras produce * only half of scanlines - sometimes only even lines, sometimes only * odd lines. The deinterlacing method is stored in frame->deinterlace * variable. * * Here we scan the frame vertically and replace missing scanlines with * average between surrounding ones - before and after. If we have no * line above then we just copy next line. Similarly, if we need to * create a last line then preceding line is used. */ void usbvideo_DeinterlaceFrame(uvd_t *uvd, usbvideo_frame_t *frame) { if ((uvd == NULL) || (frame == NULL)) return; if ((frame->deinterlace == Deinterlace_FillEvenLines) || (frame->deinterlace == Deinterlace_FillOddLines)) { const int v4l_linesize = VIDEOSIZE_X(frame->request) * V4L_BYTES_PER_PIXEL; int i = (frame->deinterlace == Deinterlace_FillEvenLines) ? 0 : 1; for (; i < VIDEOSIZE_Y(frame->request); i += 2) { const unsigned char *fs1, *fs2; unsigned char *fd; int ip, in, j; /* Previous and next lines */ /* * Need to average lines before and after 'i'. * If we go out of bounds seeking those lines then * we point back to existing line. */ ip = i - 1; /* First, get rough numbers */ in = i + 1; /* Now validate */ if (ip < 0) ip = in; if (in >= VIDEOSIZE_Y(frame->request)) in = ip; /* Sanity check */ if ((ip < 0) || (in < 0) || (ip >= VIDEOSIZE_Y(frame->request)) || (in >= VIDEOSIZE_Y(frame->request))) { err("Error: ip=%d. in=%d. req.height=%ld.", ip, in, VIDEOSIZE_Y(frame->request)); break; } /* Now we need to average lines 'ip' and 'in' to produce line 'i' */ fs1 = frame->data + (v4l_linesize * ip); fs2 = frame->data + (v4l_linesize * in); fd = frame->data + (v4l_linesize * i); /* Average lines around destination */ for (j=0; j < v4l_linesize; j++) { fd[j] = (unsigned char)((((unsigned) fs1[j]) + ((unsigned)fs2[j])) >> 1); } } } /* Optionally display statistics on the screen */ if (uvd->flags & FLAGS_OVERLAY_STATS) usbvideo_OverlayStats(uvd, frame); } /* * usbvideo_SoftwareContrastAdjustment() * * This code adjusts the contrast of the frame, assuming RGB24 format. * As most software image processing, this job is CPU-intensive. * Get a camera that supports hardware adjustment! * * History: * 09-Feb-2001 Created. */ void usbvideo_SoftwareContrastAdjustment(uvd_t *uvd, usbvideo_frame_t *frame) { static const char proc[] = "usbvideo_SoftwareContrastAdjustment"; int i, j, v4l_linesize; signed long adj; const int ccm = 128; /* Color correction median - see below */ if ((uvd == NULL) || (frame == NULL)) { err("%s: Illegal call.", proc); return; } adj = (uvd->vpic.contrast - 0x8000) >> 8; /* -128..+127 = -ccm..+(ccm-1)*/ RESTRICT_TO_RANGE(adj, -ccm, ccm+1); if (adj == 0) { /* In rare case of no adjustment */ return; } v4l_linesize = VIDEOSIZE_X(frame->request) * V4L_BYTES_PER_PIXEL; for (i=0; i < VIDEOSIZE_Y(frame->request); i++) { unsigned char *fd = frame->data + (v4l_linesize * i); for (j=0; j < v4l_linesize; j++) { signed long v = (signed long) fd[j]; /* Magnify up to 2 times, reduce down to zero */ v = 128 + ((ccm + adj) * (v - 128)) / ccm; RESTRICT_TO_RANGE(v, 0, 0xFF); /* Must flatten tails */ fd[j] = (unsigned char) v; } } } /* * /proc interface * * We will be creating directories and entries under /proc/video using * external 'video_proc_entry' directory which is exported by videodev.o * module. Within that directory we will create $driver/ directory to * uniquely and uniformly refer to our specific $driver. Within that * directory we will finally create an entry that is named after the * video device node - video3, for example. The format of that file * is determined by callbacks that the minidriver may provide. If no * callbacks are provided (neither read nor write) then we don't create * the entry. * * Here is a sample directory entry: /proc/video/ibmcam/video3 * * The "file" video3 (in example above) is readable and writeable, in * theory. If the minidriver provides callbacks to do reading and * writing then both those procedures are supported. However if the * driver leaves callbacks in default (NULL) state the default * read and write handlers are used. The default read handler reports * that the driver does not support /proc fs. The default write handler * returns error code on any write attempt. */ #if USES_PROC_FS extern struct proc_dir_entry *video_proc_entry; static void usbvideo_procfs_level1_create(usbvideo_t *ut) { static const char proc[] = "usbvideo_procfs_level1_create"; if (ut == NULL) { err("%s: ut == NULL", proc); return; } if (video_proc_entry == NULL) { err("%s: /proc/video/ doesn't exist.", proc); return; } ut->procfs_dEntry = create_proc_entry(ut->drvName, S_IFDIR, video_proc_entry); if (ut->procfs_dEntry != NULL) { if (ut->md_module != NULL) ut->procfs_dEntry->owner = ut->md_module; } else { err("%s: Unable to initialize /proc/video/%s", proc, ut->drvName); } } static void usbvideo_procfs_level1_destroy(usbvideo_t *ut) { static const char proc[] = "usbvideo_procfs_level1_destroy"; if (ut == NULL) { err("%s: ut == NULL", proc); return; } if (ut->procfs_dEntry != NULL) { remove_proc_entry(ut->drvName, video_proc_entry); ut->procfs_dEntry = NULL; } } static void usbvideo_procfs_level2_create(uvd_t *uvd) { static const char proc[] = "usbvideo_procfs_level2_create"; if (uvd == NULL) { err("%s: uvd == NULL", proc); return; } assert(uvd->handle != NULL); if (uvd->handle->procfs_dEntry == NULL) { err("%s: uvd->handle->procfs_dEntry == NULL", proc); return; } sprintf(uvd->videoName, "video%d", uvd->vdev.minor); uvd->procfs_vEntry = create_proc_entry( uvd->videoName, S_IFREG | S_IRUGO | S_IWUSR, uvd->handle->procfs_dEntry); if (uvd->procfs_vEntry != NULL) { uvd->procfs_vEntry->data = uvd; uvd->procfs_vEntry->read_proc = uvd->handle->cb.procfs_read; uvd->procfs_vEntry->write_proc = uvd->handle->cb.procfs_write; } else { err("%s: Failed to create entry \"%s\"", proc, uvd->videoName); } } static void usbvideo_procfs_level2_destroy(uvd_t *uvd) { static const char proc[] = "usbvideo_procfs_level2_destroy"; if (uvd == NULL) { err("%s: uvd == NULL", proc); return; } if (uvd->procfs_vEntry != NULL) { remove_proc_entry(uvd->videoName, uvd->procfs_vEntry); uvd->procfs_vEntry = NULL; } } static int usbvideo_default_procfs_read_proc( char *page, char **start, off_t off, int count, int *eof, void *data) { char *out = page; int len; /* Stay under PAGE_SIZE or else */ out += sprintf(out, "This driver does not support /proc services.\n"); len = out - page; len -= off; if (len < count) { *eof = 1; if (len <= 0) return 0; } else len = count; *start = page + off; return len; } static int usbvideo_default_procfs_write_proc( struct file *file, const char *buffer, unsigned long count, void *data) { return -EINVAL; } #endif /* USES_PROC_FS */ MODULE_LICENSE("GPL");