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

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

嵌入式Linux

开发平台：

Unix_Linux

stv680.c：源码内容
  1. /*
  2.  *  STV0680 USB Camera Driver, by Kevin Sisson (kjsisson@bellsouth.net)
  3.  *  
  4.  * Thanks to STMicroelectronics for information on the usb commands, and 
  5.  * to Steve Miller at STM for his help and encouragement while I was 
  6.  * writing this driver.
  7.  *
  8.  * This driver is based heavily on the 
  9.  * Endpoints (formerly known as AOX) se401 USB Camera Driver
  10.  * Copyright (c) 2000 Jeroen B. Vreeken (pe1rxq@amsat.org)
  11.  *
  12.  * Still somewhat based on the Linux ov511 driver.
  13.  * 
  14.  * This program is free software; you can redistribute it and/or modify it
  15.  * under the terms of the GNU General Public License as published by the
  16.  * Free Software Foundation; either version 2 of the License, or (at your
  17.  * option) any later version.
  18.  *
  19.  * This program is distributed in the hope that it will be useful, but
  20.  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  21.  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  22.  * for more details.
  23.  *
  24.  * You should have received a copy of the GNU General Public License
  25.  * along with this program; if not, write to the Free Software Foundation,
  26.  * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  27.  *
  28.  * History: 
  29.  * ver 0.1 October, 2001. Initial attempt. 
  30.  *
  31.  * ver 0.2 November, 2001. Fixed asbility to resize, added brightness
  32.  *                         function, made more stable (?)
  33.  *
  34.  * ver 0.21 Nov, 2001.     Added gamma correction and white balance, 
  35.  *                         due to Alexander Schwartz. Still trying to 
  36.  *                         improve stablility. Moved stuff into stv680.h
  37.  *
  38.  * ver 0.22 Nov, 2001.    Added sharpen function (by Michael Sweet, 
  39.  *                         mike@easysw.com) from GIMP, also used in pencam. 
  40.  *                         Simple, fast, good integer math routine.
  41.  *
  42.  * ver 0.23 Dec, 2001 (gkh)
  43.  *     Took out sharpen function, ran code through
  44.  *     Lindent, and did other minor tweaks to get
  45.  *     things to work properly with 2.5.1
  46.  *
  47.  * ver 0.24 Jan, 2002 (kjs) 
  48.  *                         Fixed the problem with webcam crashing after
  49.  *                         two pictures. Changed the way pic is halved to 
  50.  *                         improve quality. Got rid of green line around 
  51.  *                         frame. Fix brightness reset when changing size 
  52.  *                         bug. Adjusted gamma filters slightly.
  53.  */
  55. #include <linux/config.h>
  56. #include <linux/module.h>
  57. #include <linux/version.h>
  58. #include <linux/init.h>
  59. #include <linux/fs.h>
  60. #include <linux/vmalloc.h>
  61. #include <linux/slab.h>
  62. #include <linux/proc_fs.h>
  63. #include <linux/pagemap.h>
  64. #include <linux/wrapper.h>
  65. #include <linux/smp_lock.h>
  66. #include <linux/sched.h>
  67. #include <linux/signal.h>
  68. #include <linux/errno.h>
  69. #include <linux/videodev.h>
  70. #include <linux/usb.h>
  72. #include "stv680.h"
  74. static int video_nr = -1;
  75. static int swapRGB = 0;   /* default for auto sleect */
  76. static int swapRGB_on = 0; /* default to allow auto select; -1=swap never, +1= swap always */
  78. static unsigned int debug = 0;
  80. #define PDEBUG(level, fmt, args...) 
  81. do { 
  82. if (debug >= level)
  83. info("[" __PRETTY_FUNCTION__ ":%d] " fmt, __LINE__ , ## args);
  84. } while (0)
  87. /*
  88.  * Version Information
  89.  */
  90. #define DRIVER_VERSION "v0.24"
  91. #define DRIVER_AUTHOR "Kevin Sisson <kjsisson@bellsouth.net>"
  92. #define DRIVER_DESC "STV0680 USB Camera Driver"
  94. MODULE_AUTHOR (DRIVER_AUTHOR);
  95. MODULE_DESCRIPTION (DRIVER_DESC);
  96. MODULE_LICENSE ("GPL");
  97. MODULE_PARM (debug, "i");
  98. MODULE_PARM_DESC (debug, "Debug enabled or not");
  99. MODULE_PARM (swapRGB_on, "i");
  100. MODULE_PARM_DESC (swapRGB_on, "Red/blue swap: 1=always, 0=auto, -1=never");
  101. MODULE_PARM (video_nr, "i");
  102. EXPORT_NO_SYMBOLS;
  104. /********************************************************************
  105.  *
  106.  * Memory management
  107.  *
  108.  * This is a shameless copy from the USB-cpia driver (linux kernel
  109.  * version 2.3.29 or so, I have no idea what this code actually does ;).
  110.  * Actually it seems to be a copy of a shameless copy of the bttv-driver.
  111.  * Or that is a copy of a shameless copy of ... (To the powers: is there
  112.  * no generic kernel-function to do this sort of stuff?)
  113.  *
  114.  * Yes, it was a shameless copy from the bttv-driver. IIRC, Alan says
  115.  * there will be one, but apparentely not yet -jerdfelt
  116.  *
  117.  * So I copied it again for the ov511 driver -claudio
  118.  *
  119.  * Same for the se401 driver -Jeroen
  120.  *
  121.  * And the STV0680 driver - Kevin
  122.  ********************************************************************/
  124. /* Given PGD from the address space's page table, return the kernel
  125.  * virtual mapping of the physical memory mapped at ADR.
  126.  */
  127. static inline unsigned long uvirt_to_kva (pgd_t * pgd, unsigned long adr)
  128. {
  129. unsigned long ret = 0UL;
  130. pmd_t *pmd;
  131. pte_t *ptep, pte;
  133. if (!pgd_none (*pgd)) {
  134. pmd = pmd_offset (pgd, adr);
  135. if (!pmd_none (*pmd)) {
  136. ptep = pte_offset (pmd, adr);
  137. pte = *ptep;
  138. if (pte_present (pte)) {
  139. ret = (unsigned long) page_address (pte_page (pte));
  140. ret |= (adr & (PAGE_SIZE - 1));
  141. }
  142. }
  143. }
  144. return ret;
  145. }
  147. /* Here we want the physical address of the memory. This is used when 
  148.  * initializing the contents of the area and marking the pages as reserved.
  149.  */
  150. static inline unsigned long kvirt_to_pa (unsigned long adr)
  151. {
  152. unsigned long va, kva, ret;
  154. va = VMALLOC_VMADDR (adr);
  155. kva = uvirt_to_kva (pgd_offset_k (va), va);
  156. ret = __pa (kva);
  157. return ret;
  158. }
  160. static void *rvmalloc (unsigned long size)
  161. {
  162. void *mem;
  163. unsigned long adr, page;
  165. /* Round it off to PAGE_SIZE */
  166. size += (PAGE_SIZE - 1);
  167. size &= ~(PAGE_SIZE - 1);
  169. mem = vmalloc_32 (size);
  170. if (!mem)
  171. return NULL;
  173. memset (mem, 0, size); /* Clear the ram out, no junk to the user */
  174. adr = (unsigned long) mem;
  175. while (size > 0) {
  176. page = kvirt_to_pa (adr);
  177. mem_map_reserve (virt_to_page (__va (page)));
  178. adr += PAGE_SIZE;
  179. if (size > PAGE_SIZE)
  180. size -= PAGE_SIZE;
  181. else
  182. size = 0;
  183. }
  184. return mem;
  185. }
  187. static void rvfree (void *mem, unsigned long size)
  188. {
  189. unsigned long adr, page;
  191. if (!mem)
  192. return;
  194. size += (PAGE_SIZE - 1);
  195. size &= ~(PAGE_SIZE - 1);
  197. adr = (unsigned long) mem;
  198. while (size > 0) {
  199. page = kvirt_to_pa (adr);
  200. mem_map_unreserve (virt_to_page (__va (page)));
  201. adr += PAGE_SIZE;
  202. if (size > PAGE_SIZE)
  203. size -= PAGE_SIZE;
  204. else
  205. size = 0;
  206. }
  207. vfree (mem);
  208. }
  211. /*********************************************************************
  212.  * pencam read/write functions
  213.  ********************************************************************/
  215. static int stv_sndctrl (int set, struct usb_stv *stv680, unsigned short req, unsigned short value, unsigned char *buffer, int size)
  216. {
  217. int ret = -1;
  219. switch (set) {
  220. case 0: /*  0xc1  */
  221. ret = usb_control_msg (stv680->udev,
  222.        usb_rcvctrlpipe (stv680->udev, 0),
  223.        req,
  224.        (USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_ENDPOINT),
  225.        value, 0, buffer, size, PENCAM_TIMEOUT);
  226. break;
  228. case 1: /*  0x41  */
  229. ret = usb_control_msg (stv680->udev,
  230.        usb_sndctrlpipe (stv680->udev, 0),
  231.        req,
  232.        (USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_ENDPOINT),
  233.        value, 0, buffer, size, PENCAM_TIMEOUT);
  234. break;
  236. case 2: /*  0x80  */
  237. ret = usb_control_msg (stv680->udev,
  238.        usb_rcvctrlpipe (stv680->udev, 0),
  239.        req,
  240.        (USB_DIR_IN | USB_RECIP_DEVICE),
  241.        value, 0, buffer, size, PENCAM_TIMEOUT);
  242. break;
  244. case 3: /*  0x40  */
  245. ret = usb_control_msg (stv680->udev,
  246.        usb_sndctrlpipe (stv680->udev, 0),
  247.        req,
  248.        (USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE),
  249.        value, 0, buffer, size, PENCAM_TIMEOUT);
  250. break;
  252. }
  253. if ((ret < 0) && (req != 0x0a)) {
  254. PDEBUG (1, "STV(e): usb_control_msg error %i, request = 0x%x, error = %i", set, req, ret);
  255. }
  256. return ret;
  257. }
  259. static int stv_set_config (struct usb_stv *dev, int configuration, int interface, int alternate)
  260. {
  262. if (usb_set_configuration (dev->udev, configuration) < 0) {
  263. PDEBUG (1, "STV(e): FAILED to set configuration %i", configuration);
  264. return -1;
  265. }
  266. if (usb_set_interface (dev->udev, interface, alternate) < 0) {
  267. PDEBUG (1, "STV(e): FAILED to set alternate interface %i", alternate);
  268. return -1;
  269. }
  270. return 0;
  271. }
  273. static int stv_stop_video (struct usb_stv *dev)
  274. {
  275. int i;
  276. unsigned char *buf;
  278. buf = kmalloc (40, GFP_KERNEL);
  279. if (buf == NULL) {
  280. PDEBUG (0, "STV(e): Out of (small buf) memory");
  281. return -1;
  282. }
  284. /* this is a high priority command; it stops all lower order commands */
  285. if ((i = stv_sndctrl (1, dev, 0x04, 0x0000, buf, 0x0)) < 0) {
  286. i = stv_sndctrl (0, dev, 0x80, 0, buf, 0x02); /* Get Last Error; 2 = busy */
  287. PDEBUG (1, "STV(i): last error: %i,  command = 0x%x", buf[0], buf[1]);
  288. } else {
  289. PDEBUG (1, "STV(i): Camera reset to idle mode.");
  290. }
  292. if ((i = stv_set_config (dev, 1, 0, 0)) < 0)
  293. PDEBUG (1, "STV(e): Reset config during exit failed");
  295. /*  get current mode  */
  296. buf[0] = 0xf0;
  297. if ((i = stv_sndctrl (0, dev, 0x87, 0, buf, 0x08)) != 0x08) /* get mode */
  298. PDEBUG (0, "STV(e): Stop_video: problem setting original mode");
  299. if (dev->origMode != buf[0]) {
  300. memset (buf, 0, 8);
  301. buf[0] = (unsigned char) dev->origMode;
  302. if ((i = stv_sndctrl (3, dev, 0x07, 0x0100, buf, 0x08)) != 0x08) {
  303. PDEBUG (0, "STV(e): Stop_video: Set_Camera_Mode failed");
  304. i = -1;
  305. }
  306. buf[0] = 0xf0;
  307. i = stv_sndctrl (0, dev, 0x87, 0, buf, 0x08);
  308. if ((i != 0x08) || (buf[0] != dev->origMode)) {
  309. PDEBUG (0, "STV(e): camera NOT set to original resolution.");
  310. i = -1;
  311. } else
  312. PDEBUG (0, "STV(i): Camera set to original resolution");
  313. }
  314. /* origMode */
  315. kfree (buf);
  316. return i;
  317. }
  319. static int stv_set_video_mode (struct usb_stv *dev)
  320. {
  321. int i, stop_video = 1;
  322. unsigned char *buf;
  324. buf = kmalloc (40, GFP_KERNEL);
  325. if (buf == NULL) {
  326. PDEBUG (0, "STV(e): Out of (small buf) memory");
  327. return -1;
  328. }
  330. if ((i = stv_set_config (dev, 1, 0, 0)) < 0) {
  331. kfree (buf);
  332. return i;
  333. }
  335. i = stv_sndctrl (2, dev, 0x06, 0x0100, buf, 0x12);
  336. if (!(i > 0) && (buf[8] == 0x53) && (buf[9] == 0x05)) {
  337. PDEBUG (1, "STV(e): Could not get descriptor 0100.");
  338. goto error;
  339. }
  341. /*  set alternate interface 1 */
  342. if ((i = stv_set_config (dev, 1, 0, 1)) < 0)
  343. goto error;
  345. if ((i = stv_sndctrl (0, dev, 0x85, 0, buf, 0x10)) != 0x10)
  346. goto error;
  347. PDEBUG (1, "STV(i): Setting video mode.");
  348. /*  Switch to Video mode: 0x0100 = VGA (640x480), 0x0000 = CIF (352x288) 0x0300 = QVGA (320x240)  */
  349. if ((i = stv_sndctrl (1, dev, 0x09, dev->VideoMode, buf, 0x0)) < 0) {
  350. stop_video = 0;
  351. goto error;
  352. }
  353. goto exit;
  355. error:
  356. kfree (buf);
  357. if (stop_video == 1)
  358. stv_stop_video (dev);
  359. return -1;
  361. exit:
  362. kfree (buf);
  363. return 0;
  364. }
  366. static int stv_init (struct usb_stv *stv680)
  367. {
  368. int i = 0;
  369. unsigned char *buffer;
  370. unsigned long int bufsize;
  372. buffer = kmalloc (40, GFP_KERNEL);
  373. if (buffer == NULL) {
  374. PDEBUG (0, "STV(e): Out of (small buf) memory");
  375. return -1;
  376. }
  377. memset (buffer, 0, 40);
  378. udelay (100);
  380. /* set config 1, interface 0, alternate 0 */
  381. if ((i = stv_set_config (stv680, 1, 0, 0)) < 0) {
  382. kfree (buffer);
  383. PDEBUG (0, "STV(e): set config 1,0,0 failed");
  384. return -1;
  385. }
  386. /* ping camera to be sure STV0680 is present */
  387. if ((i = stv_sndctrl (0, stv680, 0x88, 0x5678, buffer, 0x02)) != 0x02)
  388. goto error;
  389. if ((buffer[0] != 0x56) || (buffer[1] != 0x78)) {
  390. PDEBUG (1, "STV(e): camera ping failed!!");
  391. goto error;
  392. }
  394. /* get camera descriptor */
  395. if ((i = stv_sndctrl (2, stv680, 0x06, 0x0200, buffer, 0x09)) != 0x09)
  396. goto error;
  397. i = stv_sndctrl (2, stv680, 0x06, 0x0200, buffer, 0x22);
  398. if (!(i >= 0) && (buffer[7] == 0xa0) && (buffer[8] == 0x23)) {
  399. PDEBUG (1, "STV(e): Could not get descriptor 0200.");
  400. goto error;
  401. }
  402. if ((i = stv_sndctrl (0, stv680, 0x8a, 0, buffer, 0x02)) != 0x02)
  403. goto error;
  404. if ((i = stv_sndctrl (0, stv680, 0x8b, 0, buffer, 0x24)) != 0x24)
  405. goto error;
  406. if ((i = stv_sndctrl (0, stv680, 0x85, 0, buffer, 0x10)) != 0x10)
  407. goto error;
  409. stv680->SupportedModes = buffer[7];
  410. i = stv680->SupportedModes;
  411. stv680->CIF = 0;
  412. stv680->VGA = 0;
  413. stv680->QVGA = 0;
  414. if (i & 1)
  415. stv680->CIF = 1;
  416. if (i & 2)
  417. stv680->VGA = 1;
  418. if (i & 8)
  419. stv680->QVGA = 1;
  420. if (stv680->SupportedModes == 0) {
  421. PDEBUG (0, "STV(e): There are NO supported STV680 modes!!");
  422. i = -1;
  423. goto error;
  424. } else {
  425. if (stv680->CIF)
  426. PDEBUG (0, "STV(i): CIF is supported");
  427. if (stv680->QVGA)
  428. PDEBUG (0, "STV(i): QVGA is supported");
  429. }
  430. /* FW rev, ASIC rev, sensor ID  */
  431. PDEBUG (1, "STV(i): Firmware rev is %i.%i", buffer[0], buffer[1]);
  432. PDEBUG (1, "STV(i): ASIC rev is %i.%i", buffer[2], buffer[3]);
  433. PDEBUG (1, "STV(i): Sensor ID is %i", (buffer[4]*16) + (buffer[5]>>4));
  435. /*  set alternate interface 1 */
  436. if ((i = stv_set_config (stv680, 1, 0, 1)) < 0)
  437. goto error;
  439. if ((i = stv_sndctrl (0, stv680, 0x85, 0, buffer, 0x10)) != 0x10)
  440. goto error;
  441. if ((i = stv_sndctrl (0, stv680, 0x8d, 0, buffer, 0x08)) != 0x08)
  442. goto error;
  443. i = buffer[3];
  444. PDEBUG (0, "STV(i): Camera has %i pictures.", i);
  446. /*  get current mode */
  447. if ((i = stv_sndctrl (0, stv680, 0x87, 0, buffer, 0x08)) != 0x08)
  448. goto error;
  449. stv680->origMode = buffer[0]; /* 01 = VGA, 03 = QVGA, 00 = CIF */
  451. /* This will attemp CIF mode, if supported. If not, set to QVGA  */
  452. memset (buffer, 0, 8);
  453. if (stv680->CIF)
  454. buffer[0] = 0x00;
  455. else if (stv680->QVGA)
  456. buffer[0] = 0x03;
  457. if ((i = stv_sndctrl (3, stv680, 0x07, 0x0100, buffer, 0x08)) != 0x08) {
  458. PDEBUG (0, "STV(i): Set_Camera_Mode failed");
  459. i = -1;
  460. goto error;
  461. }
  462. buffer[0] = 0xf0;
  463. stv_sndctrl (0, stv680, 0x87, 0, buffer, 0x08);
  464. if (((stv680->CIF == 1) && (buffer[0] != 0x00)) || ((stv680->QVGA == 1) && (buffer[0] != 0x03))) {
  465. PDEBUG (0, "STV(e): Error setting camera video mode!");
  466. i = -1;
  467. goto error;
  468. } else {
  469. if (buffer[0] == 0) {
  470. stv680->VideoMode = 0x0000;
  471. PDEBUG (0, "STV(i): Video Mode set to CIF");
  472. }
  473. if (buffer[0] == 0x03) {
  474. stv680->VideoMode = 0x0300;
  475. PDEBUG (0, "STV(i): Video Mode set to QVGA");
  476. }
  477. }
  478. if ((i = stv_sndctrl (0, stv680, 0x8f, 0, buffer, 0x10)) != 0x10)
  479. goto error;
  480. bufsize = (buffer[0] << 24) | (buffer[1] << 16) | (buffer[2] << 8) | (buffer[3]);
  481. stv680->cwidth = (buffer[4] << 8) | (buffer[5]); /* ->camera = 322, 356, 644  */
  482. stv680->cheight = (buffer[6] << 8) | (buffer[7]); /* ->camera = 242, 292, 484  */
  483. stv680->origGain = buffer[12];
  485. goto exit;
  487. error:
  488. i = stv_sndctrl (0, stv680, 0x80, 0, buffer, 0x02); /* Get Last Error */
  489. PDEBUG (1, "STV(i): last error: %i,  command = 0x%x", buffer[0], buffer[1]);
  490. kfree (buffer);
  491. return -1;
  493. exit:
  494. kfree (buffer);
  496. /* video = 320x240, 352x288 */
  497. if (stv680->CIF == 1) {
  498. stv680->maxwidth = 352;
  499. stv680->maxheight = 288;
  500. stv680->vwidth = 352;
  501. stv680->vheight = 288;
  502. }
  503. if (stv680->QVGA == 1) {
  504. stv680->maxwidth = 320;
  505. stv680->maxheight = 240;
  506. stv680->vwidth = 320;
  507. stv680->vheight = 240;
  508. }
  510. stv680->rawbufsize = bufsize; /* must be ./. by 8 */
  511. stv680->maxframesize = bufsize * 3; /* RGB size */
  512. PDEBUG (2, "STV(i): cwidth = %i, cheight = %i", stv680->cwidth, stv680->cheight);
  513. PDEBUG (1, "STV(i): width = %i, height = %i, rawbufsize = %li", stv680->vwidth, stv680->vheight, stv680->rawbufsize);
  515. /* some default values */
  516. stv680->bulk_in_endpointAddr = 0x82;
  517. stv680->dropped = 0;
  518. stv680->error = 0;
  519. stv680->framecount = 0;
  520. stv680->readcount = 0;
  521. stv680->streaming = 0;
  522. /* bright, white, colour, hue, contrast are set by software, not in stv0680 */
  523. stv680->brightness = 32767;
  524. stv680->chgbright = 0;
  525. stv680->whiteness = 0; /* only for greyscale */
  526. stv680->colour = 32767;
  527. stv680->contrast = 32767;
  528. stv680->hue = 32767;
  529. stv680->palette = STV_VIDEO_PALETTE;
  530. stv680->depth = 24; /* rgb24 bits */
  531. swapRGB = 0;
  532. if ((swapRGB_on == 0) && (swapRGB == 0))
  533. PDEBUG (1, "STV(i): swapRGB is (auto) OFF");
  534. else if ((swapRGB_on == 1) && (swapRGB == 1))
  535. PDEBUG (1, "STV(i): swapRGB is (auto) ON");
  536. else if (swapRGB_on == 1)
  537. PDEBUG (1, "STV(i): swapRGB is (forced) ON");
  538. else if (swapRGB_on == -1)
  539. PDEBUG (1, "STV(i): swapRGB is (forced) OFF");
  541. if (stv_set_video_mode (stv680) < 0) {
  542. PDEBUG (0, "STV(e): Could not set video mode in stv_init");
  543. return -1;
  544. }
  546. return 0;
  547. }
  549. /***************** last of pencam  routines  *******************/
  551. /********************************************************************
  552.  * /proc interface
  553.  *******************************************************************/
  555. #if defined(CONFIG_PROC_FS) && defined(CONFIG_VIDEO_PROC_FS)
  557. static struct proc_dir_entry *stv680_proc_entry = NULL;
  558. extern struct proc_dir_entry *video_proc_entry;
  560. #define YES_NO(x) ((x) ? "yes" : "no")
  561. #define ON_OFF(x) ((x) ? "(auto) on" : "(auto) off")
  563. static int stv680_read_proc (char *page, char **start, off_t off, int count, int *eof, void *data)
  564. {
  565. char *out = page;
  566. int len;
  567. struct usb_stv *stv680 = data;
  569. /* Stay under PAGE_SIZE or else bla bla bla.... */
  571. out += sprintf (out, "driver_version  : %sn", DRIVER_VERSION);
  572. out += sprintf (out, "model           : %sn", stv680->camera_name);
  573. out += sprintf (out, "in use          : %sn", YES_NO (stv680->user));
  574. out += sprintf (out, "streaming       : %sn", YES_NO (stv680->streaming));
  575. out += sprintf (out, "num_frames      : %dn", STV680_NUMFRAMES);
  577. out += sprintf (out, "Current size    : %ix%in", stv680->vwidth, stv680->vheight);
  578. if (swapRGB_on == 0)
  579. out += sprintf (out, "swapRGB         : %sn", ON_OFF (swapRGB));
  580. else if (swapRGB_on == 1)
  581. out += sprintf (out, "swapRGB         : (forced) onn");
  582. else if (swapRGB_on == -1)
  583. out += sprintf (out, "swapRGB         : (forced) offn");
  585. out += sprintf (out, "Palette         : %i", stv680->palette);
  587. out += sprintf (out, "n");
  589. out += sprintf (out, "Frames total    : %dn", stv680->readcount);
  590. out += sprintf (out, "Frames read     : %dn", stv680->framecount);
  591. out += sprintf (out, "Packets dropped : %dn", stv680->dropped);
  592. out += sprintf (out, "Decoding Errors : %dn", stv680->error);
  594. len = out - page;
  595. len -= off;
  596. if (len < count) {
  597. *eof = 1;
  598. if (len <= 0)
  599. return 0;
  600. } else
  601. len = count;
  603. *start = page + off;
  604. return len;
  605. }
  607. static int create_proc_stv680_cam (struct usb_stv *stv680)
  608. {
  609. char name[9];
  610. struct proc_dir_entry *ent;
  612. if (!stv680_proc_entry || !stv680)
  613. return -1;
  615. sprintf (name, "video%d", stv680->vdev.minor);
  617. ent = create_proc_entry (name, S_IFREG | S_IRUGO | S_IWUSR, stv680_proc_entry);
  618. if (!ent)
  619. return -1;
  621. ent->data = stv680;
  622. ent->read_proc = stv680_read_proc;
  623. stv680->proc_entry = ent;
  624. return 0;
  625. }
  627. static void destroy_proc_stv680_cam (struct usb_stv *stv680)
  628. {
  629. /* One to much, just to be sure :) */
  630. char name[9];
  632. if (!stv680 || !stv680->proc_entry)
  633. return;
  635. sprintf (name, "video%d", stv680->vdev.minor);
  636. remove_proc_entry (name, stv680_proc_entry);
  637. stv680->proc_entry = NULL;
  638. }
  640. static int proc_stv680_create (void)
  641. {
  642. if (video_proc_entry == NULL) {
  643. PDEBUG (0, "STV(e): /proc/video/ doesn't exist!");
  644. return -1;
  645. }
  646. stv680_proc_entry = create_proc_entry ("stv680", S_IFDIR, video_proc_entry);
  648. if (stv680_proc_entry) {
  649. stv680_proc_entry->owner = THIS_MODULE;
  650. } else {
  651. PDEBUG (0, "STV(e): Unable to initialize /proc/video/stv680");
  652. return -1;
  653. }
  654. return 0;
  655. }
  657. static void proc_stv680_destroy (void)
  658. {
  659. if (stv680_proc_entry == NULL)
  660. return;
  662. remove_proc_entry ("stv", video_proc_entry);
  663. }
  664. #endif /* CONFIG_PROC_FS && CONFIG_VIDEO_PROC_FS */
  666. /********************************************************************
  667.  * Camera control
  668.  *******************************************************************/
  670. static int stv680_get_pict (struct usb_stv *stv680, struct video_picture *p)
  671. {
  672. /* This sets values for v4l interface. max/min = 65535/0  */
  674. p->brightness = stv680->brightness;
  675. p->whiteness = stv680->whiteness; /* greyscale */
  676. p->colour = stv680->colour;
  677. p->contrast = stv680->contrast;
  678. p->hue = stv680->hue;
  679. p->palette = stv680->palette;
  680. p->depth = stv680->depth;
  681. return 0;
  682. }
  684. static int stv680_set_pict (struct usb_stv *stv680, struct video_picture *p)
  685. {
  686. /* See above stv680_get_pict  */
  688. if (p->palette != STV_VIDEO_PALETTE) {
  689. PDEBUG (2, "STV(e): Palette set error in _set_pic");
  690. return 1;
  691. }
  693. if (stv680->brightness != p->brightness) {
  694. stv680->chgbright = 1;
  695. stv680->brightness = p->brightness;
  696. } 
  698. stv680->whiteness = p->whiteness; /* greyscale */
  699. stv680->colour = p->colour;
  700. stv680->contrast = p->contrast;
  701. stv680->hue = p->hue;
  702. stv680->palette = p->palette;
  703. stv680->depth = p->depth;
  705. return 0;
  706. }
  708. static void stv680_video_irq (struct urb *urb)
  709. {
  710. struct usb_stv *stv680 = urb->context;
  711. int length = urb->actual_length;
  713. if (length < stv680->rawbufsize)
  714. PDEBUG (2, "STV(i): Lost data in transfer: exp %li, got %i", stv680->rawbufsize, length);
  716. /* ohoh... */
  717. if (!stv680->streaming)
  718. return;
  720. if (!stv680->udev) {
  721. PDEBUG (0, "STV(e): device vapourished in video_irq");
  722. return;
  723. }
  725. /* 0 sized packets happen if we are to fast, but sometimes the camera
  726.    keeps sending them forever...
  727.  */
  728. if (length && !urb->status) {
  729. stv680->nullpackets = 0;
  730. switch (stv680->scratch[stv680->scratch_next].state) {
  731. case BUFFER_READY:
  732. case BUFFER_BUSY:
  733. stv680->dropped++;
  734. break;
  736. case BUFFER_UNUSED:
  737. memcpy (stv680->scratch[stv680->scratch_next].data,
  738.         (unsigned char *) urb->transfer_buffer, length);
  739. stv680->scratch[stv680->scratch_next].state = BUFFER_READY;
  740. stv680->scratch[stv680->scratch_next].length = length;
  741. if (waitqueue_active (&stv680->wq)) {
  742. wake_up_interruptible (&stv680->wq);
  743. }
  744. stv680->scratch_overflow = 0;
  745. stv680->scratch_next++;
  746. if (stv680->scratch_next >= STV680_NUMSCRATCH)
  747. stv680->scratch_next = 0;;
  748. break;
  749. } /* switch  */
  750. } else {
  751. stv680->nullpackets++;
  752. if (stv680->nullpackets > STV680_MAX_NULLPACKETS) {
  753. if (waitqueue_active (&stv680->wq)) {
  754. wake_up_interruptible (&stv680->wq);
  755. }
  756. }
  757. } /*  if - else */
  759. /* Resubmit urb for new data */
  760. urb->status = 0;
  761. urb->dev = stv680->udev;
  762. if (usb_submit_urb (urb))
  763. PDEBUG (0, "STV(e): urb burned down in video irq");
  764. return;
  765. } /*  _video_irq  */
  767. static int stv680_start_stream (struct usb_stv *stv680)
  768. {
  769. urb_t *urb;
  770. int err = 0, i;
  772. stv680->streaming = 1;
  774. /* Do some memory allocation */
  775. for (i = 0; i < STV680_NUMFRAMES; i++) {
  776. stv680->frame[i].data = stv680->fbuf + i * stv680->maxframesize;
  777. stv680->frame[i].curpix = 0;
  778. }
  779. /* packet size = 4096  */
  780. for (i = 0; i < STV680_NUMSBUF; i++) {
  781. stv680->sbuf[i].data = kmalloc (stv680->rawbufsize, GFP_KERNEL);
  782. if (stv680->sbuf[i].data == NULL) {
  783. PDEBUG (0, "STV(e): Could not kmalloc raw data buffer %i", i);
  784. return -1;
  785. }
  786. }
  788. stv680->scratch_next = 0;
  789. stv680->scratch_use = 0;
  790. stv680->scratch_overflow = 0;
  791. for (i = 0; i < STV680_NUMSCRATCH; i++) {
  792. stv680->scratch[i].data = kmalloc (stv680->rawbufsize, GFP_KERNEL);
  793. if (stv680->scratch[i].data == NULL) {
  794. PDEBUG (0, "STV(e): Could not kmalloc raw scratch buffer %i", i);
  795. return -1;
  796. }
  797. stv680->scratch[i].state = BUFFER_UNUSED;
  798. }
  800. for (i = 0; i < STV680_NUMSBUF; i++) {
  801. urb = usb_alloc_urb (0);
  802. if (!urb)
  803. return ENOMEM;
  805. /* sbuf is urb->transfer_buffer, later gets memcpyed to scratch */
  806. usb_fill_bulk_urb (urb, stv680->udev,
  807.    usb_rcvbulkpipe (stv680->udev, stv680->bulk_in_endpointAddr),
  808.    stv680->sbuf[i].data, stv680->rawbufsize,
  809.    stv680_video_irq, stv680);
  810. urb->timeout = PENCAM_TIMEOUT * 2;
  811. urb->transfer_flags |= USB_QUEUE_BULK;
  812. stv680->urb[i] = urb;
  813. err = usb_submit_urb (stv680->urb[i]);
  814. if (err)
  815. PDEBUG (0, "STV(e): urb burned down in start stream");
  816. } /* i STV680_NUMSBUF */
  818. stv680->framecount = 0;
  819. return 0;
  820. }
  822. static int stv680_stop_stream (struct usb_stv *stv680)
  823. {
  824. int i;
  826. if (!stv680->streaming || !stv680->udev)
  827. return 1;
  829. stv680->streaming = 0;
  831. for (i = 0; i < STV680_NUMSBUF; i++)
  832. if (stv680->urb[i]) {
  833. stv680->urb[i]->next = NULL;
  834. usb_unlink_urb (stv680->urb[i]);
  835. usb_free_urb (stv680->urb[i]);
  836. stv680->urb[i] = NULL;
  837. kfree (stv680->sbuf[i].data);
  838. }
  839. for (i = 0; i < STV680_NUMSCRATCH; i++) {
  840. kfree (stv680->scratch[i].data);
  841. stv680->scratch[i].data = NULL;
  842. }
  844. return 0;
  845. }
  847. static int stv680_set_size (struct usb_stv *stv680, int width, int height)
  848. {
  849. int wasstreaming = stv680->streaming;
  851. /* Check to see if we need to change */
  852. if ((stv680->vwidth == width) && (stv680->vheight == height))
  853. return 0;
  855. PDEBUG (1, "STV(i): size request for %i x %i", width, height);
  856. /* Check for a valid mode */
  857. if ((!width || !height) || ((width & 1) || (height & 1))) {
  858. PDEBUG (1, "STV(e): set_size error: request: v.width = %i, v.height = %i  actual: stv.width = %i, stv.height = %i", width, height, stv680->vwidth, stv680->vheight);
  859. return 1;
  860. }
  862. if ((width < (stv680->maxwidth / 2)) || (height < (stv680->maxheight / 2))) {
  863. width = stv680->maxwidth / 2;
  864. height = stv680->maxheight / 2;
  865. } else if ((width >= 158) && (width <= 166)) {
  866. width = 160;
  867. height = 120;
  868. } else if ((width >= 172) && (width <= 180)) {
  869. width = 176;
  870. height = 144;
  871. } else if ((width >= 318) && (width <= 350)) {
  872. width = 320;
  873. height = 240;
  874. } else if ((width >= 350) && (width <= 358)) {
  875. width = 352;
  876. height = 288;
  877. }
  879. /* Stop a current stream and start it again at the new size */
  880. if (wasstreaming)
  881. stv680_stop_stream (stv680);
  882. stv680->vwidth = width;
  883. stv680->vheight = height;
  884. PDEBUG (1, "STV(i): size set to %i x %i", stv680->vwidth, stv680->vheight);
  885. if (wasstreaming)
  886. stv680_start_stream (stv680);
  888. return 0;
  889. }
  891. /**********************************************************************
  892.  * Video Decoding
  893.  **********************************************************************/
  895. /*******  routines from the pencam program; hey, they work!  ********/
  897. /*
  898.  * STV0680 Vision Camera Chipset Driver
  899.  * Copyright (C) 2000 Adam Harrison <adam@antispin.org> 
  900. */
  902. #define RED 0
  903. #define GREEN 1
  904. #define BLUE 2
  905. #define AD(x, y, w) (((y)*(w)+(x))*3)
  907. static void bayer_unshuffle (struct usb_stv *stv680, struct stv680_scratch *buffer)
  908. {
  909. int x, y, i;
  910. int w = stv680->cwidth;
  911. int vw = stv680->cwidth, vh = stv680->cheight;
  912. unsigned int p = 0;
  913. int colour = 0, bayer = 0;
  914. unsigned char *raw = buffer->data;
  915. struct stv680_frame *frame = &stv680->frame[stv680->curframe];
  916. unsigned char *output = frame->data;
  917. unsigned char *temp = frame->data;
  918. int offset = buffer->offset;
  920. if (frame->curpix == 0) {
  921. if (frame->grabstate == FRAME_READY) {
  922. frame->grabstate = FRAME_GRABBING;
  923. }
  924. }
  925. if (offset != frame->curpix) { /* Regard frame as lost :( */
  926. frame->curpix = 0;
  927. stv680->error++;
  928. return;
  929. }
  931. if ((stv680->vwidth == 320) || (stv680->vwidth == 160)) {
  932. vw = 320;
  933. vh = 240;
  934. }
  935. if ((stv680->vwidth == 352) || (stv680->vwidth == 176)) {
  936. vw = 352;
  937. vh = 288;
  938. }
  940. memset (output, 0, 3 * vw * vh); /* clear output matrix. */
  942. for (y = 0; y < vh; y++) {
  943. for (x = 0; x < vw; x++) {
  944. if (x & 1)
  945. p = *(raw + y * w + (x >> 1));
  946. else
  947. p = *(raw + y * w + (x >> 1) + (w >> 1));
  949. if (y & 1)
  950. bayer = 2;
  951. else
  952. bayer = 0;
  953. if (x & 1)
  954. bayer++;
  956. switch (bayer) {
  957. case 0:
  958. case 3:
  959. colour = 1;
  960. break;
  961. case 1:
  962. colour = 0;
  963. break;
  964. case 2:
  965. colour = 2;
  966. break;
  967. }
  968. i = (y * vw + x) * 3;
  969. *(output + i + colour) = (unsigned char) p;
  970. } /* for x */
  972. } /* for y */
  974. /****** gamma correction plus hardcoded white balance */
  975. /* Thanks to Alexander Schwartx <alexander.schwartx@gmx.net> for this code.
  976.    Correction values red[], green[], blue[], are generated by 
  977.    (pow(i/256.0, GAMMA)*255.0)*white balanceRGB where GAMMA=0.55, 1<i<255. 
  978.    White balance (RGB)= 1.0, 1.17, 1.48. Values are calculated as double float and 
  979.    converted to unsigned char. Values are in stv680.h  */
  981. for (y = 0; y < vh; y++) {
  982. for (x = 0; x < vw; x++) {
  983. i = (y * vw + x) * 3;
  984. *(output + i) = red[*(output + i)];
  985. *(output + i + 1) = green[*(output + i + 1)];
  986. *(output + i + 2) = blue[*(output + i + 2)];
  987. }
  988. }
  990. /******  bayer demosaic  ******/
  991. for (y = 1; y < (vh - 1); y++) {
  992. for (x = 1; x < (vw - 1); x++) { /* work out pixel type */
  993. if (y & 1)
  994. bayer = 0;
  995. else
  996. bayer = 2;
  997. if (!(x & 1))
  998. bayer++;
  1000. switch (bayer) {
  1001. case 0: /* green. blue lr, red tb */
  1002. *(output + AD (x, y, vw) + BLUE) = ((int) *(output + AD (x - 1, y, vw) + BLUE) + (int) *(output + AD (x + 1, y, vw) + BLUE)) >> 1;
  1003. *(output + AD (x, y, vw) + RED) = ((int) *(output + AD (x, y - 1, vw) + RED) + (int) *(output + AD (x, y + 1, vw) + RED)) >> 1;
  1004. break;
  1006. case 1: /* blue. green lrtb, red diagonals */
  1007. *(output + AD (x, y, vw) + GREEN) = ((int) *(output + AD (x - 1, y, vw) + GREEN) + (int) *(output + AD (x + 1, y, vw) + GREEN) + (int) *(output + AD (x, y - 1, vw) + GREEN) + (int) *(output + AD (x, y + 1, vw) + GREEN)) >> 2;
  1008. *(output + AD (x, y, vw) + RED) = ((int) *(output + AD (x - 1, y - 1, vw) + RED) + (int) *(output + AD (x - 1, y + 1, vw) + RED) + (int) *(output + AD (x + 1, y - 1, vw) + RED) + (int) *(output + AD (x + 1, y + 1, vw) + RED)) >> 2;
  1009. break;
  1011. case 2: /* red. green lrtb, blue diagonals */
  1012. *(output + AD (x, y, vw) + GREEN) = ((int) *(output + AD (x - 1, y, vw) + GREEN) + (int) *(output + AD (x + 1, y, vw) + GREEN) + (int) *(output + AD (x, y - 1, vw) + GREEN) + (int) *(output + AD (x, y + 1, vw) + GREEN)) >> 2;
  1013. *(output + AD (x, y, vw) + BLUE) = ((int) *(output + AD (x - 1, y - 1, vw) + BLUE) + (int) *(output + AD (x + 1, y - 1, vw) + BLUE) + (int) *(output + AD (x - 1, y + 1, vw) + BLUE) + (int) *(output + AD (x + 1, y + 1, vw) + BLUE)) >> 2;
  1014. break;
  1016. case 3: /* green. red lr, blue tb */
  1017. *(output + AD (x, y, vw) + RED) = ((int) *(output + AD (x - 1, y, vw) + RED) + (int) *(output + AD (x + 1, y, vw) + RED)) >> 1;
  1018. *(output + AD (x, y, vw) + BLUE) = ((int) *(output + AD (x, y - 1, vw) + BLUE) + (int) *(output + AD (x, y + 1, vw) + BLUE)) >> 1;
  1019. break;
  1020. } /* switch */
  1021. } /* for x */
  1022. } /* for y  - end demosaic  */
  1024. /* fix top and bottom row, left and right side */
  1025. i = vw * 3;
  1026. memcpy (output, (output + i), i);
  1027. memcpy ((output + (vh * i)), (output + ((vh - 1) * i)), i);
  1028. for (y = 0; y < vh; y++) {
  1029. i = y * vw * 3;
  1030. memcpy ((output + i), (output + i + 3), 3);
  1031. memcpy ((output + i + (vw * 3)), (output + i + (vw - 1) * 3), 3);
  1032. }
  1034. /*  process all raw data, then trim to size if necessary */
  1035. if ((stv680->vwidth == 160) || (stv680->vwidth == 176))  {
  1036. i = 0;
  1037. for (y = 0; y < vh; y++) {
  1038. if (!(y & 1)) {
  1039. for (x = 0; x < vw; x++) {
  1040. p = (y * vw + x) * 3;
  1041. if (!(x & 1)) {
  1042. *(output + i) = *(output + p);
  1043. *(output + i + 1) = *(output + p + 1);
  1044. *(output + i + 2) = *(output + p + 2);
  1045. i += 3;
  1046. }
  1047. }  /* for x */
  1048. }
  1049. }  /* for y */
  1050. }
  1051. /* reset to proper width */
  1052. if ((stv680->vwidth == 160)) {
  1053. vw = 160;
  1054. vh = 120;
  1055. }
  1056. if ((stv680->vwidth == 176)) {
  1057. vw = 176;
  1058. vh = 144;
  1059. }
  1061. /* output is RGB; some programs want BGR  */
  1062. /* swapRGB_on=0 -> program decides;  swapRGB_on=1, always swap */
  1063. /* swapRGB_on=-1, never swap */
  1064. if (((swapRGB == 1) && (swapRGB_on != -1)) || (swapRGB_on == 1)) {
  1065. for (y = 0; y < vh; y++) {
  1066. for (x = 0; x < vw; x++) {
  1067. i = (y * vw + x) * 3;
  1068. *(temp) = *(output + i);
  1069. *(output + i) = *(output + i + 2);
  1070. *(output + i + 2) = *(temp);
  1071. }
  1072. }
  1073. }
  1074. /* brightness */
  1075. if (stv680->chgbright == 1) {
  1076. if (stv680->brightness >= 32767) {
  1077. p = (stv680->brightness - 32767) / 256;
  1078. for (x = 0; x < (vw * vh * 3); x++) {
  1079. if ((*(output + x) + (unsigned char) p) > 255)
  1080. *(output + x) = 255;
  1081. else
  1082. *(output + x) += (unsigned char) p;
  1083. } /* for */
  1084. } else {
  1085. p = (32767 - stv680->brightness) / 256;
  1086. for (x = 0; x < (vw * vh * 3); x++) {
  1087. if ((unsigned char) p > *(output + x))
  1088. *(output + x) = 0;
  1089. else
  1090. *(output + x) -= (unsigned char) p;
  1091. } /* for */
  1092. } /* else */
  1093. }
  1094. /* if */
  1095. frame->curpix = 0;
  1096. frame->curlinepix = 0;
  1097. frame->grabstate = FRAME_DONE;
  1098. stv680->framecount++;
  1099. stv680->readcount++;
  1100. if (stv680->frame[(stv680->curframe + 1) & (STV680_NUMFRAMES - 1)].grabstate == FRAME_READY) {
  1101. stv680->curframe = (stv680->curframe + 1) & (STV680_NUMFRAMES - 1);
  1102. }
  1104. } /* bayer_unshuffle */
  1106. /*******  end routines from the pencam program  *********/
  1108. static int stv680_newframe (struct usb_stv *stv680, int framenr)
  1109. {
  1110. int errors = 0;
  1112. while (stv680->streaming && (stv680->frame[framenr].grabstate == FRAME_READY || stv680->frame[framenr].grabstate == FRAME_GRABBING)) {
  1113. if (!stv680->frame[framenr].curpix) {
  1114. errors++;
  1115. }
  1116. wait_event_interruptible (stv680->wq, (stv680->scratch[stv680->scratch_use].state == BUFFER_READY));
  1118. if (stv680->nullpackets > STV680_MAX_NULLPACKETS) {
  1119. stv680->nullpackets = 0;
  1120. PDEBUG (2, "STV(i): too many null length packets, restarting capture");
  1121. stv680_stop_stream (stv680);
  1122. stv680_start_stream (stv680);
  1123. } else {
  1124. if (stv680->scratch[stv680->scratch_use].state != BUFFER_READY) {
  1125. stv680->frame[framenr].grabstate = FRAME_ERROR;
  1126. PDEBUG (2, "STV(e): FRAME_ERROR in _newframe");
  1127. return -EIO;
  1128. }
  1129. stv680->scratch[stv680->scratch_use].state = BUFFER_BUSY;
  1131. bayer_unshuffle (stv680, &stv680->scratch[stv680->scratch_use]);
  1133. stv680->scratch[stv680->scratch_use].state = BUFFER_UNUSED;
  1134. stv680->scratch_use++;
  1135. if (stv680->scratch_use >= STV680_NUMSCRATCH)
  1136. stv680->scratch_use = 0;
  1137. if (errors > STV680_MAX_ERRORS) {
  1138. errors = 0;
  1139. PDEBUG (2, "STV(i): too many errors, restarting capture");
  1140. stv680_stop_stream (stv680);
  1141. stv680_start_stream (stv680);
  1142. }
  1143. } /* else */
  1144. } /* while */
  1145. return 0;
  1146. }
  1148. /*********************************************************************
  1149.  * Video4Linux
  1150.  *********************************************************************/
  1152. static int stv_open (struct video_device *dev, int flags)
  1153. {
  1154. struct usb_stv *stv680 = (struct usb_stv *) dev;
  1155. int err = 0;
  1157. /* we are called with the BKL held */
  1158. MOD_INC_USE_COUNT;
  1159. stv680->user = 1;
  1160. err = stv_init (stv680); /* main initialization routine for camera */
  1162. if (err >= 0) {
  1163. stv680->fbuf = rvmalloc (stv680->maxframesize * STV680_NUMFRAMES);
  1164. if (!stv680->fbuf) {
  1165. PDEBUG (0, "STV(e): Could not rvmalloc frame bufer");
  1166. err = -ENOMEM;
  1167. }
  1168. }
  1169. if (err) {
  1170. MOD_DEC_USE_COUNT;
  1171. stv680->user = 0;
  1172. }
  1174. return err;
  1175. }
  1177. static void stv_close (struct video_device *dev)
  1178. {
  1179. /* called with BKL held */
  1180. struct usb_stv *stv680 = (struct usb_stv *) dev;
  1181. int i;
  1183. for (i = 0; i < STV680_NUMFRAMES; i++)
  1184. stv680->frame[i].grabstate = FRAME_UNUSED;
  1185. if (stv680->streaming)
  1186. stv680_stop_stream (stv680);
  1188. if ((i = stv_stop_video (stv680)) < 0)
  1189. PDEBUG (1, "STV(e): stop_video failed in stv_close");
  1191. rvfree (stv680->fbuf, stv680->maxframesize * STV680_NUMFRAMES);
  1192. stv680->user = 0;
  1194. if (stv680->removed) {
  1195. video_unregister_device (&stv680->vdev);
  1196. kfree (stv680);
  1197. stv680 = NULL;
  1198. PDEBUG (0, "STV(i): device unregistered");
  1199. }
  1200. MOD_DEC_USE_COUNT;
  1201. }
  1203. static long stv680_write (struct video_device *dev, const char *buf, unsigned long count, int noblock)
  1204. {
  1205. return -EINVAL;
  1206. }
  1208. static int stv680_ioctl (struct video_device *vdev, unsigned int cmd, void *arg)
  1209. {
  1210. struct usb_stv *stv680 = (struct usb_stv *) vdev;
  1212. if (!stv680->udev)
  1213. return -EIO;
  1215. switch (cmd) {
  1216. case VIDIOCGCAP:{
  1217. struct video_capability b;
  1219. strcpy (b.name, stv680->camera_name);
  1220. b.type = VID_TYPE_CAPTURE;
  1221. b.channels = 1;
  1222. b.audios = 0;
  1223. b.maxwidth = stv680->maxwidth;
  1224. b.maxheight = stv680->maxheight;
  1225. b.minwidth = stv680->maxwidth / 2;
  1226. b.minheight = stv680->maxheight / 2;
  1228. if (copy_to_user (arg, &b, sizeof (b))) {
  1229. PDEBUG (2, "STV(e): VIDIOCGGAP failed");
  1230. return -EFAULT;
  1231. }
  1232. return 0;
  1233. }
  1234. case VIDIOCGCHAN:{
  1235. struct video_channel v;
  1237. if (copy_from_user (&v, arg, sizeof (v)))
  1238. return -EFAULT;
  1239. if (v.channel != 0)
  1240. return -EINVAL;
  1242. v.flags = 0;
  1243. v.tuners = 0;
  1244. v.type = VIDEO_TYPE_CAMERA;
  1245. strcpy (v.name, "STV Camera");
  1247. if (copy_to_user (arg, &v, sizeof (v))) {
  1248. PDEBUG (2, "STV(e): VIDIOCGCHAN failed");
  1249. return -EFAULT;
  1250. }
  1251. return 0;
  1252. }
  1253. case VIDIOCSCHAN:{
  1254. int v;
  1256. if (copy_from_user (&v, arg, sizeof (v))) {
  1257. PDEBUG (2, "STV(e): VIDIOCSCHAN failed");
  1258. return -EFAULT;
  1259. }
  1260. if (v != 0)
  1261. return -EINVAL;
  1263. return 0;
  1264. }
  1265. case VIDIOCGPICT:{
  1266. struct video_picture p;
  1268. stv680_get_pict (stv680, &p);
  1269. if (copy_to_user (arg, &p, sizeof (p))) {
  1270. PDEBUG (2, "STV(e): VIDIOCGPICT failed");
  1271. return -EFAULT;
  1272. }
  1273. return 0;
  1274. }
  1275. case VIDIOCSPICT:{
  1276. struct video_picture p;
  1278. if (copy_from_user (&p, arg, sizeof (p))) {
  1279. PDEBUG (2, "STV(e): VIDIOCSPICT failed");
  1280. return -EFAULT;
  1281. }
  1282. copy_from_user (&p, arg, sizeof (p));
  1283. PDEBUG (2, "STV(i): palette set to %i in VIDIOSPICT", p.palette);
  1285. if (stv680_set_pict (stv680, &p))
  1286. return -EINVAL;
  1287. return 0;
  1288. }
  1289. case VIDIOCSWIN:{
  1290. struct video_window vw;
  1292. if (copy_from_user (&vw, arg, sizeof (vw)))
  1293. return -EFAULT;
  1294. if (vw.flags)
  1295. return -EINVAL;
  1296. if (vw.clipcount)
  1297. return -EINVAL;
  1298. if (vw.width != stv680->vwidth) {
  1299. if (stv680_set_size (stv680, vw.width, vw.height)) {
  1300. PDEBUG (2, "STV(e): failed (from user) set size in VIDIOCSWIN");
  1301. return -EINVAL;
  1302. }
  1303. }
  1304. return 0;
  1305. }
  1306. case VIDIOCGWIN:{
  1307. struct video_window vw;
  1309. vw.x = 0; /* FIXME */
  1310. vw.y = 0;
  1311. vw.chromakey = 0;
  1312. vw.flags = 0;
  1313. vw.clipcount = 0;
  1314. vw.width = stv680->vwidth;
  1315. vw.height = stv680->vheight;
  1317. if (copy_to_user (arg, &vw, sizeof (vw))) {
  1318. PDEBUG (2, "STV(e): VIDIOCGWIN failed");
  1319. return -EFAULT;
  1320. }
  1321. return 0;
  1322. }
  1323. case VIDIOCGMBUF:{
  1324. struct video_mbuf vm;
  1325. int i;
  1327. memset (&vm, 0, sizeof (vm));
  1328. vm.size = STV680_NUMFRAMES * stv680->maxframesize;
  1329. vm.frames = STV680_NUMFRAMES;
  1330. for (i = 0; i < STV680_NUMFRAMES; i++)
  1331. vm.offsets[i] = stv680->maxframesize * i;
  1333. if (copy_to_user ((void *) arg, (void *) &vm, sizeof (vm))) {
  1334. PDEBUG (2, "STV(e): VIDIOCGMBUF failed");
  1335. return -EFAULT;
  1336. }
  1338. return 0;
  1339. }
  1340. case VIDIOCMCAPTURE:{
  1341. struct video_mmap vm;
  1343. if (copy_from_user (&vm, arg, sizeof (vm))) {
  1344. PDEBUG (2, "STV(e): VIDIOCMCAPTURE failed");
  1345. return -EFAULT;
  1346. }
  1347. if (vm.format != STV_VIDEO_PALETTE) {
  1348. PDEBUG (2, "STV(i): VIDIOCMCAPTURE vm.format (%i) != VIDEO_PALETTE (%i)",
  1349. vm.format, STV_VIDEO_PALETTE);
  1350. if ((vm.format == 3) && (swapRGB_on == 0))  {
  1351. PDEBUG (2, "STV(i): VIDIOCMCAPTURE swapRGB is (auto) ON");
  1352. /* this may fix those apps (e.g., xawtv) that want BGR */
  1353. swapRGB = 1;
  1354. }
  1355. return -EINVAL;
  1356. }
  1357. if (vm.frame >= STV680_NUMFRAMES) {
  1358. PDEBUG (2, "STV(e): VIDIOCMCAPTURE vm.frame > NUMFRAMES");
  1359. return -EINVAL;
  1360. }
  1361. if ((stv680->frame[vm.frame].grabstate == FRAME_ERROR)
  1362.     || (stv680->frame[vm.frame].grabstate == FRAME_GRABBING)) {
  1363. PDEBUG (2, "STV(e): VIDIOCMCAPTURE grabstate (%i) error",
  1364. stv680->frame[vm.frame].grabstate);
  1365. return -EBUSY;
  1366. }
  1367. /* Is this according to the v4l spec??? */
  1368. if (stv680->vwidth != vm.width) {
  1369. if (stv680_set_size (stv680, vm.width, vm.height)) {
  1370. PDEBUG (2, "STV(e): VIDIOCMCAPTURE set_size failed");
  1371. return -EINVAL;
  1372. }
  1373. }
  1374. stv680->frame[vm.frame].grabstate = FRAME_READY;
  1376. if (!stv680->streaming)
  1377. stv680_start_stream (stv680);
  1379. return 0;
  1380. }
  1381. case VIDIOCSYNC:{
  1382. int frame, ret = 0;
  1384. if (copy_from_user ((void *) &frame, arg, sizeof (int))) {
  1385. PDEBUG (2, "STV(e): VIDIOCSYNC failed");
  1386. return -EFAULT;
  1387. }
  1388. if (frame < 0 || frame >= STV680_NUMFRAMES) {
  1389. PDEBUG (2, "STV(e): Bad frame # in VIDIOCSYNC");
  1390. return -EINVAL;
  1391. }
  1392. ret = stv680_newframe (stv680, frame);
  1393. stv680->frame[frame].grabstate = FRAME_UNUSED;
  1394. return ret;
  1395. }
  1396. case VIDIOCGFBUF:{
  1397. struct video_buffer vb;
  1399. memset (&vb, 0, sizeof (vb));
  1400. vb.base = NULL; /* frame buffer not supported, not used */
  1402. if (copy_to_user ((void *) arg, (void *) &vb, sizeof (vb))) {
  1403. PDEBUG (2, "STV(e): VIDIOCSYNC failed");
  1404. return -EFAULT;
  1405. }
  1406. return 0;
  1407. }
  1408. case VIDIOCKEY:
  1409. return 0;
  1410. case VIDIOCCAPTURE:
  1411. {
  1412. PDEBUG (2, "STV(e): VIDIOCCAPTURE failed");
  1413. return -EINVAL;
  1414. }
  1415. case VIDIOCSFBUF:
  1416. return -EINVAL;
  1417. case VIDIOCGTUNER:
  1418. case VIDIOCSTUNER:
  1419. return -EINVAL;
  1420. case VIDIOCGFREQ:
  1421. case VIDIOCSFREQ:
  1422. return -EINVAL;
  1423. case VIDIOCGAUDIO:
  1424. case VIDIOCSAUDIO:
  1425. return -EINVAL;
  1426. default:
  1427. return -ENOIOCTLCMD;
  1428. } /* end switch */
  1430. return 0;
  1431. }
  1433. static int stv680_mmap (struct video_device *dev, const char *adr, unsigned long size)
  1434. {
  1435. struct usb_stv *stv680 = (struct usb_stv *) dev;
  1436. unsigned long start = (unsigned long) adr;
  1437. unsigned long page, pos;
  1439. down (&stv680->lock);
  1441. if (stv680->udev == NULL) {
  1442. up (&stv680->lock);
  1443. return -EIO;
  1444. }
  1445. if (size > (((STV680_NUMFRAMES * stv680->maxframesize) + PAGE_SIZE - 1)
  1446.     & ~(PAGE_SIZE - 1))) {
  1447. up (&stv680->lock);
  1448. return -EINVAL;
  1449. }
  1450. pos = (unsigned long) stv680->fbuf;
  1451. while (size > 0) {
  1452. page = kvirt_to_pa (pos);
  1453. if (remap_page_range (start, page, PAGE_SIZE, PAGE_SHARED)) {
  1454. up (&stv680->lock);
  1455. return -EAGAIN;
  1456. }
  1457. start += PAGE_SIZE;
  1458. pos += PAGE_SIZE;
  1459. if (size > PAGE_SIZE)
  1460. size -= PAGE_SIZE;
  1461. else
  1462. size = 0;
  1463. }
  1464. up (&stv680->lock);
  1466. return 0;
  1467. }
  1469. static long stv680_read (struct video_device *dev, char *buf, unsigned long count, int noblock)
  1470. {
  1471. unsigned long int realcount = count;
  1472. int ret = 0;
  1473. struct usb_stv *stv680 = (struct usb_stv *) dev;
  1474. unsigned long int i;
  1476. if (STV680_NUMFRAMES != 2) {
  1477. PDEBUG (0, "STV(e): STV680_NUMFRAMES needs to be 2!");
  1478. return -1;
  1479. }
  1480. if (stv680->udev == NULL)
  1481. return -EIO;
  1482. if (realcount > (stv680->vwidth * stv680->vheight * 3))
  1483. realcount = stv680->vwidth * stv680->vheight * 3;
  1485. /* Shouldn't happen: */
  1486. if (stv680->frame[0].grabstate == FRAME_GRABBING) {
  1487. PDEBUG (2, "STV(e): FRAME_GRABBING in stv680_read");
  1488. return -EBUSY;
  1489. }
  1490. stv680->frame[0].grabstate = FRAME_READY;
  1491. stv680->frame[1].grabstate = FRAME_UNUSED;
  1492. stv680->curframe = 0;
  1494. if (!stv680->streaming)
  1495. stv680_start_stream (stv680);
  1497. if (!stv680->streaming) {
  1498. ret = stv680_newframe (stv680, 0); /* ret should = 0 */
  1499. }
  1501. ret = stv680_newframe (stv680, 0);
  1503. if (!ret) {
  1504. if ((i = copy_to_user (buf, stv680->frame[0].data, realcount)) != 0) {
  1505. PDEBUG (2, "STV(e): copy_to_user frame 0 failed, ret count = %li", i);
  1506. return -EFAULT;
  1507. }
  1508. } else {
  1509. realcount = ret;
  1510. }
  1511. stv680->frame[0].grabstate = FRAME_UNUSED;
  1512. return realcount;
  1513. } /* stv680_read */
  1515. static int stv_init_done (struct video_device *dev)
  1516. {
  1518. #if defined(CONFIG_PROC_FS) && defined(CONFIG_VIDEO_PROC_FS)
  1519. if (create_proc_stv680_cam ((struct usb_stv *) dev) < 0)
  1520. return -1;
  1521. #endif
  1522. return 0;
  1523. }
  1525. static struct video_device stv680_template = {
  1526. owner: THIS_MODULE,
  1527. name: "STV0680 USB camera",
  1528. type: VID_TYPE_CAPTURE,
  1529. hardware: VID_HARDWARE_SE401,
  1530. open: stv_open,
  1531. close: stv_close,
  1532. read: stv680_read,
  1533. write: stv680_write,
  1534. ioctl: stv680_ioctl,
  1535. mmap: stv680_mmap,
  1536. initialize: stv_init_done,
  1537. };
  1539. static void *__devinit stv680_probe (struct usb_device *dev, unsigned int ifnum, const struct usb_device_id *id)
  1540. {
  1541. struct usb_interface_descriptor *interface;
  1542. struct usb_stv *stv680;
  1543. char *camera_name = NULL;
  1545. /* We don't handle multi-config cameras */
  1546. if (dev->descriptor.bNumConfigurations != 1) {
  1547. PDEBUG (0, "STV(e): Number of Configurations != 1");
  1548. return NULL;
  1549. }
  1551. interface = &dev->actconfig->interface[ifnum].altsetting[0];
  1552. /* Is it a STV680? */
  1553. if ((dev->descriptor.idVendor == USB_PENCAM_VENDOR_ID) && (dev->descriptor.idProduct == USB_PENCAM_PRODUCT_ID)) {
  1554. camera_name = "STV0680";
  1555. PDEBUG (0, "STV(i): STV0680 camera found.");
  1556. } else {
  1557. PDEBUG (0, "STV(e): Vendor/Product ID do not match STV0680 values.");
  1558. PDEBUG (0, "STV(e): Check that the STV0680 camera is connected to the computer.");
  1559. return NULL;
  1560. }
  1561. /* We found one */
  1562. if ((stv680 = kmalloc (sizeof (*stv680), GFP_KERNEL)) == NULL) {
  1563. PDEBUG (0, "STV(e): couldn't kmalloc stv680 struct.");
  1564. return NULL;
  1565. }
  1567. memset (stv680, 0, sizeof (*stv680));
  1569. stv680->udev = dev;
  1570. stv680->camera_name = camera_name;
  1572. memcpy (&stv680->vdev, &stv680_template, sizeof (stv680_template));
  1573. memcpy (stv680->vdev.name, stv680->camera_name, strlen (stv680->camera_name));
  1574. init_waitqueue_head (&stv680->wq);
  1575. init_MUTEX (&stv680->lock);
  1576. wmb ();
  1578. if (video_register_device (&stv680->vdev, VFL_TYPE_GRABBER, video_nr) == -1) {
  1579. kfree (stv680);
  1580. PDEBUG (0, "STV(e): video_register_device failed");
  1581. return NULL;
  1582. }
  1583. PDEBUG (0, "STV(i): registered new video device: video%d", stv680->vdev.minor);
  1585. return stv680;
  1586. }
  1588. static inline void usb_stv680_remove_disconnected (struct usb_stv *stv680)
  1589. {
  1590. int i;
  1592. stv680->udev = NULL;
  1593. stv680->frame[0].grabstate = FRAME_ERROR;
  1594. stv680->frame[1].grabstate = FRAME_ERROR;
  1595. stv680->streaming = 0;
  1597. wake_up_interruptible (&stv680->wq);
  1599. for (i = 0; i < STV680_NUMSBUF; i++)
  1600. if (stv680->urb[i]) {
  1601. stv680->urb[i]->next = NULL;
  1602. usb_unlink_urb (stv680->urb[i]);
  1603. usb_free_urb (stv680->urb[i]);
  1604. stv680->urb[i] = NULL;
  1605. kfree (stv680->sbuf[i].data);
  1606. }
  1607. for (i = 0; i < STV680_NUMSCRATCH; i++)
  1608. if (stv680->scratch[i].data) {
  1609. kfree (stv680->scratch[i].data);
  1610. }
  1611. PDEBUG (0, "STV(i): %s disconnected", stv680->camera_name);
  1613. #if defined(CONFIG_PROC_FS) && defined(CONFIG_VIDEO_PROC_FS)
  1614. destroy_proc_stv680_cam (stv680);
  1615. #endif
  1616. /* Free the memory */
  1617. kfree (stv680);
  1618. }
  1620. static void stv680_disconnect (struct usb_device *dev, void *ptr)
  1621. {
  1622. struct usb_stv *stv680 = (struct usb_stv *) ptr;
  1624. lock_kernel ();
  1625. /* We don't want people trying to open up the device */
  1626. if (!stv680->user) {
  1627. video_unregister_device (&stv680->vdev);
  1628. usb_stv680_remove_disconnected (stv680);
  1629. } else {
  1630. stv680->removed = 1;
  1631. }
  1632. unlock_kernel ();
  1633. }
  1635. static struct usb_driver stv680_driver = {
  1636. name: "stv680",
  1637. probe: stv680_probe,
  1638. disconnect: stv680_disconnect,
  1639. id_table: device_table
  1640. };
  1642. /********************************************************************
  1643.  *  Module routines
  1644.  ********************************************************************/
  1646. static int __init usb_stv680_init (void)
  1647. {
  1648. #if defined(CONFIG_PROC_FS) && defined(CONFIG_VIDEO_PROC_FS)
  1649. if (proc_stv680_create () < 0)
  1650. return -1;
  1651. #endif
  1652. if (usb_register (&stv680_driver) < 0) {
  1653. PDEBUG (0, "STV(e): Could not setup STV0680 driver");
  1654. return -1;
  1655. }
  1656. PDEBUG (0, "STV(i): usb camera driver version %s registering", DRIVER_VERSION);
  1658. info(DRIVER_DESC " " DRIVER_VERSION);
  1659. return 0;
  1660. }
  1662. static void __exit usb_stv680_exit (void)
  1663. {
  1664. usb_deregister (&stv680_driver);
  1665. PDEBUG (0, "STV(i): driver deregistered");
  1667. #if defined(CONFIG_PROC_FS) && defined(CONFIG_VIDEO_PROC_FS)
  1668. proc_stv680_destroy ();
  1669. #endif
  1670. }
  1672. module_init (usb_stv680_init);
  1673. module_exit (usb_stv680_exit);