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

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

嵌入式Linux

开发平台：

Unix_Linux

w9966.c：源码内容
  1. /*
  2. Winbond w9966cf Webcam parport driver.
  4. Copyright (C) 2001 Jakob Kemi <jakob.kemi@telia.com>
  6. This program is free software; you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published by
  8. the Free Software Foundation; either version 2 of the License, or
  9. (at your option) any later version.
  11. This program is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  16. You should have received a copy of the GNU General Public License
  17. along with this program; if not, write to the Free Software
  18. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19. */
  20. /*
  21. Supported devices:
  22.   * Lifeview FlyCam Supra (using the Philips saa7111a chip)
  24. Todo:
  25.   * Add a working EPP mode
  26.   * Support other ccd-control chips than the saa7111
  27.     (what combinations exists?)
  28.   * Add proper probing. IEEE1284 probing of w9966 chips haven't
  29.     worked since parport drivers changed in 2.4.x.
  30.   * Probe for onboard SRAM, port directions etc. (if possible)
  32. Changes:
  34. Alan Cox: Removed RGB mode for kernel merge, added THIS_MODULE
  35. and owner support for newer module locks
  36. */
  38. #include <linux/module.h>
  39. #include <linux/init.h>
  40. #include <linux/delay.h>
  41. #include <linux/videodev.h>
  42. #include <linux/parport.h>
  43. #include <linux/types.h>
  44. #include <linux/slab.h>
  46. //#define DEBUG // Undef me for production
  48. #ifdef DEBUG
  49. #define DPRINTF(x, a...) printk(KERN_DEBUG "W9966: "__FUNCTION__ "(): "x, ##a)
  50. #else
  51. #define DPRINTF(x...)
  52. #endif
  54. /*
  55.  * Defines, simple typedefs etc.
  56.  */
  58. #define W9966_DRIVERNAME "W9966CF Webcam"
  59. #define W9966_MAXCAMS 4 // Maximum number of cameras
  60. #define W9966_RBUFFER 2048 // Read buffer (must be an even number)
  61. #define W9966_SRAMSIZE 131072 // 128kb
  62. #define W9966_SRAMID 0x02 // check w9966cf.pdf
  64. // Empirically determined window limits
  65. #define W9966_WND_MIN_X 16
  66. #define W9966_WND_MIN_Y 14
  67. #define W9966_WND_MAX_X 705
  68. #define W9966_WND_MAX_Y 253
  69. #define W9966_WND_MAX_W (W9966_WND_MAX_X - W9966_WND_MIN_X)
  70. #define W9966_WND_MAX_H (W9966_WND_MAX_Y - W9966_WND_MIN_Y)
  72. // Keep track of our current state
  73. #define W9966_STATE_PDEV 0x01
  74. #define W9966_STATE_CLAIMED 0x02
  75. #define W9966_STATE_VDEV 0x04
  77. #define W9966_I2C_W_ID 0x48
  78. #define W9966_I2C_R_ID 0x49
  79. #define W9966_I2C_R_DATA 0x08
  80. #define W9966_I2C_R_CLOCK 0x04
  81. #define W9966_I2C_W_DATA 0x02
  82. #define W9966_I2C_W_CLOCK 0x01
  84. struct w9966_dev {
  85. u8 dev_state;
  86. u8 i2c_state;
  87. int ppmode;
  88. struct parport* pport;
  89. struct pardevice* pdev;
  90. struct video_device vdev;
  91. u16 width;
  92. u16 height;
  93. u8 brightness;
  94. s8 contrast;
  95. s8 color;
  96. s8 hue;
  97. u8* buffer;
  98. };
  100. /*
  101.  * Module specific properties
  102.  */
  104. MODULE_AUTHOR("Jakob Kemi <jakob.kemi@telia.com>");
  105. MODULE_DESCRIPTION("Winbond w9966cf WebCam driver (FlyCam Supra and others)");
  106. MODULE_LICENSE("GPL");
  109. static const char* pardev[] = {[0 ... W9966_MAXCAMS] = "auto"};
  110. MODULE_PARM(pardev, "0-" __MODULE_STRING(W9966_MAXCAMS) "s");
  111. MODULE_PARM_DESC(pardev,"n
  112. <auto|name|none[,...]> Where to find cameras.n
  113.   auto = probe all parports for cameran
  114.   name = name of parport (eg parport0)n
  115.   none = don't search for this cameran
  116. You can specify all cameras this way, for example:
  117.   pardev=parport2,auto,none,parport0 would search for cam1 on parport2, searchn
  118.   for cam2 on all parports, skip cam3 and search for cam4 on parport0");
  120. static int parmode = 0;
  121. MODULE_PARM(parmode, "i");
  122. MODULE_PARM_DESC(parmode, "n<0|1|2> transfer mode (0=auto, 1=ecp, 2=epp)");
  124. static int video_nr = -1;
  125. MODULE_PARM(video_nr, "i");
  127. /*
  128.  * Private data
  129.  */
  131. static struct w9966_dev w9966_cams[W9966_MAXCAMS];
  133. /*
  134.  * Private function declares
  135.  */
  137. static inline void w9966_setState(struct w9966_dev* cam, int mask, int val);
  138. static inline int  w9966_getState(struct w9966_dev* cam, int mask, int val);
  139. static inline void w9966_pdev_claim(struct w9966_dev *vdev);
  140. static inline void w9966_pdev_release(struct w9966_dev *vdev);
  142. static int w9966_rReg(struct w9966_dev* cam, int reg);
  143. static int w9966_wReg(struct w9966_dev* cam, int reg, int data);
  144. static int w9966_rReg_i2c(struct w9966_dev* cam, int reg);
  145. static int w9966_wReg_i2c(struct w9966_dev* cam, int reg, int data);
  146. static int w9966_findlen(int near, int size, int maxlen);
  147. static int w9966_calcscale(int size, int min, int max, int* beg, int* end, unsigned char* factor);
  148. static int w9966_setup(struct w9966_dev* cam, int x1, int y1, int x2, int y2, int w, int h);
  150. static int  w9966_init(struct w9966_dev* cam, struct parport* port);
  151. static void w9966_term(struct w9966_dev* cam);
  153. static inline void w9966_i2c_setsda(struct w9966_dev* cam, int state);
  154. static inline int  w9966_i2c_setscl(struct w9966_dev* cam, int state);
  155. static inline int  w9966_i2c_getsda(struct w9966_dev* cam);
  156. static inline int  w9966_i2c_getscl(struct w9966_dev* cam);
  157. static int w9966_i2c_wbyte(struct w9966_dev* cam, int data);
  158. static int w9966_i2c_rbyte(struct w9966_dev* cam);
  160. static int  w9966_v4l_open(struct video_device *vdev, int mode);
  161. static void w9966_v4l_close(struct video_device *vdev);
  162. static int  w9966_v4l_ioctl(struct video_device *vdev, unsigned int cmd, void *arg);
  163. static long w9966_v4l_read(struct video_device *vdev, char *buf, unsigned long count, int noblock);
  165. /*
  166.  * Private function defines
  167.  */
  170. // Set camera phase flags, so we know what to uninit when terminating 
  171. static inline void w9966_setState(struct w9966_dev* cam, int mask, int val)
  172. {
  173. cam->dev_state = (cam->dev_state & ~mask) ^ val;
  174. }
  176. // Get camera phase flags
  177. static inline int w9966_getState(struct w9966_dev* cam, int mask, int val)
  178. {
  179. return ((cam->dev_state & mask) == val);
  180. }
  182. // Claim parport for ourself
  183. static inline void w9966_pdev_claim(struct w9966_dev* cam)
  184. {
  185. if (w9966_getState(cam, W9966_STATE_CLAIMED, W9966_STATE_CLAIMED))
  186. return;
  187. parport_claim_or_block(cam->pdev);
  188. w9966_setState(cam, W9966_STATE_CLAIMED, W9966_STATE_CLAIMED);
  189. }
  191. // Release parport for others to use
  192. static inline void w9966_pdev_release(struct w9966_dev* cam)
  193. {
  194. if (w9966_getState(cam, W9966_STATE_CLAIMED, 0))
  195. return;
  196. parport_release(cam->pdev);
  197. w9966_setState(cam, W9966_STATE_CLAIMED, 0);
  198. }
  199.  
  200. // Read register from W9966 interface-chip
  201. // Expects a claimed pdev
  202. // -1 on error, else register data (byte)
  203. static int w9966_rReg(struct w9966_dev* cam, int reg)
  204. {
  205. // ECP, read, regtransfer, REG, REG, REG, REG, REG
  206. const unsigned char addr = 0x80 | (reg & 0x1f);
  207. unsigned char val;
  209. if (parport_negotiate(cam->pport, cam->ppmode | IEEE1284_ADDR) != 0)
  210. return -1;
  211. if (parport_write(cam->pport, &addr, 1) != 1)
  212. return -1;
  213. if (parport_negotiate(cam->pport, cam->ppmode | IEEE1284_DATA) != 0)
  214. return -1;
  215. if (parport_read(cam->pport, &val, 1) != 1)
  216. return -1;
  218. return val;
  219. }
  221. // Write register to W9966 interface-chip
  222. // Expects a claimed pdev
  223. // -1 on error
  224. static int w9966_wReg(struct w9966_dev* cam, int reg, int data)
  225. {
  226. // ECP, write, regtransfer, REG, REG, REG, REG, REG
  227. const unsigned char addr = 0xc0 | (reg & 0x1f);
  228. const unsigned char val = data;
  230. if (parport_negotiate(cam->pport, cam->ppmode | IEEE1284_ADDR) != 0)
  231. return -1;
  232. if (parport_write(cam->pport, &addr, 1) != 1)
  233. return -1;
  234. if (parport_negotiate(cam->pport, cam->ppmode | IEEE1284_DATA) != 0)
  235. return -1;
  236. if (parport_write(cam->pport, &val, 1) != 1)
  237. return -1;
  239. return 0;
  240. }
  242. // Initialize camera device. Setup all internal flags, set a
  243. // default video mode, setup ccd-chip, register v4l device etc..
  244. // Also used for 'probing' of hardware.
  245. // -1 on error
  246. static int w9966_init(struct w9966_dev* cam, struct parport* port)
  247. {
  248. if (cam->dev_state != 0)
  249. return -1;
  251. cam->pport = port;
  252. cam->brightness = 128;
  253. cam->contrast = 64;
  254. cam->color = 64;
  255. cam->hue = 0;
  257. // Select requested transfer mode
  258. switch(parmode)
  259. {
  260. default: // Auto-detect (priority: hw-ecp, hw-epp, sw-ecp)
  261. case 0:
  262. if (port->modes & PARPORT_MODE_ECP)
  263. cam->ppmode = IEEE1284_MODE_ECP;
  264. /* else if (port->modes & PARPORT_MODE_EPP)
  265. cam->ppmode = IEEE1284_MODE_EPP;*/
  266. else
  267. cam->ppmode = IEEE1284_MODE_ECPSWE;
  268. break;
  269. case 1: // hw- or sw-ecp
  270. if (port->modes & PARPORT_MODE_ECP)
  271. cam->ppmode = IEEE1284_MODE_ECP;
  272. else
  273. cam->ppmode = IEEE1284_MODE_ECPSWE;
  274. break;
  275. case 2: // hw- or sw-epp
  276. if (port->modes & PARPORT_MODE_EPP)
  277. cam->ppmode = IEEE1284_MODE_EPP;
  278. else
  279. cam->ppmode = IEEE1284_MODE_EPPSWE;
  280. break;
  281. }
  283. // Tell the parport driver that we exists
  284. cam->pdev = parport_register_device(port, "w9966", NULL, NULL, NULL, 0, NULL);
  285. if (cam->pdev == NULL) {
  286. DPRINTF("parport_register_device() failedn");
  287. return -1;
  288. }
  289. w9966_setState(cam, W9966_STATE_PDEV, W9966_STATE_PDEV);
  291. w9966_pdev_claim(cam);
  293. // Setup a default capture mode
  294. if (w9966_setup(cam, 0, 0, 1023, 1023, 200, 160) != 0) {
  295. DPRINTF("w9966_setup() failed.n");
  296. return -1;
  297. }
  299. w9966_pdev_release(cam);
  301. // Fill in the video_device struct and register us to v4l
  302. memset(&cam->vdev, 0, sizeof(struct video_device));
  303. strcpy(cam->vdev.name, W9966_DRIVERNAME);
  304. cam->vdev.type = VID_TYPE_CAPTURE | VID_TYPE_SCALES;
  305. cam->vdev.hardware = VID_HARDWARE_W9966;
  306. cam->vdev.open = &w9966_v4l_open;
  307. cam->vdev.close = &w9966_v4l_close;
  308. cam->vdev.read = &w9966_v4l_read;
  309. cam->vdev.ioctl = &w9966_v4l_ioctl;
  310. cam->vdev.priv = (void*)cam;
  311. cam->vdev.owner = THIS_MODULE;
  313. if (video_register_device(&cam->vdev, VFL_TYPE_GRABBER, video_nr) == -1)  
  314. return -1;
  316. w9966_setState(cam, W9966_STATE_VDEV, W9966_STATE_VDEV);
  318. cam->buffer = NULL;
  320. // All ok
  321. printk(
  322. "w9966cf: Found and initialized a webcam on %s.n",
  323. cam->pport->name
  324. );
  325. return 0;
  326. }
  329. // Terminate everything gracefully
  330. static void w9966_term(struct w9966_dev* cam)
  331. {
  332. // Delete allocated buffer if needed
  333. if (cam->buffer != NULL) {
  334. kfree(cam->buffer);
  335. cam->buffer = NULL;
  336. }
  338. // Unregister from v4l
  339. if (w9966_getState(cam, W9966_STATE_VDEV, W9966_STATE_VDEV)) {
  340. video_unregister_device(&cam->vdev);
  341. w9966_setState(cam, W9966_STATE_VDEV, 0);
  342. }
  344. // Terminate from IEEE1284 mode and release pdev block
  345. if (w9966_getState(cam, W9966_STATE_PDEV, W9966_STATE_PDEV)) {
  346. w9966_pdev_claim(cam);
  347. parport_negotiate(cam->pport, IEEE1284_MODE_COMPAT);
  348. w9966_pdev_release(cam);
  349. }
  351. // Unregister from parport
  352. if (w9966_getState(cam, W9966_STATE_PDEV, W9966_STATE_PDEV)) {
  353. parport_unregister_device(cam->pdev);
  354. w9966_setState(cam, W9966_STATE_PDEV, 0);
  355. }
  356. }
  359. // Find a good length for capture window (used both for W and H)
  360. // A bit ugly but pretty functional. The capture length
  361. // have to match the downscale
  362. static int w9966_findlen(int near, int size, int maxlen)
  363. {
  364. int bestlen = size;
  365. int besterr = abs(near - bestlen);
  366. int len;
  368. for(len = size+1;len < maxlen;len++)
  369. {
  370. int err;
  371. if ( ((64*size) %len) != 0)
  372. continue;
  374. err = abs(near - len);
  376. // Only continue as long as we keep getting better values
  377. if (err > besterr)
  378. break;
  380. besterr = err;
  381. bestlen = len;
  382. }
  384. return bestlen;
  385. }
  387. // Modify capture window (if necessary) 
  388. // and calculate downscaling
  389. // Return -1 on error
  390. static int w9966_calcscale(int size, int min, int max, int* beg, int* end, unsigned char* factor)
  391. {
  392. int maxlen = max - min;
  393. int len = *end - *beg + 1;
  394. int newlen = w9966_findlen(len, size, maxlen);
  395. int err = newlen - len; 
  397. // Check for bad format
  398. if (newlen > maxlen || newlen < size)
  399. return -1;
  401. // Set factor (6 bit fixed)
  402. *factor = (64*size) / newlen;
  403. if (*factor == 64)
  404. *factor = 0x00; // downscale is disabled
  405. else
  406. *factor |= 0x80; // set downscale-enable bit
  408. // Modify old beginning and end
  409. *beg -= err / 2;
  410. *end += err - (err / 2);
  412. // Move window if outside borders
  413. if (*beg < min) {
  414. *end += min - *beg;
  415. *beg += min - *beg;
  416. }
  417. if (*end > max) {
  418. *beg -= *end - max;
  419. *end -= *end - max;
  420. }
  422. return 0;
  423. }
  425. // Setup the cameras capture window etc.
  426. // Expects a claimed pdev
  427. // return -1 on error
  428. static int w9966_setup(struct w9966_dev* cam, int x1, int y1, int x2, int y2, int w, int h)
  429. {
  430. unsigned int i;
  431. unsigned int enh_s, enh_e;
  432. u8 scale_x, scale_y;
  433. u8 regs[0x1c];
  434. u8 saa7111_regs[] = {
  435. 0x21, 0x00, 0xd8, 0x23, 0x00, 0x80, 0x80, 0x00,
  436. 0x88, 0x10, 0x80, 0x40, 0x40, 0x00, 0x01, 0x00,
  437. 0x48, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  438. 0x00, 0x00, 0x00, 0x71, 0xe7, 0x00, 0x00, 0xc0
  439. };
  442. if (w*h*2 > W9966_SRAMSIZE)
  443. {
  444. DPRINTF("capture window exceeds SRAM size!.n");
  445. w = 200; h = 160; // Pick default values
  446. }
  448. w &= ~0x1;
  449. if (w < 2) w = 2;
  450. if (h < 1) h = 1;
  451. if (w > W9966_WND_MAX_W) w = W9966_WND_MAX_W;
  452. if (h > W9966_WND_MAX_H) h = W9966_WND_MAX_H;
  454. cam->width = w;
  455. cam->height = h;
  457. enh_s = 0;
  458. enh_e = w*h*2;
  460. // Modify capture window if necessary and calculate downscaling
  461. if (
  462. w9966_calcscale(w, W9966_WND_MIN_X, W9966_WND_MAX_X, &x1, &x2, &scale_x) != 0 ||
  463. w9966_calcscale(h, W9966_WND_MIN_Y, W9966_WND_MAX_Y, &y1, &y2, &scale_y) != 0
  464. ) return -1;
  466. DPRINTF(
  467. "%dx%d, x: %d<->%d, y: %d<->%d, sx: %d/64, sy: %d/64.n",
  468. w, h, x1, x2, y1, y2, scale_x&~0x80, scale_y&~0x80
  469. );
  471. // Setup registers
  472. regs[0x00] = 0x00; // Set normal operation
  473. regs[0x01] = 0x18; // Capture mode
  474. regs[0x02] = scale_y; // V-scaling
  475. regs[0x03] = scale_x; // H-scaling
  477. // Capture window
  478. regs[0x04] = (x1 & 0x0ff); // X-start (8 low bits)
  479. regs[0x05] = (x1 & 0x300)>>8; // X-start (2 high bits)
  480. regs[0x06] = (y1 & 0x0ff); // Y-start (8 low bits)
  481. regs[0x07] = (y1 & 0x300)>>8; // Y-start (2 high bits)
  482. regs[0x08] = (x2 & 0x0ff); // X-end (8 low bits)
  483. regs[0x09] = (x2 & 0x300)>>8; // X-end (2 high bits)
  484. regs[0x0a] = (y2 & 0x0ff); // Y-end (8 low bits)
  486. regs[0x0c] = W9966_SRAMID; // SRAM-banks (1x 128kb)
  488. // Enhancement layer
  489. regs[0x0d] = (enh_s& 0x000ff); // Enh. start (0-7)
  490. regs[0x0e] = (enh_s& 0x0ff00)>>8; // Enh. start (8-15)
  491. regs[0x0f] = (enh_s& 0x70000)>>16; // Enh. start (16-17/18??)
  492. regs[0x10] = (enh_e& 0x000ff); // Enh. end (0-7)
  493. regs[0x11] = (enh_e& 0x0ff00)>>8; // Enh. end (8-15)
  494. regs[0x12] = (enh_e& 0x70000)>>16; // Enh. end (16-17/18??)
  496. // Misc
  497. regs[0x13] = 0x40; // VEE control (raw 4:2:2)
  498. regs[0x17] = 0x00; // ???
  499. regs[0x18] = cam->i2c_state = 0x00; // Serial bus
  500. regs[0x19] = 0xff; // I/O port direction control
  501. regs[0x1a] = 0xff; // I/O port data register
  502. regs[0x1b] = 0x10; // ???
  504. // SAA7111 chip settings
  505. saa7111_regs[0x0a] = cam->brightness;
  506. saa7111_regs[0x0b] = cam->contrast;
  507. saa7111_regs[0x0c] = cam->color;
  508. saa7111_regs[0x0d] = cam->hue;
  510. // Reset (ECP-fifo & serial-bus)
  511. if (w9966_wReg(cam, 0x00, 0x03) == -1)
  512. return -1;
  514. // Write regs to w9966cf chip
  515. for (i = 0; i < 0x1c; i++)
  516. if (w9966_wReg(cam, i, regs[i]) == -1)
  517. return -1;
  519. // Write regs to saa7111 chip
  520. for (i = 0; i < 0x20; i++)
  521. if (w9966_wReg_i2c(cam, i, saa7111_regs[i]) == -1)
  522. return -1;
  524. return 0;
  525. }
  527. /*
  528.  * Ugly and primitive i2c protocol functions
  529.  */
  531. // Sets the data line on the i2c bus.
  532. // Expects a claimed pdev.
  533. static inline void w9966_i2c_setsda(struct w9966_dev* cam, int state)
  534. {
  535. if (state)
  536. cam->i2c_state |= W9966_I2C_W_DATA;
  537. else
  538. cam->i2c_state &= ~W9966_I2C_W_DATA;
  540. w9966_wReg(cam, 0x18, cam->i2c_state);
  541. udelay(5);
  542. }
  544. // Sets the clock line on the i2c bus.
  545. // Expects a claimed pdev. -1 on error
  546. static inline int w9966_i2c_setscl(struct w9966_dev* cam, int state)
  547. {
  548. int timeout;
  549. if (state)
  550. cam->i2c_state |= W9966_I2C_W_CLOCK;
  551. else
  552. cam->i2c_state &= ~W9966_I2C_W_CLOCK;
  554. w9966_wReg(cam, 0x18, cam->i2c_state);
  555. udelay(5);
  557. // we go to high, we also expect the peripheral to ack.
  558. if (state) {
  559. timeout = jiffies + 100;
  560. while (!w9966_i2c_getscl(cam)) {
  561. if (jiffies > timeout)
  562. return -1;
  563. }
  564. }
  565. return 0;
  566. }
  568. // Get peripheral data line
  569. // Expects a claimed pdev.
  570. static inline int w9966_i2c_getsda(struct w9966_dev* cam)
  571. {
  572. const unsigned char state = w9966_rReg(cam, 0x18);
  573. return ((state & W9966_I2C_R_DATA) > 0);
  574. }
  576. // Get peripheral clock line
  577. // Expects a claimed pdev.
  578. static inline int w9966_i2c_getscl(struct w9966_dev* cam)
  579. {
  580. const unsigned char state = w9966_rReg(cam, 0x18);
  581. return ((state & W9966_I2C_R_CLOCK) > 0);
  582. }
  584. // Write a byte with ack to the i2c bus.
  585. // Expects a claimed pdev. -1 on error
  586. static int w9966_i2c_wbyte(struct w9966_dev* cam, int data)
  587. {
  588. int i;
  589. for (i = 7; i >= 0; i--)
  590. {
  591. w9966_i2c_setsda(cam, (data >> i) & 0x01);
  593. if (w9966_i2c_setscl(cam, 1) == -1)
  594. return -1;
  595. w9966_i2c_setscl(cam, 0);
  596. }
  598. w9966_i2c_setsda(cam, 1);
  600. if (w9966_i2c_setscl(cam, 1) == -1)
  601. return -1;
  602. w9966_i2c_setscl(cam, 0);
  604. return 0;
  605. }
  607. // Read a data byte with ack from the i2c-bus
  608. // Expects a claimed pdev. -1 on error
  609. static int w9966_i2c_rbyte(struct w9966_dev* cam)
  610. {
  611. unsigned char data = 0x00;
  612. int i;
  614. w9966_i2c_setsda(cam, 1);
  616. for (i = 0; i < 8; i++)
  617. {
  618. if (w9966_i2c_setscl(cam, 1) == -1)
  619. return -1;
  620. data = data << 1;
  621. if (w9966_i2c_getsda(cam))
  622. data |= 0x01;
  624. w9966_i2c_setscl(cam, 0);
  625. }
  626. return data;
  627. }
  629. // Read a register from the i2c device.
  630. // Expects claimed pdev. -1 on error
  631. static int w9966_rReg_i2c(struct w9966_dev* cam, int reg)
  632. {
  633. int data;
  635. w9966_i2c_setsda(cam, 0);
  636. w9966_i2c_setscl(cam, 0);
  638. if (
  639. w9966_i2c_wbyte(cam, W9966_I2C_W_ID) == -1 ||
  640. w9966_i2c_wbyte(cam, reg) == -1
  641. )
  642. return -1;
  644. w9966_i2c_setsda(cam, 1);
  645. if (w9966_i2c_setscl(cam, 1) == -1)
  646. return -1;
  647. w9966_i2c_setsda(cam, 0);
  648. w9966_i2c_setscl(cam, 0);
  650. if (
  651. w9966_i2c_wbyte(cam, W9966_I2C_R_ID) == -1 ||
  652. (data = w9966_i2c_rbyte(cam)) == -1
  653. )
  654. return -1;
  656. w9966_i2c_setsda(cam, 0);
  658. if (w9966_i2c_setscl(cam, 1) == -1)
  659. return -1;
  660. w9966_i2c_setsda(cam, 1);
  662. return data;
  663. }
  666. // Write a register to the i2c device.
  667. // Expects claimed pdev. -1 on error
  668. static int w9966_wReg_i2c(struct w9966_dev* cam, int reg, int data)
  669. {
  670. w9966_i2c_setsda(cam, 0);
  671. w9966_i2c_setscl(cam, 0);
  673. if (
  674. w9966_i2c_wbyte(cam, W9966_I2C_W_ID) == -1 ||
  675. w9966_i2c_wbyte(cam, reg) == -1 ||
  676. w9966_i2c_wbyte(cam, data) == -1
  677. )
  678. return -1;
  680. w9966_i2c_setsda(cam, 0);
  681. if (w9966_i2c_setscl(cam, 1) == -1)
  682. return -1;
  684. w9966_i2c_setsda(cam, 1);
  686. return 0;
  687. }
  689. /*
  690.  * Video4linux interfacing
  691.  */
  693. static int w9966_v4l_open(struct video_device *vdev, int flags)
  694. {
  695. struct w9966_dev *cam = (struct w9966_dev*)vdev->priv;
  696. cam->buffer = (u8*)kmalloc(W9966_RBUFFER, GFP_KERNEL);
  698. if (cam->buffer == NULL)
  699. return -EFAULT;
  701. return 0;
  702. }
  704. static void w9966_v4l_close(struct video_device *vdev)
  705. {
  706. struct w9966_dev *cam = (struct w9966_dev*)vdev->priv;
  708. if (cam->buffer != NULL) {
  709. kfree(cam->buffer);
  710. cam->buffer = NULL;
  711. }
  712. }
  714. static int w9966_v4l_ioctl(struct video_device *vdev, unsigned int cmd, void *arg)
  715. {
  716. struct w9966_dev *cam = (struct w9966_dev*)vdev->priv;
  718. switch(cmd)
  719. {
  720. case VIDIOCGCAP:
  721. {
  722. struct video_capability vcap = {
  723. W9966_DRIVERNAME, // name
  724. VID_TYPE_CAPTURE | VID_TYPE_SCALES, // type
  725. 1, 0, // vid, aud channels
  726. W9966_WND_MAX_W, // max w
  727. W9966_WND_MAX_H, // max h
  728. 2, 1 // min w, min h
  729. };
  731. if(copy_to_user(arg, &vcap, sizeof(vcap)) != 0)
  732. return -EFAULT;
  734. return 0;
  735. }
  736. case VIDIOCGCHAN:
  737. {
  738. struct video_channel vch;
  739. if(copy_from_user(&vch, arg, sizeof(vch)) != 0)
  740. return -EFAULT;
  742. if(vch.channel != 0) // We only support one channel (#0)
  743. return -EINVAL;
  745. strcpy(vch.name, "CCD-input");
  746. vch.flags = 0; // We have no tuner or audio
  747. vch.tuners = 0;
  748. vch.type = VIDEO_TYPE_CAMERA;
  749. vch.norm = 0; // ???
  751. if(copy_to_user(arg, &vch, sizeof(vch)) != 0)
  752. return -EFAULT;
  754. return 0;
  755. }
  756. case VIDIOCSCHAN:
  757. {
  758. struct video_channel vch;
  759. if(copy_from_user(&vch, arg, sizeof(vch) ) != 0)
  760. return -EFAULT;
  762. if(vch.channel != 0)
  763. return -EINVAL;
  765. return 0;
  766. }
  767. case VIDIOCGTUNER:
  768. {
  769. struct video_tuner vtune;
  770. if(copy_from_user(&vtune, arg, sizeof(vtune)) != 0)
  771. return -EFAULT;
  773. if(vtune.tuner != 0);
  774. return -EINVAL;
  776. strcpy(vtune.name, "no tuner");
  777. vtune.rangelow = 0;
  778. vtune.rangehigh = 0;
  779. vtune.flags = VIDEO_TUNER_NORM;
  780. vtune.mode = VIDEO_MODE_AUTO;
  781. vtune.signal = 0xffff;
  783. if(copy_to_user(arg, &vtune, sizeof(vtune)) != 0)
  784. return -EFAULT;
  786. return 0;
  787. }
  788. case VIDIOCSTUNER:
  789. {
  790. struct video_tuner vtune;
  791. if (copy_from_user(&vtune, arg, sizeof(vtune)) != 0)
  792. return -EFAULT;
  794. if (vtune.tuner != 0)
  795. return -EINVAL;
  797. if (vtune.mode != VIDEO_MODE_AUTO)
  798. return -EINVAL;
  800. return 0;
  801. }
  802. case VIDIOCGPICT:
  803. {
  804. struct video_picture vpic = {
  805. cam->brightness << 8, // brightness
  806. (cam->hue + 128) << 8, // hue
  807. cam->color << 9, // color
  808. cam->contrast << 9, // contrast
  809. 0x8000, // whiteness
  810. 16, VIDEO_PALETTE_YUV422// bpp, palette format
  811. };
  813. if(copy_to_user(arg, &vpic, sizeof(vpic)) != 0)
  814. return -EFAULT;
  816. return 0;
  817. }
  818. case VIDIOCSPICT:
  819. {
  820. struct video_picture vpic;
  821. if(copy_from_user(&vpic, arg, sizeof(vpic)) != 0)
  822. return -EFAULT;
  824. if (vpic.depth != 16 || vpic.palette != VIDEO_PALETTE_YUV422)
  825. return -EINVAL;
  827. cam->brightness = vpic.brightness >> 8;
  828. cam->hue = (vpic.hue >> 8) - 128;
  829. cam->color = vpic.colour >> 9;
  830. cam->contrast = vpic.contrast >> 9;
  832. w9966_pdev_claim(cam);
  834. if (
  835. w9966_wReg_i2c(cam, 0x0a, cam->brightness) == -1 ||
  836. w9966_wReg_i2c(cam, 0x0b, cam->contrast) == -1 ||
  837. w9966_wReg_i2c(cam, 0x0c, cam->color) == -1 ||
  838. w9966_wReg_i2c(cam, 0x0d, cam->hue) == -1
  839. ) {
  840. w9966_pdev_release(cam);
  841. return -EFAULT;
  842. }
  844. w9966_pdev_release(cam);
  845. return 0;
  846. }
  847. case VIDIOCSWIN:
  848. {
  849. int ret;
  850. struct video_window vwin;
  852. if (copy_from_user(&vwin, arg, sizeof(vwin)) != 0)
  853. return -EFAULT;
  854. if (vwin.flags != 0)
  855. return -EINVAL;
  856. if (vwin.clipcount != 0)
  857. return -EINVAL;
  858. if (vwin.width < 2 || vwin.width > W9966_WND_MAX_W)
  859. return -EINVAL;
  860. if (vwin.height < 1 || vwin.height > W9966_WND_MAX_H)
  861. return -EINVAL;
  863. // Update camera regs
  864. w9966_pdev_claim(cam);
  865. ret = w9966_setup(cam, 0, 0, 1023, 1023, vwin.width, vwin.height);
  866. w9966_pdev_release(cam);
  868. if (ret != 0) {
  869. DPRINTF("VIDIOCSWIN: w9966_setup() failed.n");
  870. return -EFAULT;
  871. }
  873. return 0;
  874. }
  875. case VIDIOCGWIN:
  876. {
  877. struct video_window vwin;
  878. memset(&vwin, 0, sizeof(vwin));
  880. vwin.width = cam->width;
  881. vwin.height = cam->height;
  883. if(copy_to_user(arg, &vwin, sizeof(vwin)) != 0)
  884. return -EFAULT;
  886. return 0;
  887. }
  888. // Unimplemented
  889. case VIDIOCCAPTURE:
  890. case VIDIOCGFBUF:
  891. case VIDIOCSFBUF:
  892. case VIDIOCKEY:
  893. case VIDIOCGFREQ:
  894. case VIDIOCSFREQ:
  895. case VIDIOCGAUDIO:
  896. case VIDIOCSAUDIO:
  897. return -EINVAL;
  898. default:
  899. return -ENOIOCTLCMD;
  900. }
  901. return 0;
  902. }
  904. // Capture data
  905. static long w9966_v4l_read(struct video_device *vdev, char *buf, unsigned long count,  int noblock)
  906. {
  907. struct w9966_dev *cam = (struct w9966_dev *)vdev->priv;
  908. unsigned char addr = 0xa0; // ECP, read, CCD-transfer, 00000
  909. unsigned char* dest = (unsigned char*)buf;
  910. unsigned long dleft = count;
  912. // Why would anyone want more than this??
  913. if (count > cam->width * cam->height * 2)
  914. return -EINVAL;
  916. w9966_pdev_claim(cam);
  917. w9966_wReg(cam, 0x00, 0x02); // Reset ECP-FIFO buffer
  918. w9966_wReg(cam, 0x00, 0x00); // Return to normal operation
  919. w9966_wReg(cam, 0x01, 0x98); // Enable capture
  921. // write special capture-addr and negotiate into data transfer
  922. if (
  923. (parport_negotiate(cam->pport, cam->ppmode|IEEE1284_ADDR) != 0 )||
  924. (parport_write(cam->pport, &addr, 1) != 1 )||
  925. (parport_negotiate(cam->pport, cam->ppmode|IEEE1284_DATA) != 0 )
  926. ) {
  927. w9966_pdev_release(cam);
  928. return -EFAULT;
  929. }
  931. while(dleft > 0)
  932. {
  933. unsigned long tsize = (dleft > W9966_RBUFFER) ? W9966_RBUFFER : dleft;
  935. if (parport_read(cam->pport, cam->buffer, tsize) < tsize) {
  936. w9966_pdev_release(cam);
  937. return -EFAULT;
  938. }
  939. if (copy_to_user(dest, cam->buffer, tsize) != 0) {
  940. w9966_pdev_release(cam);
  941. return -EFAULT;
  942. }
  943. dest += tsize;
  944. dleft -= tsize;
  945. }
  947. w9966_wReg(cam, 0x01, 0x18); // Disable capture
  948. w9966_pdev_release(cam);
  950. return count;
  951. }
  954. // Called once for every parport on init
  955. static void w9966_attach(struct parport *port)
  956. {
  957. int i;
  959. for (i = 0; i < W9966_MAXCAMS; i++)
  960. {
  961. if (strcmp(pardev[i], "none") == 0) // Skip if 'none'
  962. continue;
  963. if (w9966_cams[i].dev_state != 0) // Cam is already assigned
  964. continue;
  965. if (strcmp(pardev[i], "auto") == 0 ||
  966.     strcmp(pardev[i], port->name) == 0) {
  967. if (w9966_init(&w9966_cams[i], port) != 0)
  968. w9966_term(&w9966_cams[i]);
  969. break; // return
  970. }
  971. }
  972. }
  974. // Called once for every parport on termination
  975. static void w9966_detach(struct parport *port)
  976. {
  977. int i;
  978. for (i = 0; i < W9966_MAXCAMS; i++)
  979. if (w9966_cams[i].dev_state != 0 && w9966_cams[i].pport == port)
  980. w9966_term(&w9966_cams[i]);
  981. }
  984. static struct parport_driver w9966_ppd = {
  985. W9966_DRIVERNAME,
  986. w9966_attach,
  987. w9966_detach,
  988. NULL
  989. };
  991. // Module entry point
  992. static int __init w9966_mod_init(void)
  993. {
  994. int i;
  995. for (i = 0; i < W9966_MAXCAMS; i++)
  996. w9966_cams[i].dev_state = 0;
  998. return parport_register_driver(&w9966_ppd);
  999. }
  1001. // Module cleanup
  1002. static void __exit w9966_mod_term(void)
  1003. {
  1004. parport_unregister_driver(&w9966_ppd);
  1005. }
  1007. module_init(w9966_mod_init);
  1008. module_exit(w9966_mod_term);