开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
usbvideo.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：64k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

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