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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
usbvideo.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：64k
源码类别：

Linux/Unix编程

开发平台：

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