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

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

嵌入式Linux

开发平台：

Unix_Linux

pwc-if.c：源码内容
  1. /* Linux driver for Philips webcam 
  2.    USB and Video4Linux interface part.
  3.    (C) 1999-2001 Nemosoft Unv.
  5.    This program is free software; you can redistribute it and/or modify
  6.    it under the terms of the GNU General Public License as published by
  7.    the Free Software Foundation; either version 2 of the License, or
  8.    (at your option) any later version.
  10.    This program is distributed in the hope that it will be useful,
  11.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.    GNU General Public License for more details.
  15.    You should have received a copy of the GNU General Public License
  16.    along with this program; if not, write to the Free Software
  17.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19. */
  21. /*  
  22.    This code forms the interface between the USB layers and the Philips
  23.    specific stuff. Some adanved stuff of the driver falls under an
  24.    NDA, signed between me and Philips B.V., Eindhoven, the Netherlands, and
  25.    is thus not distributed in source form. The binary pwcx.o module 
  26.    contains the code that falls under the NDA.
  27.    
  28.    In case you're wondering: 'pwc' stands for "Philips WebCam", but 
  29.    I really didn't want to type 'philips_web_cam' every time (I'm lazy as
  30.    any Linux kernel hacker, but I don't like uncomprehensible abbreviations
  31.    without explanation).
  32.    
  33.    Oh yes, convention: to disctinguish between all the various pointers to
  34.    device-structures, I use these names for the pointer variables:
  35.    udev: struct usb_device *
  36.    vdev: struct video_device *
  37.    pdev: struct pwc_devive *
  38. */
  40. /* Contributors:
  41.    - Alvarado: adding whitebalance code
  42.    - Alistar Moire: QuickCam 3000 Pro device/product ID
  43.    - Tony Hoyle: Creative Labs Webcam 5 device/product ID
  44.    - Mark Burazin: solving hang in VIDIOCSYNC when camera gets unplugged
  45.    - Jk Fang: SOTEC device/product ID
  46. */
  48. #include <linux/errno.h>
  49. #include <linux/init.h>
  50. #include <linux/module.h>
  51. #include <linux/poll.h>
  52. #include <linux/slab.h>
  53. #include <linux/vmalloc.h>
  54. #include <linux/wrapper.h>
  55. #include <asm/io.h>
  57. #include "pwc.h"
  58. #include "pwc-ioctl.h"
  59. #include "pwc-uncompress.h"
  61. #if !defined(MAP_NR)
  62. #define MAP_NR(a) virt_to_page(a)
  63. #endif
  65. /* Function prototypes and driver templates */
  67. /* hotplug device table support */
  68. static __devinitdata struct usb_device_id pwc_device_table [] = {
  69. { USB_DEVICE(0x0471, 0x0302) },
  70. { USB_DEVICE(0x0471, 0x0303) },
  71. { USB_DEVICE(0x0471, 0x0304) },
  72. { USB_DEVICE(0x0471, 0x0307) },
  73. { USB_DEVICE(0x0471, 0x0308) },
  74. { USB_DEVICE(0x0471, 0x030C) },
  75. { USB_DEVICE(0x0471, 0x0310) },
  76. { USB_DEVICE(0x0471, 0x0311) },
  77. { USB_DEVICE(0x0471, 0x0312) },
  78. { USB_DEVICE(0x069A, 0x0001) },
  79. { USB_DEVICE(0x046D, 0x08b0) },
  80. { USB_DEVICE(0x055D, 0x9000) },
  81. { USB_DEVICE(0x055D, 0x9001) },
  82. { USB_DEVICE(0x041E, 0x400C) },
  83. { USB_DEVICE(0x04CC, 0x8116) },
  84. { }
  85. };
  86. MODULE_DEVICE_TABLE(usb, pwc_device_table);
  88. static void *usb_pwc_probe(struct usb_device *udev, unsigned int ifnum, const struct usb_device_id *id);
  89. static void usb_pwc_disconnect(struct usb_device *udev, void *ptr);
  91. static struct usb_driver pwc_driver =
  92. {
  93. name: "Philips webcam", /* name */
  94. id_table: pwc_device_table,
  95. probe: usb_pwc_probe, /* probe() */
  96. disconnect: usb_pwc_disconnect, /* disconnect() */
  97. };
  99. #define MAX_DEV_HINTS 10
  101. static int default_size = PSZ_QCIF;
  102. static int default_fps = 10;
  103. static int default_palette = VIDEO_PALETTE_YUV420P; /* This format is understood by most tools */
  104. static int default_fbufs = 3;   /* Default number of frame buffers */
  105. static int default_mbufs = 2; /* Default number of mmap() buffers */
  106.        int pwc_trace = TRACE_MODULE | TRACE_FLOW | TRACE_PWCX;
  107. static int power_save = 0;
  108. static int led_on = 1, led_off = 0; /* defaults to LED that is on while in use */
  109.        int pwc_preferred_compression = 2; /* 0..3 = uncompressed..high */
  110. static struct {
  111. int type;
  112. char serial_number[30];
  113. int device_node;
  114. struct pwc_device *pdev;
  115. } device_hint[MAX_DEV_HINTS];
  117. static struct semaphore mem_lock;
  118. static void *mem_leak = NULL; /* For delayed kfree()s. See below */
  120. /***/
  122. static int  pwc_video_open(struct video_device *vdev, int mode);
  123. static void pwc_video_close(struct video_device *vdev);
  124. static long pwc_video_read(struct video_device *vdev, char *buf, unsigned long count, int noblock);
  125. static long pwc_video_write(struct video_device *vdev, const char *buf, unsigned long count, int noblock);
  126. static unsigned int pwc_video_poll(struct video_device *vdev, struct file *file, poll_table *wait);
  127. static int  pwc_video_ioctl(struct video_device *vdev, unsigned int cmd, void *arg);
  128. static int  pwc_video_mmap(struct video_device *dev, const char *adr, unsigned long size);
  130. static struct video_device pwc_template = {
  131. owner: THIS_MODULE,
  132. name: "Philips Webcam", /* Filled in later */
  133. type: VID_TYPE_CAPTURE,
  134. hardware: VID_HARDWARE_PWC,
  135. open: pwc_video_open,
  136. close: pwc_video_close,
  137. read: pwc_video_read,
  138. write: pwc_video_write,
  139. poll: pwc_video_poll,
  140. ioctl: pwc_video_ioctl,
  141. mmap: pwc_video_mmap,
  142. initialize: NULL, /* initialize */
  143. minor: 0 /* minor */
  144. };
  146. /***************************************************************************/
  148. /* Okay, this is some magic that I worked out and the reasoning behind it...
  150.    The biggest problem with any USB device is of course: "what to do 
  151.    when the user unplugs the device while it is in use by an application?"
  152.    We have several options:
  153.    1) Curse them with the 7 plagues when they do (requires divine intervention)
  154.    2) Tell them not to (won't work: they'll do it anyway)
  155.    3) Oops the kernel (this will have a negative effect on a user's uptime)
  156.    4) Do something sensible.
  157.    
  158.    Of course, we go for option 4.
  160.    It happens that this device will be linked to two times, once from
  161.    usb_device and once from the video_device in their respective 'private'
  162.    pointers. This is done when the device is probed() and all initialization
  163.    succeeded. The pwc_device struct links back to both structures.
  165.    When a device is unplugged while in use it will be removed from the 
  166.    list of known USB devices; I also de-register as a V4L device, but 
  167.    unfortunately I can't free the memory since the struct is still in use
  168.    by the file descriptor. This free-ing is then deferend until the first
  169.    opportunity. Crude, but it works.
  170.    
  171.    A small 'advantage' is that if a user unplugs the cam and plugs it back
  172.    in, it should get assigned the same video device minor, but unfortunately
  173.    it's non-trivial to re-link the cam back to the video device... (that 
  174.    would surely be magic! :))
  175. */
  177. /***************************************************************************/
  178. /* Private functions */
  180. /* Memory management functions, nicked from cpia.c, which nicked them from
  181.    bttv.c. So far, I've counted duplication of this code 6 times 
  182.    (bttv, cpia, ibmcam, ov511, pwc, ieee1394).
  183.  */
  185. /* Given PGD from the address space's page table, return the kernel
  186.  * virtual mapping of the physical memory mapped at ADR.
  187.  */
  188. static inline unsigned long uvirt_to_kva(pgd_t *pgd, unsigned long adr)
  189. {
  190.         unsigned long ret = 0UL;
  191. pmd_t *pmd;
  192. pte_t *ptep, pte;
  193.   
  194. if (!pgd_none(*pgd)) {
  195.                 pmd = pmd_offset(pgd, adr);
  196.                 if (!pmd_none(*pmd)) {
  197.                         ptep = pte_offset(pmd, adr);
  198.                         pte = *ptep;
  199.                         if(pte_present(pte)) {
  200. ret  = (unsigned long) page_address(pte_page(pte));
  201. ret |= (adr & (PAGE_SIZE - 1));
  203. }
  204.                 }
  205.         }
  206. return ret;
  207. }
  211. /* Here we want the physical address of the memory.
  212.  * This is used when initializing the contents of the
  213.  * area and marking the pages as reserved.
  214.  */
  215. static inline unsigned long kvirt_to_pa(unsigned long adr) 
  216. {
  217.         unsigned long va, kva, ret;
  219.         va = VMALLOC_VMADDR(adr);
  220.         kva = uvirt_to_kva(pgd_offset_k(va), va);
  221. ret = __pa(kva);
  222.         return ret;
  223. }
  225. static void * rvmalloc(signed long size)
  226. {
  227. void * mem;
  228. unsigned long adr, page;
  230.         /* Round it off to PAGE_SIZE */
  231.         size += (PAGE_SIZE - 1);
  232.         size &= ~(PAGE_SIZE - 1);
  233.         
  234.         mem=vmalloc_32(size);
  235. if (mem) 
  236. {
  237. memset(mem, 0, size); /* Clear the ram out, no junk to the user */
  238.         adr=(unsigned long) mem;
  239. while (size > 0) 
  240.                 {
  241.                 page = kvirt_to_pa(adr);
  242. mem_map_reserve(virt_to_page(__va(page)));
  243. adr+=PAGE_SIZE;
  244. size-=PAGE_SIZE;
  245. }
  246. }
  247. return mem;
  248. }
  250. static void rvfree(void * mem, signed long size)
  251. {
  252.         unsigned long adr, page;
  253.         
  254.         /* Round it off to PAGE_SIZE */
  255.         size += (PAGE_SIZE - 1);
  256.         size &= ~(PAGE_SIZE - 1);
  257. if (mem) 
  258. {
  259.         adr=(unsigned long) mem;
  260. while (size > 0) 
  261.                 {
  262.                 page = kvirt_to_pa(adr);
  263. mem_map_unreserve(virt_to_page(__va(page)));
  264. adr+=PAGE_SIZE;
  265. size-=PAGE_SIZE;
  266. }
  267. vfree(mem);
  268. }
  269. }
  274. static int pwc_allocate_buffers(struct pwc_device *pdev)
  275. {
  276. int i;
  277. void *kbuf;
  279. Trace(TRACE_MEMORY, "Entering allocate_buffers(%p).n", pdev);
  281. if (pdev == NULL)
  282. return -ENXIO;
  284. #ifdef PWC_MAGIC
  285. if (pdev->magic != PWC_MAGIC) {
  286. Err("allocate_buffers(): magic failed.n");
  287. return -ENXIO;
  288. }
  289. #endif
  290. /* Allocate Isochronuous pipe buffers */
  291. for (i = 0; i < MAX_ISO_BUFS; i++) {
  292. if (pdev->sbuf[i].data == NULL) {
  293. kbuf = kmalloc(ISO_BUFFER_SIZE, GFP_KERNEL);
  294. if (kbuf == NULL) {
  295. Err("Failed to allocate iso buffer %d.n", i);
  296. return -ENOMEM;
  297. }
  298. Trace(TRACE_MEMORY, "Allocated iso buffer at %p.n", kbuf);
  299. pdev->sbuf[i].data = kbuf;
  300. memset(kbuf, 0, ISO_BUFFER_SIZE);
  301. }
  302. }
  304. /* Allocate frame buffer structure */
  305. if (pdev->fbuf == NULL) {
  306. kbuf = kmalloc(default_fbufs * sizeof(struct pwc_frame_buf), GFP_KERNEL);
  307. if (kbuf == NULL) {
  308. Err("Failed to allocate frame buffer structure.n");
  309. return -ENOMEM;
  310. }
  311. Trace(TRACE_MEMORY, "Allocated frame buffer structure at %p.n", kbuf);
  312. pdev->fbuf = kbuf;
  313. memset(kbuf, 0, default_fbufs * sizeof(struct pwc_frame_buf));
  314. }
  315. /* create frame buffers, and make circular ring */
  316. for (i = 0; i < default_fbufs; i++) {
  317. if (pdev->fbuf[i].data == NULL) {
  318. kbuf = vmalloc(PWC_FRAME_SIZE); /* need vmalloc since frame buffer > 128K */
  319. if (kbuf == NULL) {
  320. Err("Failed to allocate frame buffer %d.n", i);
  321. return -ENOMEM;
  322. }
  323. Trace(TRACE_MEMORY, "Allocated frame buffer %d at %p.n", i, kbuf);
  324. pdev->fbuf[i].data = kbuf;
  325. memset(kbuf, 128, PWC_FRAME_SIZE);
  326. }
  327. }
  329. /* Allocate decompressor table space */
  330. kbuf = NULL;
  331. if (pdev->decompressor != NULL) {
  332. kbuf = kmalloc(pdev->decompressor->table_size, GFP_KERNEL);
  333. if (kbuf == NULL) {
  334. Err("Failed to allocate decompress table.n");
  335. return -ENOMEM;
  336. }
  337. Trace(TRACE_MEMORY, "Allocated decompress table %p.n", kbuf);
  338. }
  339. pdev->decompress_data = kbuf;
  341. /* Allocate image buffer; double buffer for mmap() */
  342. kbuf = rvmalloc(default_mbufs * pdev->len_per_image);
  343. if (kbuf == NULL) {
  344. Err("Failed to allocate image buffer(s).n");
  345. return -ENOMEM;
  346. }
  347. Trace(TRACE_MEMORY, "Allocated image buffer at %p.n", kbuf);
  348. pdev->image_data = kbuf;
  349. for (i = 0; i < default_mbufs; i++)
  350. pdev->image_ptr[i] = kbuf + i * pdev->len_per_image;
  351. for (; i < MAX_IMAGES; i++)
  352. pdev->image_ptr[i] = NULL;
  354. Trace(TRACE_MEMORY, "Leaving pwc_allocate_buffers().n");
  355. return 0;
  356. }
  358. static void pwc_free_buffers(struct pwc_device *pdev)
  359. {
  360. int i;
  362. Trace(TRACE_MEMORY, "Entering free_buffers(%p).n", pdev);
  364. if (pdev == NULL)
  365. return;
  366. #ifdef PWC_MAGIC
  367. if (pdev->magic != PWC_MAGIC) {
  368. Err("free_buffers(): magic failed.n");
  369. return;
  370. }
  371. #endif
  373. /* Release Iso-pipe buffers */
  374. for (i = 0; i < MAX_ISO_BUFS; i++)
  375. if (pdev->sbuf[i].data != NULL) {
  376. Trace(TRACE_MEMORY, "Freeing ISO buffer at %p.n", pdev->sbuf[i].data);
  377. kfree(pdev->sbuf[i].data);
  378. pdev->sbuf[i].data = NULL;
  379. }
  381. /* The same for frame buffers */
  382. if (pdev->fbuf != NULL) {
  383. for (i = 0; i < default_fbufs; i++) {
  384. if (pdev->fbuf[i].data != NULL) {
  385. Trace(TRACE_MEMORY, "Freeing frame buffer %d at %p.n", i, pdev->fbuf[i].data);
  386. vfree(pdev->fbuf[i].data);
  387. pdev->fbuf[i].data = NULL;
  388. }
  389. }
  390. kfree(pdev->fbuf);
  391. pdev->fbuf = NULL;
  392. }
  394. /* Intermediate decompression buffer & tables */
  395. if (pdev->decompress_data != NULL) {
  396. Trace(TRACE_MEMORY, "Freeing decompression buffer at %p.n", pdev->decompress_data);
  397. kfree(pdev->decompress_data);
  398. pdev->decompress_data = NULL;
  399. }
  400. pdev->decompressor = NULL;
  402. /* Release image buffers */
  403. if (pdev->image_data != NULL) {
  404. Trace(TRACE_MEMORY, "Freeing image buffer at %p.n", pdev->image_data);
  405. rvfree(pdev->image_data, default_mbufs * pdev->len_per_image);
  406. }
  407. pdev->image_data = NULL;
  408. Trace(TRACE_MEMORY, "Leaving free_buffers().n");
  409. }
  411. /* The frame & image buffer mess. 
  413.    Yes, this is a mess. Well, it used to be simple, but alas...  In this
  414.    module, 3 buffers schemes are used to get the data from the USB bus to
  415.    the user program. The first scheme involves the ISO buffers (called thus
  416.    since they transport ISO data from the USB controller), and not really
  417.    interesting. Suffices to say the data from this buffer is quickly 
  418.    gathered in an interrupt handler (pwc_isoc_handler) and placed into the 
  419.    frame buffer.
  420.    
  421.    The frame buffer is the second scheme, and is the central element here.
  422.    It collects the data from a single frame from the camera (hence, the
  423.    name). Frames are delimited by the USB camera with a short USB packet,
  424.    so that's easy to detect. The frame buffers form a list that is filled
  425.    by the camera+USB controller and drained by the user process through 
  426.    either read() or mmap().
  427.    
  428.    The image buffer is the third scheme, in which frames are decompressed
  429.    and possibly converted into planar format. For mmap() there is more than
  430.    one image buffer available.
  432.    The frame buffers provide the image buffering, in case the user process
  433.    is a bit slow. This introduces lag and some undesired side-effects.
  434.    The problem arises when the frame buffer is full. I used to drop the last 
  435.    frame, which makes the data in the queue stale very quickly. But dropping 
  436.    the frame at the head of the queue proved to be a litte bit more difficult.
  437.    I tried a circular linked scheme, but this introduced more problems than
  438.    it solved.
  440.    Because filling and draining are completely asynchronous processes, this
  441.    requires some fiddling with pointers and mutexes.
  442.    
  443.    Eventually, I came up with a system with 2 lists: an 'empty' frame list
  444.    and a 'full' frame list:
  445.      * Initially, all frame buffers but one are on the 'empty' list; the one
  446.        remaining buffer is our initial fill frame.
  447.      * If a frame is needed for filling, we take it from the 'empty' list, 
  448.        unless that list is empty, in which case we take the buffer at the 
  449.        head of the 'full' list.
  450.      * When our fill buffer has been filled, it is appended to the 'full' 
  451.        list.
  452.      * If a frame is needed by read() or mmap(), it is taken from the head of 
  453.        the 'full' list, handled, and then appended to the 'empty' list. If no
  454.        buffer is present on the 'full' list, we wait.
  455.    The advantage is that the buffer that is currently being decompressed/
  456.    converted, is on neither list, and thus not in our way (any other scheme 
  457.    I tried had the problem of old data lingering in the queue).
  459.    Whatever strategy you choose, it always remains a tradeoff: with more
  460.    frame buffers the chances of a missed frame are reduced. On the other
  461.    hand, on slower machines it introduces lag because the queue will 
  462.    always be full.
  463.  */
  465. /**
  466.   brief Find next frame buffer to fill. Take from empty or full list, whichever comes first.
  467.  */
  468. static inline int pwc_next_fill_frame(struct pwc_device *pdev)
  469. {
  470. int ret;
  471. unsigned long flags;
  473. ret = 0;
  474. spin_lock_irqsave(&pdev->ptrlock, flags);
  475. if (pdev->fill_frame != NULL) {
  476. /* append to 'full' list */
  477. if (pdev->full_frames == NULL) {
  478. pdev->full_frames = pdev->fill_frame;
  479. pdev->full_frames_tail = pdev->full_frames;
  480. }
  481. else {
  482. pdev->full_frames_tail->next = pdev->fill_frame;
  483. pdev->full_frames_tail = pdev->fill_frame;
  484. }
  485. }
  486. if (pdev->empty_frames != NULL) {
  487. /* We have empty frames available. That's easy */
  488. pdev->fill_frame = pdev->empty_frames;
  489. pdev->empty_frames = pdev->empty_frames->next;
  490. }
  491. else {
  492. /* Hmm. Take it from the full list */
  493. #if PWC_DEBUG
  494. /* sanity check */
  495. if (pdev->full_frames == NULL) {
  496. Err("Neither empty or full frames available!n");
  497. spin_unlock_irqrestore(&pdev->ptrlock, flags);
  498. return -EINVAL;
  499. }
  500. #endif
  501. pdev->fill_frame = pdev->full_frames;
  502. pdev->full_frames = pdev->full_frames->next;
  503. ret = 1;
  504. }
  505. pdev->fill_frame->next = NULL;
  506. #if PWC_DEBUG
  507. Trace(TRACE_SEQUENCE, "Assigning sequence number %d.n", pdev->sequence);
  508. pdev->fill_frame->sequence = pdev->sequence++;
  509. #endif
  510. spin_unlock_irqrestore(&pdev->ptrlock, flags);
  511. return ret;
  512. }
  513.  
  515. /**
  516.   brief Reset all buffers, pointers and lists, except for the image_used[] buffer. 
  517.   
  518.   If the image_used[] buffer is cleared too, mmap()/VIDIOCSYNC will run into trouble.
  519.  */
  520. static void pwc_reset_buffers(struct pwc_device *pdev)
  521. {
  522. int i;
  523. unsigned long flags;
  525. spin_lock_irqsave(&pdev->ptrlock, flags);
  526. pdev->full_frames = NULL;
  527. pdev->full_frames_tail = NULL;
  528. for (i = 0; i < default_fbufs; i++) {
  529. pdev->fbuf[i].filled = 0;
  530. if (i > 0)
  531. pdev->fbuf[i].next = &pdev->fbuf[i - 1];
  532. else
  533. pdev->fbuf->next = NULL;
  534. }
  535. pdev->empty_frames = &pdev->fbuf[default_fbufs - 1];
  536. pdev->empty_frames_tail = pdev->fbuf;
  537. pdev->read_frame = NULL;
  538. pdev->fill_frame = pdev->empty_frames;
  539. pdev->empty_frames = pdev->empty_frames->next;
  541. pdev->image_read_pos = 0;
  542. pdev->fill_image = 0;
  543. spin_unlock_irqrestore(&pdev->ptrlock, flags);
  544. }
  547. /**
  548.   brief Do all the handling for getting one frame: get pointer, decompress, advance pointers.
  549.  */
  550. static int pwc_handle_frame(struct pwc_device *pdev)
  551. {
  552. int ret = 0;
  553. unsigned long flags;
  555. spin_lock_irqsave(&pdev->ptrlock, flags);
  556. /* First grab our read_frame; this is removed from all lists, so
  557.    we can release the lock after this without problems */
  558. if (pdev->read_frame != NULL) {
  559. /* This can't theoretically happen */
  560. Err("Huh? Read frame still in use?n");
  561. }
  562. else {
  563. if (pdev->full_frames == NULL) {
  564. Err("Woops. No frames ready.n");
  565. }
  566. else {
  567. pdev->read_frame = pdev->full_frames;
  568. pdev->full_frames = pdev->full_frames->next;
  569. pdev->read_frame->next = NULL;
  570. }
  572. if (pdev->read_frame != NULL) {
  573. #if PWC_DEBUG
  574. Trace(TRACE_SEQUENCE, "Decompressing frame %dn", pdev->read_frame->sequence);
  575. #endif
  576. /* Decompression is a lenghty process, so it's outside of the lock.
  577.    This gives the isoc_handler the opportunity to fill more frames 
  578.    in the mean time.
  579. */
  580. spin_unlock_irqrestore(&pdev->ptrlock, flags);
  581. ret = pwc_decompress(pdev);
  582. spin_lock_irqsave(&pdev->ptrlock, flags);
  584. /* We're done with read_buffer, tack it to the end of the empty buffer list */
  585. if (pdev->empty_frames == NULL) {
  586. pdev->empty_frames = pdev->read_frame;
  587. pdev->empty_frames_tail = pdev->empty_frames;
  588. }
  589. else {
  590. pdev->empty_frames_tail->next = pdev->read_frame;
  591. pdev->empty_frames_tail = pdev->read_frame;
  592. }
  593. pdev->read_frame = NULL;
  594. }
  595. }
  596. spin_unlock_irqrestore(&pdev->ptrlock, flags);
  597. return ret;
  598. }
  600. /**
  601.   brief Advance pointers of image buffer (after each user request) 
  602. */
  603. static inline void pwc_next_image(struct pwc_device *pdev)
  604. {
  605. pdev->image_used[pdev->fill_image] = 0;
  606. pdev->fill_image = (pdev->fill_image + 1) % default_mbufs;
  607. }
  609. /* 2001-10-14: The YUV420 is still there, but you can only set it from within 
  610.    a program (YUV420P being the default) */
  611. static int pwc_set_palette(struct pwc_device *pdev, int pal)
  612. {
  613. if (   pal == VIDEO_PALETTE_YUV420
  614.             || pal == VIDEO_PALETTE_YUV420P
  615. #if PWC_DEBUG
  616.             || pal == VIDEO_PALETTE_RAW
  617. #endif
  618. ) {
  619. pdev->vpalette = pal;
  620. pwc_set_image_buffer_size(pdev);
  621. return 0;
  622. }
  623. Trace(TRACE_READ, "Palette %d not supported.n", pal);
  624. return -1;
  625. }
  629. /* This gets called for the Isochronous pipe (video). This is done in
  630.  * interrupt time, so it has to be fast, not crash, and not stall. Neat.
  631.  */
  632. static void pwc_isoc_handler(purb_t urb)
  633. {
  634. struct pwc_device *pdev;
  635. int i, fst, flen;
  636. int awake;
  637. struct pwc_frame_buf *fbuf;
  638. unsigned char *fillptr, *iso_buf;
  640. pdev = (struct pwc_device *)urb->context;
  641. if (pdev == NULL) {
  642. Err("isoc_handler() called with NULL device?!n");
  643. return;
  644. }
  645. #ifdef PWC_MAGIC
  646. if (pdev->magic != PWC_MAGIC) {
  647. Err("isoc_handler() called with bad magic!n");
  648. return;
  649. }
  650. #endif
  651. if (urb->status == -ENOENT || urb->status == -ECONNRESET) {
  652. Trace(TRACE_OPEN, "pwc_isoc_handler(): URB unlinked.n");
  653. return;
  654. }
  655. if (urb->status != -EINPROGRESS && urb->status != 0) {
  656. char *errmsg;
  658. errmsg = "Unknown";
  659. switch(urb->status) {
  660. case -ENOSR: errmsg = "Buffer error (overrun)"; break;
  661. case -EPIPE: errmsg = "Stalled (device not responding)"; break;
  662. case -EOVERFLOW: errmsg = "Babble (bad cable?)"; break;
  663. case -EPROTO: errmsg = "Bit-stuff error (bad cable?)"; break;
  664. case -EILSEQ: errmsg = "CRC/Timeout"; break;
  665. case -ETIMEDOUT: errmsg = "NAK (device does not respond)"; break;
  666. }
  667. Trace(TRACE_FLOW, "pwc_isoc_handler() called with status %d [%s].n", urb->status, errmsg);
  668. return;
  669. }
  671. fbuf = pdev->fill_frame;
  672. if (fbuf == NULL) {
  673. Err("pwc_isoc_handler without valid fill frame.n");
  674. wake_up_interruptible(&pdev->frameq);
  675. return;
  676. }
  677. fillptr = fbuf->data + fbuf->filled;
  678. awake = 0;
  680. /* vsync: 0 = don't copy data
  681.           1 = sync-hunt
  682.           2 = synched 
  683.  */
  684. /* Compact data */
  685. for (i = 0; i < urb->number_of_packets; i++) {
  686. fst  = urb->iso_frame_desc[i].status;
  687. flen = urb->iso_frame_desc[i].actual_length;
  688. iso_buf = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
  689. if (fst == 0) {
  690. if (flen > 0) { /* if valid data... */
  691. if (pdev->vsync > 0) { /* ...and we are not sync-hunting... */
  692. pdev->vsync = 2;
  694. /* ...copy data to frame buffer, if possible */
  695. if (flen + fbuf->filled > pdev->frame_size) {
  696. Trace(TRACE_FLOW, "Frame buffer overflow (flen = %d, frame_size = %d).n", flen, pdev->frame_size);
  697. pdev->vsync = 0; /* Hmm, let's wait for an EOF (end-of-frame) */
  698. pdev->vframes_error++;
  699. }
  700. else {
  701. memmove(fillptr, iso_buf, flen);
  702. fillptr += flen;
  703. }
  704. }
  705. fbuf->filled += flen;
  706. } /* ..flen > 0 */
  708. if (flen < pdev->vlast_packet_size) {
  709. /* Shorter packet... We probably have the end of an image-frame; 
  710.    wake up read() process and let select()/poll() do something.
  711.    Decompression is done in user time over there. 
  712.  */
  713. if (pdev->vsync == 2) {
  714. /* The ToUCam Fun CMOS sensor causes the firmware to send 2 or 3 bogus 
  715.    frames on the USB wire after an exposure change. This conditition is 
  716.    however detected  in the cam and a bit is set in the header.
  717.  */
  718. if (pdev->type == 730) {
  719. unsigned char *ptr = (unsigned char *)fbuf->data;
  721. if (ptr[1] == 1 && ptr[0] & 0x10) {
  722. #if PWC_DEBUG
  723. Debug("Hyundai CMOS sensor bug. Dropping frame %d.n", fbuf->sequence);
  724. #endif
  725. pdev->drop_frames = 2;
  726. pdev->vframes_error++;
  727. }
  728. /* Sometimes the trailer of the 730 is still sent as a 4 byte packet 
  729.    after a short frame; this condition is filtered out specifically. A 4 byte
  730.    frame doesn't make sense anyway.
  731.    So we get either this sequence: 
  732.     drop_bit set -> 4 byte frame -> short frame -> good frame
  733.    Or this one:
  734.     drop_bit set -> short frame -> good frame
  735.    So we drop either 3 or 2 frames in all!
  736.  */
  737. if (fbuf->filled == 4)
  738. pdev->drop_frames++;
  739. }
  741. /* In case we were instructed to drop the frame, do so silently.
  742.    The buffer pointers are not updated either (but the counters are reset below).
  743.  */
  744. if (pdev->drop_frames)
  745. pdev->drop_frames--;
  746. else {
  747. /* Check for underflow first */
  748. if (fbuf->filled < pdev->frame_size) {
  749. Trace(TRACE_FLOW, "Frame buffer underflow (%d bytes); discarded.n", fbuf->filled);
  750. pdev->vframes_error++;
  751. }
  752. else {
  753. /* Send only once per EOF */
  754. awake = 1; /* delay wake_ups */
  756. /* Find our next frame to fill. This will always succeed, since we
  757.  * nick a frame from either empty or full list, but if we had to
  758.  * take it from the full list, it means a frame got dropped.
  759.  */
  760. if (pwc_next_fill_frame(pdev)) {
  761. pdev->vframes_dumped++;
  762. if ((pdev->vframe_count > FRAME_LOWMARK) && (pwc_trace & TRACE_FLOW)) {
  763. if (pdev->vframes_dumped < 20)
  764. Trace(TRACE_FLOW, "Dumping frame %d.n", pdev->vframe_count);
  765. if (pdev->vframes_dumped == 20)
  766. Trace(TRACE_FLOW, "Dumping frame %d (last message).n", pdev->vframe_count);
  767. }
  768. }
  769. fbuf = pdev->fill_frame;
  770. }
  771. } /* !drop_frames */
  772. pdev->vframe_count++;
  773. }
  774. fbuf->filled = 0;
  775. fillptr = fbuf->data;
  776. pdev->vsync = 1;
  777. } /* .. flen < last_packet_size */
  778. pdev->vlast_packet_size = flen;
  779. } /* ..status == 0 */
  780. #ifdef PWC_DEBUG
  781. /* This is normally not interesting to the user, unless you are really debugging something */
  782. else 
  783. Trace(TRACE_FLOW, "Iso frame %d of USB has error %dn", i, fst);
  784. #endif
  785. }
  786. if (awake)
  787. wake_up_interruptible(&pdev->frameq);
  788. }
  791. static int pwc_isoc_init(struct pwc_device *pdev)
  792. {
  793. struct usb_device *udev;
  794. purb_t urb;
  795. int i, j, ret;
  797. struct usb_interface_descriptor *idesc;
  798. int cur_alt;
  800. if (pdev == NULL)
  801. return -EFAULT;
  802. if (pdev->iso_init)
  803. return 0;
  804. pdev->vsync = 0;
  805. udev = pdev->udev;
  807. /* Get the current alternate interface, adjust packet size */
  808. if (!udev->actconfig)
  809. return -EFAULT;
  810. cur_alt = udev->actconfig->interface[0].act_altsetting;
  811. idesc = &udev->actconfig->interface[0].altsetting[cur_alt];
  812. if (!idesc)
  813. return -EFAULT;
  815. /* Search video endpoint */
  816. pdev->vmax_packet_size = -1;
  817. for (i = 0; i < idesc->bNumEndpoints; i++)
  818. if ((idesc->endpoint[i].bEndpointAddress & 0xF) == pdev->vendpoint) {
  819. pdev->vmax_packet_size = idesc->endpoint[i].wMaxPacketSize;
  820. break;
  821. }
  823. if (pdev->vmax_packet_size < 0) {
  824. Err("Failed to find packet size for video endpoint in current alternate setting.n");
  825. return -ENFILE; /* Odd error, that should be noticable */
  826. }
  828. ret = 0;
  829. for (i = 0; i < MAX_ISO_BUFS; i++) {
  830. urb = usb_alloc_urb(ISO_FRAMES_PER_DESC);
  831. if (urb == NULL) {
  832. Err("Failed to allocate urb %dn", i);
  833. ret = -ENOMEM;
  834. break;
  835. }
  836. pdev->sbuf[i].urb = urb;
  837. }
  838. if (ret) {
  839. /* De-allocate in reverse order */
  840. while (i >= 0) {
  841. if (pdev->sbuf[i].urb != NULL)
  842. usb_free_urb(pdev->sbuf[i].urb);
  843. pdev->sbuf[i].urb = NULL;
  844. i--;
  845. }
  846. return ret;
  847. }
  850. /* init URB structure */
  851. for (i = 0; i < MAX_ISO_BUFS; i++) {
  852. urb = pdev->sbuf[i].urb;
  854. urb->next = pdev->sbuf[(i + 1) % MAX_ISO_BUFS].urb;
  855. urb->dev = udev;
  856.         urb->pipe = usb_rcvisocpipe(udev, pdev->vendpoint);
  857. urb->transfer_flags = USB_ISO_ASAP;
  858.         urb->transfer_buffer = pdev->sbuf[i].data;
  859.         urb->transfer_buffer_length = ISO_BUFFER_SIZE;
  860.         urb->complete = pwc_isoc_handler;
  861.         urb->context = pdev;
  862. urb->start_frame = 0;
  863. urb->number_of_packets = ISO_FRAMES_PER_DESC;
  864. for (j = 0; j < ISO_FRAMES_PER_DESC; j++) {
  865. urb->iso_frame_desc[j].offset = j * ISO_MAX_FRAME_SIZE;
  866. urb->iso_frame_desc[j].length = ISO_MAX_FRAME_SIZE;
  867. }
  868. }
  870. /* link */
  871. for (i = 0; i < MAX_ISO_BUFS; i++) {
  872. ret = usb_submit_urb(pdev->sbuf[i].urb);
  873. if (ret)
  874. Err("isoc_init() submit_urb %d failed with error %dn", i, ret);
  875. else
  876. Trace(TRACE_OPEN, "pwc_isoc_init(): URB submitted.n");
  877. }
  879. /* data should stream in now */
  880. pdev->iso_init = 1;
  881. return 0;
  882. }
  884. static void pwc_isoc_cleanup(struct pwc_device *pdev)
  885. {
  886. int i;
  888. if (pdev == NULL)
  889. return;
  890. if (!pdev->iso_init)
  891. return;
  892. /* Stop camera, but only if we are sure the camera is still there */
  893. if (!pdev->unplugged)
  894. usb_set_interface(pdev->udev, 0, 0);
  895. /* Unlinking ISOC buffers one by one */
  896. for (i = MAX_ISO_BUFS - 1; i >= 0; i--) {
  897. pdev->sbuf[i].urb->next = NULL;
  898. usb_unlink_urb(pdev->sbuf[i].urb);
  899. usb_free_urb(pdev->sbuf[i].urb);
  900. pdev->sbuf[i].urb = NULL;
  901. }
  902. pdev->iso_init = 0;
  903. }
  905. int pwc_try_video_mode(struct pwc_device *pdev, int width, int height, int new_fps, int new_compression, int new_snapshot)
  906. {
  907. int ret;
  909. /* Stop isoc stuff */
  910. pwc_isoc_cleanup(pdev);
  911. /* Reset parameters */
  912. pwc_reset_buffers(pdev);
  913. /* Try to set video mode... */
  914. ret = pwc_set_video_mode(pdev, width, height, new_fps, new_compression, new_snapshot);
  915. if (ret) /* That failed... restore old mode (we know that worked) */
  916. ret = pwc_set_video_mode(pdev, pdev->view.x, pdev->view.y, pdev->vframes, pdev->vcompression, pdev->vsnapshot);
  917. else /* Set (new) alternate interface */
  918. ret = usb_set_interface(pdev->udev, 0, pdev->valternate);
  919. if (!ret)
  920. ret = pwc_isoc_init(pdev);
  921. pdev->drop_frames = 1; /* try to avoid garbage during switch */
  922. return ret;
  923. }
  926. static inline void set_mem_leak(void *ptr)
  927. {
  928. down(&mem_lock);
  929. if (mem_leak != NULL)
  930. Err("Memleak: overwriting mem_leak pointer!n");
  931. Trace(TRACE_MEMORY, "Setting mem_leak to 0x%p.n", ptr);
  932. mem_leak = ptr;
  933. up(&mem_lock);
  934. }
  936. static inline void free_mem_leak(void)
  937. {
  938. down(&mem_lock);
  939. if (mem_leak != NULL) {
  940. Trace(TRACE_MEMORY, "Freeing mem_leak ptr 0x%p.n", mem_leak);
  941. kfree(mem_leak);
  942. mem_leak = NULL;
  943. }
  944. up(&mem_lock);
  945. }
  948. /***************************************************************************/
  949. /* Video4Linux functions */
  951. static int pwc_video_open(struct video_device *vdev, int mode)
  952. {
  953. int i;
  954. struct pwc_device *pdev;
  956. Trace(TRACE_OPEN, "video_open called(0x%p, 0%o).n", vdev, mode);
  958. if (vdev == NULL)
  959. BUG();
  960. pdev = (struct pwc_device *)vdev->priv;
  961. if (pdev == NULL)
  962. BUG();
  964. down(&pdev->modlock);
  965. if (!pdev->usb_init) {
  966. Trace(TRACE_OPEN, "Doing first time initialization.n");
  967. /* Reset camera */
  968. if (usb_set_interface(pdev->udev, 0, 0))
  969. Info("Failed to set alternate interface to 0.n");
  970. pdev->usb_init = 1;
  971. }
  973. /* Turn on camera */
  974. if (power_save) {
  975. i = pwc_camera_power(pdev, 1);
  976. if (i < 0)
  977. Info("Failed to restore power to the camera! (%d)n", i);
  978. }
  979. /* Set LED on/off time */
  980. if (pwc_set_leds(pdev, led_on, led_off) < 0)
  981. Info("Failed to set LED on/off time.n");
  983. /* Find our decompressor, if any */
  984. pdev->decompressor = pwc_find_decompressor(pdev->type);
  985. #if PWC_DEBUG
  986. Debug("Found decompressor for %d at 0x%pn", pdev->type, pdev->decompressor);
  987. #endif
  989. /* So far, so good. Allocate memory. */
  990. i = pwc_allocate_buffers(pdev);
  991. if (i < 0) {
  992. Trace(TRACE_OPEN, "Failed to allocate buffer memory.n");
  993. up(&pdev->modlock);
  994. return i;
  995. }
  997. /* Reset buffers & parameters */
  998. pwc_reset_buffers(pdev);
  999. for (i = 0; i < default_mbufs; i++)
  1000. pdev->image_used[i] = 0;
  1001. pdev->vframe_count = 0;
  1002. pdev->vframes_dumped = 0;
  1003. pdev->vframes_error = 0;
  1004. pdev->vpalette = default_palette;
  1005. #if PWC_DEBUG
  1006. pdev->sequence = 0;
  1007. #endif
  1009. /* Set some defaults */
  1010. pdev->vsnapshot = 0;
  1011. if (pdev->type == 730 || pdev->type == 740 || pdev->type == 750)
  1012. pdev->vsize = PSZ_QSIF;
  1013. else
  1014. pdev->vsize = PSZ_QCIF;
  1015. pdev->vframes = 10;
  1017. /* Start iso pipe for video; first try user-supplied size/fps, if
  1018.    that fails try QCIF/10 or QSIF/10 (a reasonable default), 
  1019.    then give up 
  1020.  */
  1021. i = pwc_set_video_mode(pdev, pwc_image_sizes[default_size].x, pwc_image_sizes[default_size].y, default_fps, pdev->vcompression, 0);
  1022. if (i) {
  1023. Trace(TRACE_OPEN, "First attempt at set_video_mode failed.n");
  1024. if (pdev->type == 730 || pdev->type == 740 || pdev->type == 750)
  1025. i = pwc_set_video_mode(pdev, pwc_image_sizes[PSZ_QSIF].x, pwc_image_sizes[PSZ_QSIF].y, 10, pdev->vcompression, 0);
  1026. else
  1027. i = pwc_set_video_mode(pdev, pwc_image_sizes[PSZ_QCIF].x, pwc_image_sizes[PSZ_QCIF].y, 10, pdev->vcompression, 0);
  1028. }
  1029. if (i) {
  1030. Trace(TRACE_OPEN, "Second attempt at set_video_mode failed.n");
  1031. up(&pdev->modlock);
  1032. return i;
  1033. }
  1035. i = usb_set_interface(pdev->udev, 0, pdev->valternate);
  1036. if (i) {
  1037. Trace(TRACE_OPEN, "Failed to set alternate interface = %d.n", i);
  1038. up(&pdev->modlock);
  1039. return -EINVAL;
  1040. }
  1041. i = pwc_isoc_init(pdev);
  1042. if (i) {
  1043. Trace(TRACE_OPEN, "Failed to init ISOC stuff = %d.n", i);
  1044. MOD_DEC_USE_COUNT;
  1045. up(&pdev->modlock);
  1046. return i;
  1047. }
  1049. pdev->vopen++;
  1050. /* lock decompressor; this has a small race condition, since we 
  1051.    could in theory unload pwcx.o between pwc_find_decompressor()
  1052.    above and this call. I doubt it's ever going to be a problem.
  1053.  */
  1054. if (pdev->decompressor != NULL)
  1055. pdev->decompressor->lock();
  1056. up(&pdev->modlock);
  1057. Trace(TRACE_OPEN, "video_open() returning 0.n");
  1058. return 0;
  1059. }
  1061. /* Note that all cleanup is done in the reverse order as in _open */
  1062. static void pwc_video_close(struct video_device *vdev)
  1063. {
  1064. struct pwc_device *pdev;
  1065. int i;
  1067. Trace(TRACE_OPEN, "video_close called(0x%p).n", vdev);
  1069. pdev = (struct pwc_device *)vdev->priv;
  1070. if (pdev->vopen == 0)
  1071. Info("video_close() called on closed device?n");
  1073. /* Free isoc URBs */
  1074. pwc_isoc_cleanup(pdev);
  1076. /* Dump statistics, but only if a reasonable amount of frames were
  1077.    processed (to prevent endless log-entries in case of snap-shot
  1078.    programs) 
  1079.  */
  1080. if (pdev->vframe_count > 20)
  1081. Info("Closing video device: %d frames received, dumped %d frames, %d frames with errors.n", pdev->vframe_count, pdev->vframes_dumped, pdev->vframes_error);
  1083. if (pdev->unplugged) {
  1084. /* The device was unplugged or some other error occured */
  1085. /* We unregister the video_device */
  1086. Trace(TRACE_OPEN, "Delayed video device unregistered.n");
  1087. video_unregister_device(pdev->vdev);
  1088. }
  1089. else {
  1090. /* Normal close: stop isochronuous and interrupt endpoint */
  1091. Trace(TRACE_OPEN, "Normal close(): setting interface to 0.n");
  1092. usb_set_interface(pdev->udev, 0, 0);
  1094. /* Turn LEDs off */
  1095. if (pwc_set_leds(pdev, 0, 0) < 0)
  1096. Info("Failed to set LED on/off time..n");
  1097. /* Power down camere to save energy */
  1098. if (power_save) {
  1099. i = pwc_camera_power(pdev, 0);
  1100. if (i < 0) 
  1101. Err("Failed to power down camera (%d)n", i);
  1102. }
  1103. }
  1105. pdev->vopen = 0;
  1106. if (pdev->decompressor != NULL) {
  1107. pdev->decompressor->exit();
  1108. pdev->decompressor->unlock();
  1109. }
  1110. pwc_free_buffers(pdev);
  1112. /* wake up _disconnect() routine */
  1113. if (pdev->unplugged)
  1114. wake_up(&pdev->remove_ok);
  1115. }
  1117. /*
  1118.  * FIXME: what about two parallel reads ????
  1119.  *      ANSWER: Not supported. You can't open the device more than once,
  1120.                 despite what the V4L1 interface says. First, I don't see 
  1121.                 the need, second there's no mechanism of alerting the 
  1122.                 2nd/3rd/... process of events like changing image size.
  1123.                 And I don't see the point of blocking that for the 
  1124.                 2nd/3rd/... process.
  1125.                 In multi-threaded environments reading parallel from any
  1126.                 device is tricky anyhow.
  1127.  */
  1128.  
  1129. static long pwc_video_read(struct video_device *vdev, char *buf, unsigned long count, int noblock)
  1130. {
  1131. struct pwc_device *pdev;
  1132. DECLARE_WAITQUEUE(wait, current);
  1134. Trace(TRACE_READ, "video_read(0x%p, %p, %ld, %d) called.n", vdev, buf, count, noblock);
  1135. if (vdev == NULL)
  1136. return -EFAULT;
  1137. pdev = vdev->priv;
  1138. if (pdev == NULL)
  1139. return -EFAULT;
  1140. if (pdev->unplugged) {
  1141. Info("pwc_video_read: Device got unplugged (1).n");
  1142. return -EPIPE; /* unplugged device! */
  1143. }
  1145. /* In case we're doing partial reads, we don't have to wait for a frame */
  1146. if (pdev->image_read_pos == 0) {
  1147. /* Do wait queueing according to the (doc)book */
  1148. add_wait_queue(&pdev->frameq, &wait);
  1149. while (pdev->full_frames == NULL) {
  1150.                 if (noblock) {
  1151.                  remove_wait_queue(&pdev->frameq, &wait);
  1152.                  set_current_state(TASK_RUNNING);
  1153.                  return -EWOULDBLOCK;
  1154.                 }
  1155.                 if (signal_pending(current)) {
  1156.                  remove_wait_queue(&pdev->frameq, &wait);
  1157.                  set_current_state(TASK_RUNNING);
  1158.                  return -ERESTARTSYS;
  1159.                 }
  1160.                 schedule();
  1161.                 set_current_state(TASK_INTERRUPTIBLE);
  1162. }
  1163. remove_wait_queue(&pdev->frameq, &wait);
  1164. set_current_state(TASK_RUNNING);
  1165.                                                                                                                                                                                 
  1166. /* Decompress [, convert] and release frame */
  1167. if (pwc_handle_frame(pdev))
  1168. return -EFAULT;
  1169. }
  1171. Trace(TRACE_READ, "Copying data to user space.n");
  1172. /* copy bytes to user space; we allow for partial reads */
  1173. if (count + pdev->image_read_pos > pdev->view.size)
  1174. count = pdev->view.size - pdev->image_read_pos;
  1175. if (copy_to_user(buf, pdev->image_ptr[pdev->fill_image] + pdev->image_read_pos, count))
  1176. return -EFAULT;
  1177. pdev->image_read_pos += count;
  1178. if (pdev->image_read_pos >= pdev->view.size) { /* All data has been read */
  1179. pdev->image_read_pos = 0;
  1180. pwc_next_image(pdev);
  1181. }
  1182. return count;
  1183. }
  1186. static long pwc_video_write(struct video_device *vdev, const char *buf, unsigned long count, int noblock)
  1187. {
  1188. return -EINVAL;   
  1189. }
  1191. static unsigned int pwc_video_poll(struct video_device *vdev, struct file *file, poll_table *wait)
  1192. {
  1193. struct pwc_device *pdev;
  1195. if (vdev == NULL)
  1196. return -EFAULT;
  1197. pdev = vdev->priv;
  1198. if (pdev == NULL)
  1199. return -EFAULT;
  1201. poll_wait(file, &pdev->frameq, wait);
  1202. if (pdev->unplugged) {
  1203. Info("pwc_video_poll: Device got unplugged.n");
  1204. return POLLERR;
  1205. }
  1206. if (pdev->full_frames != NULL) /* we have frames waiting */
  1207. return (POLLIN | POLLRDNORM);
  1209. return 0;
  1210. }
  1211.         
  1212. static int pwc_video_ioctl(struct video_device *vdev, unsigned int cmd, void *arg)
  1213. {
  1214. struct pwc_device *pdev;
  1215. DECLARE_WAITQUEUE(wait, current);
  1217. if (vdev == NULL)
  1218. return -EFAULT;
  1219. pdev = vdev->priv;
  1220. if (pdev == NULL)
  1221. return -EFAULT;
  1223. switch (cmd) {
  1224. /* Query cabapilities */
  1225. case VIDIOCGCAP: 
  1226. {
  1227. struct video_capability caps;
  1229. strcpy(caps.name, vdev->name);
  1230. caps.type = VID_TYPE_CAPTURE;
  1231. caps.channels = 1;
  1232. caps.audios = 1;
  1233. caps.minwidth  = pdev->view_min.x;
  1234. caps.minheight = pdev->view_min.y;
  1235. caps.maxwidth  = pdev->view_max.x;
  1236. caps.maxheight = pdev->view_max.y;
  1237. if (copy_to_user(arg, &caps, sizeof(caps)))
  1238. return -EFAULT;
  1239. break;
  1240. }
  1242. /* Channel functions (simulate 1 channel) */
  1243. case VIDIOCGCHAN:
  1244. {
  1245. struct video_channel v;
  1247. if (copy_from_user(&v, arg, sizeof(v)))
  1248. return -EFAULT;
  1249. if (v.channel != 0)
  1250. return -EINVAL;
  1252. v.flags = 0;
  1253. v.tuners = 0;
  1254. v.type = VIDEO_TYPE_CAMERA;
  1255. strcpy(v.name, "Webcam");
  1257. if (copy_to_user(arg, &v, sizeof(v)))
  1258. return -EFAULT;
  1260. return 0;
  1261. }
  1263. case VIDIOCSCHAN:
  1264. {
  1265. /* The spec says the argument is an integer, but
  1266.    the bttv driver uses a video_channel arg, which
  1267.    makes sense becasue it also has the norm flag.
  1268.  */
  1269. struct video_channel v;
  1271. if (copy_from_user(&v, arg, sizeof(v)))
  1272. return -EFAULT;
  1274. if (v.channel != 0)
  1275. return -EINVAL;
  1277. return 0;
  1278. }
  1281. /* Picture functions; contrast etc. */
  1282. case VIDIOCGPICT:
  1283. {
  1284. struct video_picture p;
  1285. int val;
  1287. p.colour = 0x8000;
  1288. p.hue = 0x8000;
  1289. val = pwc_get_brightness(pdev);
  1290. if (val >= 0)
  1291. p.brightness = val;
  1292. else
  1293. p.brightness = 0xffff;
  1294. val = pwc_get_contrast(pdev);
  1295. if (val >= 0)
  1296. p.contrast = val;
  1297. else
  1298. p.contrast = 0xffff;
  1299. /* Gamma, Whiteness, what's the difference? :) */
  1300. val = pwc_get_gamma(pdev);
  1301. if (val >= 0)
  1302. p.whiteness = val;
  1303. else
  1304. p.whiteness = 0xffff;
  1305. val = pwc_get_saturation(pdev);
  1306. if (val >= 0)
  1307. p.colour = val;
  1308. else
  1309. p.colour = 0xffff;
  1310. p.depth = 24;
  1311. p.palette = pdev->vpalette;
  1312. p.hue = 0xFFFF; /* N/A */
  1314. if (copy_to_user(arg, &p, sizeof(p)))
  1315. return -EFAULT;
  1316. break;
  1317. }
  1319. case VIDIOCSPICT:
  1320. {
  1321. struct video_picture p;
  1323. if (copy_from_user(&p, arg, sizeof(p)))
  1324. return -EFAULT;
  1326. /*
  1327.  * FIXME: Suppose we are mid read
  1328.         ANSWER: No problem: the firmware of the camera
  1329.                 can handle brightness/contrast/etc
  1330.                 changes at _any_ time, and the palette
  1331.                 is used exactly once in the uncompress
  1332.                 routine.
  1333.  */
  1334. pwc_set_brightness(pdev, p.brightness);
  1335. pwc_set_contrast(pdev, p.contrast);
  1336. pwc_set_gamma(pdev, p.whiteness);
  1337. pwc_set_saturation(pdev, p.colour);
  1338. if (p.palette && p.palette != pdev->vpalette) {
  1339. if (pwc_set_palette(pdev, p.palette) < 0)
  1340. return -EINVAL;
  1341. }
  1342. break;
  1343. }
  1345. /* Window/size parameters */
  1346. case VIDIOCGWIN:
  1347. {
  1348. struct video_window vw;
  1350. vw.x = 0;
  1351. vw.y = 0;
  1352. vw.width = pdev->view.x;
  1353. vw.height = pdev->view.y;
  1354. vw.chromakey = 0;
  1355. vw.flags = (pdev->vframes << PWC_FPS_SHIFT) | 
  1356.            (pdev->vsnapshot ? PWC_FPS_SNAPSHOT : 0);
  1358. if (copy_to_user(arg, &vw, sizeof(vw)))
  1359. return -EFAULT;
  1360. break;
  1361. }
  1363. case VIDIOCSWIN:
  1364. {
  1365. struct video_window vw;
  1366. int fps, snapshot, ret;
  1368. if (copy_from_user(&vw, arg, sizeof(vw)))
  1369. return -EFAULT;
  1371. fps = (vw.flags & PWC_FPS_FRMASK) >> PWC_FPS_SHIFT;
  1372. snapshot = vw.flags & PWC_FPS_SNAPSHOT;
  1373. if (fps == 0)
  1374. fps = pdev->vframes;
  1375. if (pdev->view.x == vw.width && pdev->view.y && fps == pdev->vframes && snapshot == pdev->vsnapshot)
  1376. return 0;
  1377. ret = pwc_try_video_mode(pdev, vw.width, vw.height, fps, pdev->vcompression, snapshot);
  1378. if (ret)
  1379. return ret;
  1380. break;
  1381. }
  1383. /* We don't have overlay support (yet) */
  1384. case VIDIOCGFBUF:
  1385. {
  1386. struct video_buffer vb;
  1388. vb.base = NULL;
  1389. vb.height = 0;
  1390. vb.width = 0;
  1391. vb.depth = 0;
  1392. vb.bytesperline = 0;
  1394. if (copy_to_user((void *)arg, (void *)&vb, sizeof(vb)))
  1395. return -EFAULT;
  1396. break;
  1397. }
  1399. /* mmap() functions */
  1400. case VIDIOCGMBUF:
  1401. {
  1402. /* Tell the user program how much memory is needed for a mmap() */
  1403. struct video_mbuf vm;
  1404. int i;
  1406. memset(&vm, 0, sizeof(vm));
  1407. vm.size = default_mbufs * pdev->len_per_image;
  1408. vm.frames = default_mbufs; /* double buffering should be enough for most applications */
  1409. for (i = 0; i < default_mbufs; i++)
  1410. vm.offsets[i] = i * pdev->len_per_image;
  1412. if (copy_to_user((void *)arg, (void *)&vm, sizeof(vm)))
  1413. return -EFAULT;
  1414. break;
  1415. }
  1417. case VIDIOCMCAPTURE:
  1418. {
  1419. /* Start capture into a given image buffer (called 'frame' in video_mmap structure) */
  1420. struct video_mmap vm;
  1422. if (copy_from_user((void *)&vm, (void *)arg, sizeof(vm)))
  1423. return -EFAULT;
  1424. Trace(TRACE_READ, "VIDIOCMCAPTURE: %dx%d, frame %d, format %dn", vm.width, vm.height, vm.frame, vm.format);
  1425. if (vm.frame < 0 || vm.frame >= default_mbufs)
  1426. return -EINVAL;
  1428. /* xawtv is nasty. It probes the available palettes
  1429.    by setting a very small image size and trying
  1430.    various palettes... The driver doesn't support
  1431.    such small images, so I'm working around it.
  1432.  */
  1433. if (vm.format && vm.format != pdev->vpalette)
  1434. if (pwc_set_palette(pdev, vm.format) < 0)
  1435. return -EINVAL;
  1436.  
  1437. if ((vm.width != pdev->view.x || vm.height != pdev->view.y) &&
  1438.     (vm.width >= pdev->view_min.x && vm.height >= pdev->view_min.y)) {
  1439. int ret;
  1441. Trace(TRACE_OPEN, "VIDIOCMCAPTURE: changing size to please xawtv :-(.n");
  1442. ret = pwc_try_video_mode(pdev, vm.width, vm.height, pdev->vframes, pdev->vcompression, pdev->vsnapshot);
  1443. if (ret)
  1444. return ret;
  1445. } /* ... size mismatch */
  1447. /* FIXME: should we lock here? */
  1448. if (pdev->image_used[vm.frame])
  1449. return -EBUSY; /* buffer wasn't available. Bummer */
  1450. pdev->image_used[vm.frame] = 1;
  1452. /* Okay, we're done here. In the SYNC call we wait until a 
  1453.    frame comes available, then expand image into the given 
  1454.    buffer.
  1455.    In contrast to the CPiA cam the Philips cams deliver a 
  1456.    constant stream, almost like a grabber card. Also,
  1457.    we have separate buffers for the rawdata and the image,
  1458.    meaning we can nearly always expand into the requested buffer.
  1459.  */
  1460. Trace(TRACE_READ, "VIDIOCMCAPTURE done.n");
  1461. break;
  1462. }
  1464. case VIDIOCSYNC:
  1465. {
  1466. /* The doc says: "Whenever a buffer is used it should
  1467.    call VIDIOCSYNC to free this frame up and continue."
  1468.    
  1469.    The only odd thing about this whole procedure is 
  1470.    that MCAPTURE flags the buffer as "in use", and
  1471.    SYNC immediately unmarks it, while it isn't 
  1472.    after SYNC that you know that the buffer actually
  1473.    got filled! So you better not start a CAPTURE in
  1474.    the same frame immediately (use double buffering). 
  1475.    This is not a problem for this cam, since it has 
  1476.    extra intermediate buffers, but a hardware 
  1477.    grabber card will then overwrite the buffer 
  1478.    you're working on.
  1479.  */
  1480. int mbuf, ret;
  1482. if (copy_from_user((void *)&mbuf, arg, sizeof(int)))
  1483. return -EFAULT;
  1485. Trace(TRACE_READ, "VIDIOCSYNC called (%d).n", mbuf);
  1487. /* bounds check */
  1488. if (mbuf < 0 || mbuf >= default_mbufs)
  1489. return -EINVAL;
  1490. /* check if this buffer was requested anyway */
  1491. if (pdev->image_used[mbuf] == 0)
  1492. return -EINVAL;
  1494. /* Add ourselves to the frame wait-queue.
  1495.    
  1496.    FIXME: needs auditing for safety.
  1497.    QUSTION: In what respect? I think that using the
  1498.             frameq is safe now.
  1499.  */
  1500. add_wait_queue(&pdev->frameq, &wait);
  1501. while (pdev->full_frames == NULL) {
  1502. if (pdev->unplugged) {
  1503. remove_wait_queue(&pdev->frameq, &wait);
  1504. set_current_state(TASK_RUNNING);
  1505. return -ENODEV;
  1506. }
  1508.                  if (signal_pending(current)) {
  1509.                  remove_wait_queue(&pdev->frameq, &wait);
  1510.                  set_current_state(TASK_RUNNING);
  1511.                  return -ERESTARTSYS;
  1512.                  }
  1513.                  schedule();
  1514.                 set_current_state(TASK_INTERRUPTIBLE);
  1515. }
  1516. remove_wait_queue(&pdev->frameq, &wait);
  1517. set_current_state(TASK_RUNNING);
  1519. /* The frame is ready. Expand in the image buffer 
  1520.    requested by the user. I don't care if you 
  1521.    mmap() 5 buffers and request data in this order: 
  1522.    buffer 4 2 3 0 1 2 3 0 4 3 1 . . .
  1523.    Grabber hardware may not be so forgiving.
  1524.  */
  1525. Trace(TRACE_READ, "VIDIOCSYNC: frame ready.n");
  1526. pdev->fill_image = mbuf; /* tell in which buffer we want the image to be expanded */
  1527. /* Decompress, etc */
  1528. ret = pwc_handle_frame(pdev);
  1529. pdev->image_used[mbuf] = 0;
  1530. if (ret)
  1531. return -EFAULT;
  1532. break;
  1533. }
  1535. case VIDIOCGAUDIO:
  1536. {
  1537. struct video_audio v;
  1539. strcpy(v.name, "Microphone");
  1540. v.audio = -1; /* unknown audio minor */
  1541. v.flags = 0;
  1542. v.mode = VIDEO_SOUND_MONO;
  1543. v.volume = 0;
  1544. v.bass = 0;
  1545. v.treble = 0;
  1546. v.balance = 0x8000;
  1547. v.step = 1;
  1549. if (copy_to_user(arg, &v, sizeof(v)))
  1550. return -EFAULT;
  1551. break;
  1552. }
  1554. case VIDIOCSAUDIO:
  1555. {
  1556. struct video_audio v;
  1558. if (copy_from_user(&v, arg, sizeof(v)))
  1559. return -EFAULT;
  1560. /* Dummy: nothing can be set */
  1561. break;
  1562. }
  1564. case VIDIOCGUNIT:
  1565. {
  1566. struct video_unit vu;
  1568. vu.video = pdev->vdev->minor & 0x3F;
  1569. vu.audio = -1; /* not known yet */
  1570. vu.vbi = -1;
  1571. vu.radio = -1;
  1572. vu.teletext = -1;
  1573. if (copy_to_user(arg, &vu, sizeof(vu)))
  1574. return -EFAULT;
  1575. break;
  1576. }
  1577. default:
  1578. return pwc_ioctl(pdev, cmd, arg);
  1579. } /* ..switch */
  1580. return 0;
  1581. }
  1583. static int pwc_video_mmap(struct video_device *vdev, const char *adr, unsigned long size)
  1584. {
  1585. struct pwc_device *pdev;
  1586. unsigned long start = (unsigned long)adr;
  1587. unsigned long page, pos;
  1589. Trace(TRACE_MEMORY, "mmap(0x%p, 0x%p, %lu) called.n", vdev, adr, size);
  1590. pdev = vdev->priv;
  1592. /* FIXME - audit mmap during a read */
  1593. pos = (unsigned long)pdev->image_data;
  1594. while (size > 0) {
  1595. page = kvirt_to_pa(pos);
  1596. if (remap_page_range(start, page, PAGE_SIZE, PAGE_SHARED))
  1597. return -EAGAIN;
  1599. start += PAGE_SIZE;
  1600. pos += PAGE_SIZE;
  1601. if (size > PAGE_SIZE)
  1602. size -= PAGE_SIZE;
  1603. else
  1604. size = 0;
  1605. }
  1607. return 0;
  1608. }
  1610. /***************************************************************************/
  1611. /* USB functions */
  1613. /* This function gets called when a new device is plugged in or the usb core
  1614.  * is loaded.
  1615.  */
  1617. static void *usb_pwc_probe(struct usb_device *udev, unsigned int ifnum, const struct usb_device_id *id)
  1618. {
  1619. struct pwc_device *pdev = NULL;
  1620. struct video_device *vdev;
  1621. int vendor_id, product_id, type_id;
  1622. int i, hint;
  1623. int video_nr = -1; /* default: use next available device */
  1624. char serial_number[30];
  1626. free_mem_leak();
  1628. /* Check if we can handle this device */
  1629. Trace(TRACE_PROBE, "probe() called [%04X %04X], if %dn", udev->descriptor.idVendor, udev->descriptor.idProduct, ifnum);
  1631. /* the interfaces are probed one by one. We are only interested in the
  1632.    video interface (0) now.
  1633.    Interface 1 is the Audio Control, and interface 2 Audio itself.
  1634.  */
  1635. if (ifnum > 0) 
  1636. return NULL;
  1638. vendor_id = udev->descriptor.idVendor;
  1639. product_id = udev->descriptor.idProduct;
  1641. if (vendor_id == 0x0471) {
  1642. switch (product_id) {
  1643. case 0x0302:
  1644. Info("Philips PCA645VC USB webcam detected.n");
  1645. type_id = 645;
  1646. break;
  1647. case 0x0303:
  1648. Info("Philips PCA646VC USB webcam detected.n");
  1649. type_id = 646;
  1650. break;
  1651. case 0x0304:
  1652. Info("Askey VC010 type 2 USB webcam detected.n");
  1653. type_id = 646;
  1654. break;
  1655. case 0x0307:
  1656. Info("Philips PCVC675K (Vesta) USB webcam detected.n");
  1657. type_id = 675;
  1658. break;
  1659. case 0x0308:
  1660. Info("Philips PCVC680K (Vesta Pro) USB webcam detected.n");
  1661. type_id = 680;
  1662. break;
  1663. case 0x030C:
  1664. Info("Philips PCVC690K (Vesta Pro Scan) USB webcam detected.n");
  1665. type_id = 690;
  1666. break;
  1667. case 0x0310:
  1668. Info("Philips PCVC730K (ToUCam Fun) USB webcam detected.n");
  1669. type_id = 730;
  1670. break;
  1671. case 0x0311:
  1672. Info("Philips PCVC740K (ToUCam Pro) USB webcam detected.n");
  1673. type_id = 740;
  1674. break;
  1675. case 0x0312:
  1676. Info("Philips PCVC750K (ToUCam Pro Scan) USB webcam detected.n");
  1677. type_id = 750;
  1678. break;
  1679. default:
  1680. return NULL;
  1681. break;
  1682. }
  1683. }
  1684. else if (vendor_id == 0x069A) {
  1685. switch(product_id) {
  1686. case 0x0001:
  1687. Info("Askey VC010 type 1 USB webcam detected.n");
  1688. type_id = 645;
  1689. break;
  1690. default:
  1691. return NULL;
  1692. break;
  1693. }
  1694. }
  1695. else if (vendor_id == 0x046d) {
  1696. switch(product_id) {
  1697. case 0x08b0:
  1698. Info("Logitech QuickCam 3000 Pro detected.n");
  1699. type_id = 730;
  1700.          break;
  1701.          default:
  1702.          return NULL;
  1703.          break;
  1704.          }
  1705.         }
  1706. else if (vendor_id == 0x055d) {
  1707. /* I don't know the difference between the C10 and the C30;
  1708.    I suppose the difference is the sensor, but both cameras
  1709.    work equally well with a type_id of 675
  1710.  */
  1711. switch(product_id) {
  1712. case 0x9000:
  1713. Info("Samsung MPC-C10 USB webcam detected.n");
  1714. type_id = 675;
  1715. break;
  1716. case 0x9001:
  1717. Info("Samsung MPC-C30 USB webcam detected.n");
  1718. type_id = 675;
  1719. break;
  1720. default:
  1721. return NULL;
  1722. break;
  1723. }
  1724. }
  1725. else if (vendor_id == 0x041e) {
  1726. switch(product_id) {
  1727. case 0x400c:
  1728. Info("Creative Labs Webcam 5 detected.n");
  1729. type_id = 730;
  1730. break;
  1731. default:
  1732. return NULL;
  1733. break;
  1734. }
  1735. }
  1736. else if (vendor_id == 0x04cc) { 
  1737. switch(product_id) {
  1738. case 0x8116:
  1739. Info("SOTEC CMS-001 USB webcam detected.n");
  1740. type_id = 730;
  1741. break;  
  1742. default:
  1743. return NULL;
  1744. break;
  1745. }
  1746. }
  1747. else return NULL; /* Not Philips, Askey, Logitech, Samsung, Creative or SOTEC, for sure. */
  1749. memset(serial_number, 0, 30);
  1750. usb_string(udev, udev->descriptor.iSerialNumber, serial_number, 29);
  1751. Trace(TRACE_PROBE, "Device serial number is %sn", serial_number);
  1753. if (udev->descriptor.bNumConfigurations > 1)
  1754. Info("Warning: more than 1 configuration available.n");
  1756. /* Allocate structure, initialize pointers, mutexes, etc. and link it to the usb_device */
  1757. pdev = kmalloc(sizeof(struct pwc_device), GFP_KERNEL);
  1758. if (pdev == NULL) {
  1759. Err("Oops, could not allocate memory for pwc_device.n");
  1760. return NULL;
  1761. }
  1762. memset(pdev, 0, sizeof(struct pwc_device));
  1763. pdev->type = type_id;
  1764. pwc_construct(pdev);
  1766. init_MUTEX(&pdev->modlock);
  1767. pdev->ptrlock = SPIN_LOCK_UNLOCKED;
  1769. pdev->udev = udev;
  1770. init_waitqueue_head(&pdev->frameq);
  1771. init_waitqueue_head(&pdev->remove_ok);
  1772. pdev->vcompression = pwc_preferred_compression;
  1774. /* Now hook it up to the video subsystem */
  1775. vdev = kmalloc(sizeof(struct video_device), GFP_KERNEL);
  1776. if (vdev == NULL) {
  1777. Err("Oops, could not allocate memory for video_device.n");
  1778. return NULL;
  1779. }
  1780. memcpy(vdev, &pwc_template, sizeof(pwc_template));
  1781. sprintf(vdev->name, "Philips %d webcam", pdev->type);
  1782. SET_MODULE_OWNER(vdev);
  1783. pdev->vdev = vdev;
  1784. vdev->priv = pdev;
  1786. pdev->release = udev->descriptor.bcdDevice;
  1787. Trace(TRACE_PROBE, "Release: %04xn", pdev->release);
  1790. /* Now search device_hint[] table for a match, so we can hint a node number. */
  1791. for (hint = 0; hint < MAX_DEV_HINTS; hint++) {
  1792. if (((device_hint[hint].type == -1) || (device_hint[hint].type == pdev->type)) &&
  1793.      (device_hint[hint].pdev == NULL)) {
  1794. /* so far, so good... try serial number */
  1795. if ((device_hint[hint].serial_number[0] == '*') || !strcmp(device_hint[hint].serial_number, serial_number)) {
  1796.      /* match! */
  1797.      video_nr = device_hint[hint].device_node;
  1798.      Trace(TRACE_PROBE, "Found hint, will try to register as /dev/video%dn", video_nr);
  1799.      break;
  1800. }
  1801. }
  1802. }
  1804. i = video_register_device(vdev, VFL_TYPE_GRABBER, video_nr);
  1805. if (i < 0) {
  1806. Err("Failed to register as video device (%d).n", i);
  1807. return NULL;
  1808. }
  1809. else {
  1810. Trace(TRACE_PROBE, "Registered video struct at 0x%p.n", vdev);
  1811. Info("Registered as /dev/video%d.n", vdev->minor & 0x3F);
  1812. }
  1813. /* occupy slot */
  1814. if (hint < MAX_DEV_HINTS) 
  1815. device_hint[hint].pdev = pdev;
  1817. Trace(TRACE_PROBE, "probe() function returning struct at 0x%p.n", pdev);
  1818. return pdev;
  1819. }
  1821. /* The user janked out the cable... */
  1822. static void usb_pwc_disconnect(struct usb_device *udev, void *ptr)
  1823. {
  1824. struct pwc_device *pdev;
  1825. int hint;
  1826. DECLARE_WAITQUEUE(wait, current);
  1828. lock_kernel();
  1829. free_mem_leak();
  1831. pdev = (struct pwc_device *)ptr;
  1832. if (pdev == NULL) {
  1833. Err("pwc_disconnect() Called without private pointer.n");
  1834. return;
  1835. }
  1836. if (pdev->udev == NULL) {
  1837. Err("pwc_disconnect() already called for %pn", pdev);
  1838. return;
  1839. }
  1840. if (pdev->udev != udev) {
  1841. Err("pwc_disconnect() Woops: pointer mismatch udev/pdev.n");
  1842. return;
  1843. }
  1844. #ifdef PWC_MAGIC
  1845. if (pdev->magic != PWC_MAGIC) {
  1846. Err("pwc_disconnect() Magic number failed. Consult your scrolls and try again.n");
  1847. return;
  1848. }
  1849. #endif
  1851. pdev->unplugged = 1;
  1852. if (pdev->vdev != NULL) {
  1853. if (pdev->vopen) {
  1854. Info("Disconnected while device/video is open!n");
  1856. /* Wake up any processes that might be waiting for
  1857.    a frame, let them return an error condition
  1858.  */
  1859. wake_up(&pdev->frameq);
  1861. /* Wait until we get a 'go' from _close(). This used
  1862.    to have a gigantic race condition, since we kfree()
  1863.    stuff here, but we have to wait until close() 
  1864.    is finished. 
  1865.  */
  1866.    
  1867. Trace(TRACE_PROBE, "Sleeping on remove_ok.n");
  1868. add_wait_queue(&pdev->remove_ok, &wait);
  1869. set_current_state(TASK_UNINTERRUPTIBLE);
  1870. /* ... wait ... */
  1871. schedule();
  1872. remove_wait_queue(&pdev->remove_ok, &wait);
  1873. set_current_state(TASK_RUNNING);
  1874. Trace(TRACE_PROBE, "Done sleeping.n");
  1875. set_mem_leak(pdev->vdev);
  1876. pdev->vdev = NULL;
  1877. }
  1878. else {
  1879. /* Normal disconnect; remove from available devices */
  1880. Trace(TRACE_PROBE, "Unregistering video device normally.n");
  1881. video_unregister_device(pdev->vdev); 
  1882. kfree(pdev->vdev);
  1883. pdev->vdev = NULL;
  1884. }
  1885. }
  1887. /* search device_hint[] table if we occupy a slot, by any chance */
  1888. for (hint = 0; hint < MAX_DEV_HINTS; hint++)
  1889. if (device_hint[hint].pdev == pdev)
  1890. device_hint[hint].pdev = NULL;
  1892. pdev->udev = NULL;
  1893. unlock_kernel();
  1894. kfree(pdev);
  1895. }
  1898. /* *grunt* We have to do atoi ourselves :-( */
  1899. static int pwc_atoi(char *s)
  1900. {
  1901. int k = 0;
  1903. k = 0;
  1904. while (*s != '' && *s >= '0' && *s <= '9') {
  1905. k = 10 * k + (*s - '0');
  1906. s++;
  1907. }
  1908. return k;
  1909. }
  1912. /* 
  1913.  * Initialization code & module stuff 
  1914.  */
  1916. static char *size = NULL;
  1917. static int fps = 0;
  1918. static int fbufs = 0;
  1919. static int mbufs = 0;
  1920. static int trace = -1;
  1921. static int compression = -1;
  1922. static int leds[2] = { -1, -1 };
  1923. static char *dev_hint[10] = { };
  1925. MODULE_PARM(size, "s");
  1926. MODULE_PARM_DESC(size, "Initial image size. One of sqcif, qsif, qcif, sif, cif, vga");
  1927. MODULE_PARM(fps, "i");
  1928. MODULE_PARM_DESC(fps, "Initial frames per second. Varies with model, useful range 5-30");
  1929. MODULE_PARM(fbufs, "i");
  1930. MODULE_PARM_DESC(fbufs, "Number of internal frame buffers to reserve");
  1931. MODULE_PARM(mbufs, "i");
  1932. MODULE_PARM_DESC(mbufs, "Number of external (mmap()ed) image buffers");
  1933. MODULE_PARM(trace, "i");
  1934. MODULE_PARM_DESC(trace, "For debugging purposes");
  1935. MODULE_PARM(power_save, "i");
  1936. MODULE_PARM_DESC(power_save, "Turn power save feature in camera on or off");
  1937. MODULE_PARM(compression, "i");
  1938. MODULE_PARM_DESC(compression, "Preferred compression quality. Range 0 (uncompressed) to 3 (high compression)");
  1939. MODULE_PARM(leds, "2i");
  1940. MODULE_PARM_DESC(leds, "LED on,off time in milliseconds");
  1941. MODULE_PARM(dev_hint, "0-10s");
  1942. MODULE_PARM_DESC(dev_hint, "Device node hints");
  1944. MODULE_DESCRIPTION("Philips USB webcam driver");
  1945. MODULE_AUTHOR("Nemosoft Unv. <nemosoft@smcc.demon.nl>");
  1946. MODULE_LICENSE("GPL");
  1948. static int __init usb_pwc_init(void)
  1949. {
  1950. int i, sz;
  1951. char *sizenames[PSZ_MAX] = { "sqcif", "qsif", "qcif", "sif", "cif", "vga" };
  1953. Info("Philips PCA645/646 + PCVC675/680/690 + PCVC730/740/750 webcam module version " PWC_VERSION " loaded.n");
  1954. Info("Also supports the Askey VC010, Logitech Quickcam 3000 Pro, Samsung MPC-C10 and MPC-C30, the Creative WebCam 5 and the SOTEC CMS-001.n");
  1956. if (fps) {
  1957. if (fps < 5 || fps > 30) {
  1958. Err("Framerate out of bounds (5-30).n");
  1959. return -EINVAL;
  1960. }
  1961. default_fps = fps;
  1962. Info("Default framerate set to %d.n", default_fps);
  1963. }
  1965. if (size) {
  1966. /* string; try matching with array */
  1967. for (sz = 0; sz < PSZ_MAX; sz++) {
  1968. if (!strcmp(sizenames[sz], size)) { /* Found! */
  1969. default_size = sz;
  1970. break;
  1971. }
  1972. }
  1973. if (sz == PSZ_MAX) {
  1974. Err("Size not recognized; try size=[sqcif | qsif | qcif | sif | cif | vga].n");
  1975. return -EINVAL;
  1976. }
  1977. Info("Default image size set to %s [%dx%d].n", sizenames[default_size], pwc_image_sizes[default_size].x, pwc_image_sizes[default_size].y);
  1978. }
  1979. if (mbufs) {
  1980. if (mbufs < 1 || mbufs > MAX_IMAGES) {
  1981. Err("Illegal number of mmap() buffers; use a number between 1 and %d.n", MAX_IMAGES);
  1982. return -EINVAL;
  1983. }
  1984. default_mbufs = mbufs;
  1985. Info("Number of image buffers set to %d.n", default_mbufs);
  1986. }
  1987. if (fbufs) {
  1988. if (fbufs < 2 || fbufs > MAX_FRAMES) {
  1989. Err("Illegal number of frame buffers; use a number between 2 and %d.n", MAX_FRAMES);
  1990. return -EINVAL;
  1991. }
  1992. default_fbufs = fbufs;
  1993. Info("Number of frame buffers set to %d.n", default_fbufs);
  1994. }
  1995. if (trace >= 0) {
  1996. Info("Trace options: 0x%04xn", trace);
  1997. pwc_trace = trace;
  1998. }
  1999. if (compression >= 0) {
  2000. if (compression > 3) {
  2001. Err("Invalid compression setting; use a number between 0 (uncompressed) and 3 (high).n");
  2002. return -EINVAL;
  2003. }
  2004. pwc_preferred_compression = compression;
  2005. Info("Preferred compression set to %d.n", pwc_preferred_compression);
  2006. }
  2007. if (power_save)
  2008. Info("Enabling power save on open/close.n");
  2009. if (leds[0] >= 0)
  2010. led_on = leds[0] / 100;
  2011. if (leds[1] >= 0)
  2012. led_off = leds[1] / 100;
  2014. /* Big device node whoopla. Basicly, it allows you to assign a 
  2015.    device node (/dev/videoX) to a camera, based on its type 
  2016.    & serial number. The format is [type[.serialnumber]:]node.
  2018.            Any camera that isn't matched by these rules gets the next 
  2019.            available free device node.
  2020.  */
  2021. for (i = 0; i < MAX_DEV_HINTS; i++) {
  2022. char *s, *colon, *dot;
  2024. /* This loop also initializes the array */
  2025. device_hint[i].pdev = NULL;
  2026. s = dev_hint[i];
  2027. if (s != NULL && *s != '') {
  2028. device_hint[i].type = -1; /* wildcard */
  2029. strcpy(device_hint[i].serial_number, "*");
  2031. /* parse string: chop at ':' & '/' */
  2032. colon = dot = s;
  2033. while (*colon != '' && *colon != ':')
  2034. colon++;
  2035. while (*dot != '' && *dot != '.')
  2036. dot++;
  2037. /* Few sanity checks */
  2038. if (*dot != '' && dot > colon) {
  2039. Err("Malformed camera hint: the colon must be after the dot.n");
  2040. return -EINVAL;
  2041. }
  2043. if (*colon == '') {
  2044. /* No colon */
  2045. if (*dot != '') {
  2046. Err("Malformed camera hint: no colon + device node given.n");
  2047. return -EINVAL;
  2048. }
  2049. else {
  2050. /* No type or serial number specified, just a number. */
  2051. device_hint[i].device_node = pwc_atoi(s);
  2052. }
  2053. }
  2054. else {
  2055. /* There's a colon, so we have at least a type and a device node */
  2056. device_hint[i].type = pwc_atoi(s);
  2057. device_hint[i].device_node = pwc_atoi(colon + 1);
  2058. if (*dot != '') {
  2059. /* There's a serial number as well */
  2060. int k;
  2062. dot++;
  2063. k = 0;
  2064. while (*dot != ':' && k < 29) {
  2065. device_hint[i].serial_number[k++] = *dot;
  2066. dot++;
  2067. }
  2068. device_hint[i].serial_number[k] = '';
  2069. }
  2070. }
  2071. #ifdef PWC_DEBUG
  2072. Debug("device_hint[%d]:n", i);
  2073. Debug("  type    : %dn", device_hint[i].type);
  2074. Debug("  serial# : %sn", device_hint[i].serial_number);
  2075. Debug("  node    : %dn", device_hint[i].device_node);
  2076. #endif
  2077. }
  2078. else
  2079. device_hint[i].type = 0; /* not filled */
  2080. } /* ..for MAX_DEV_HINTS */
  2082. init_MUTEX(&mem_lock);
  2083.   Trace(TRACE_PROBE, "Registering driver at address 0x%p.n", &pwc_driver);
  2084. return usb_register(&pwc_driver);
  2085. }
  2087. static void __exit usb_pwc_exit(void)
  2088. {
  2089. free_mem_leak();
  2090. Trace(TRACE_MODULE, "Deregistering driver.n");
  2091. usb_deregister(&pwc_driver);
  2092. Info("Philips webcam module removed.n");
  2093. }
  2095. module_init(usb_pwc_init);
  2096. module_exit(usb_pwc_exit);