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

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

嵌入式Linux

开发平台：

Unix_Linux

bw-qcam.c：源码内容
  1. /*
  2.  *    QuickCam Driver For Video4Linux.
  3.  *
  4.  * Video4Linux conversion work by Alan Cox.
  5.  * Parport compatibility by Phil Blundell.
  6.  * Busy loop avoidance by Mark Cooke.
  7.  *
  8.  *    Module parameters:
  9.  *
  10.  * maxpoll=<1 - 5000>
  11.  *
  12.  *   When polling the QuickCam for a response, busy-wait for a
  13.  *   maximum of this many loops. The default of 250 gives little
  14.  *   impact on interactive response.
  15.  *
  16.  *   NOTE: If this parameter is set too high, the processor
  17.  * will busy wait until this loop times out, and then
  18.  * slowly poll for a further 5 seconds before failing
  19.  * the transaction. You have been warned.
  20.  *
  21.  * yieldlines=<1 - 250>
  22.  *
  23.  *   When acquiring a frame from the camera, the data gathering
  24.  *   loop will yield back to the scheduler after completing
  25.  *   this many lines. The default of 4 provides a trade-off
  26.  *   between increased frame acquisition time and impact on
  27.  *   interactive response.
  28.  */
  30. /* qcam-lib.c -- Library for programming with the Connectix QuickCam.
  31.  * See the included documentation for usage instructions and details
  32.  * of the protocol involved. */
  35. /* Version 0.5, August 4, 1996 */
  36. /* Version 0.7, August 27, 1996 */
  37. /* Version 0.9, November 17, 1996 */
  40. /******************************************************************
  42. Copyright (C) 1996 by Scott Laird
  44. Permission is hereby granted, free of charge, to any person obtaining
  45. a copy of this software and associated documentation files (the
  46. "Software"), to deal in the Software without restriction, including
  47. without limitation the rights to use, copy, modify, merge, publish,
  48. distribute, sublicense, and/or sell copies of the Software, and to
  49. permit persons to whom the Software is furnished to do so, subject to
  50. the following conditions:
  52. The above copyright notice and this permission notice shall be
  53. included in all copies or substantial portions of the Software.
  55. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  56. EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  57. MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  58. IN NO EVENT SHALL SCOTT LAIRD BE LIABLE FOR ANY CLAIM, DAMAGES OR
  59. OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  60. ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  61. OTHER DEALINGS IN THE SOFTWARE.
  63. ******************************************************************/
  65. #include <linux/module.h>
  66. #include <linux/delay.h>
  67. #include <linux/errno.h>
  68. #include <linux/fs.h>
  69. #include <linux/init.h>
  70. #include <linux/kernel.h>
  71. #include <linux/slab.h>
  72. #include <linux/mm.h>
  73. #include <linux/parport.h>
  74. #include <linux/sched.h>
  75. #include <linux/version.h>
  76. #include <linux/videodev.h>
  77. #include <asm/semaphore.h>
  78. #include <asm/uaccess.h>
  80. #include "bw-qcam.h"
  82. static unsigned int maxpoll=250;   /* Maximum busy-loop count for qcam I/O */
  83. static unsigned int yieldlines=4;  /* Yield after this many during capture */
  84. static int video_nr = -1;
  86. #if LINUX_VERSION_CODE >= 0x020117
  87. MODULE_PARM(maxpoll,"i");
  88. MODULE_PARM(yieldlines,"i");   
  89. MODULE_PARM(video_nr,"i");
  90. #endif
  92. extern __inline__ int read_lpstatus(struct qcam_device *q)
  93. {
  94. return parport_read_status(q->pport);
  95. }
  97. extern __inline__ int read_lpcontrol(struct qcam_device *q)
  98. {
  99. return parport_read_control(q->pport);
  100. }
  102. extern __inline__ int read_lpdata(struct qcam_device *q)
  103. {
  104. return parport_read_data(q->pport);
  105. }
  107. extern __inline__ void write_lpdata(struct qcam_device *q, int d)
  108. {
  109. parport_write_data(q->pport, d);
  110. }
  112. extern __inline__ void write_lpcontrol(struct qcam_device *q, int d)
  113. {
  114. parport_write_control(q->pport, d);
  115. }
  117. static int qc_waithand(struct qcam_device *q, int val);
  118. static int qc_command(struct qcam_device *q, int command);
  119. static int qc_readparam(struct qcam_device *q);
  120. static int qc_setscanmode(struct qcam_device *q);
  121. static int qc_readbytes(struct qcam_device *q, char buffer[]);
  123. static struct video_device qcam_template;
  125. static int qc_calibrate(struct qcam_device *q)
  126. {
  127. /*
  128.  * Bugfix by Hanno Mueller hmueller@kabel.de, Mai 21 96
  129.  * The white balance is an individiual value for each
  130.  * quickcam.
  131.  */
  133. int value;
  134. int count = 0;
  136. qc_command(q, 27); /* AutoAdjustOffset */
  137. qc_command(q, 0); /* Dummy Parameter, ignored by the camera */
  139. /* GetOffset (33) will read 255 until autocalibration */
  140. /* is finished. After that, a value of 1-254 will be */
  141. /* returned. */
  143. do {
  144. qc_command(q, 33);
  145. value = qc_readparam(q);
  146. mdelay(1);
  147. schedule();
  148. count++;
  149. } while (value == 0xff && count<2048);
  151. q->whitebal = value;
  152. return value;
  153. }
  155. /* Initialize the QuickCam driver control structure.  This is where
  156.  * defaults are set for people who don't have a config file.*/
  158. static struct qcam_device *qcam_init(struct parport *port)
  159. {
  160. struct qcam_device *q;
  162. q = kmalloc(sizeof(struct qcam_device), GFP_KERNEL);
  163. if(q==NULL)
  164. return NULL;
  166. q->pport = port;
  167. q->pdev = parport_register_device(port, "bw-qcam", NULL, NULL,
  168.   NULL, 0, NULL);
  169. if (q->pdev == NULL) 
  170. {
  171. printk(KERN_ERR "bw-qcam: couldn't register for %s.n",
  172.        port->name);
  173. kfree(q);
  174. return NULL;
  175. }
  177. memcpy(&q->vdev, &qcam_template, sizeof(qcam_template));
  179. init_MUTEX(&q->lock);
  181. q->port_mode = (QC_ANY | QC_NOTSET);
  182. q->width = 320;
  183. q->height = 240;
  184. q->bpp = 4;
  185. q->transfer_scale = 2;
  186. q->contrast = 192;
  187. q->brightness = 180;
  188. q->whitebal = 105;
  189. q->top = 1;
  190. q->left = 14;
  191. q->mode = -1;
  192. q->status = QC_PARAM_CHANGE;
  193. return q;
  194. }
  197. /* qc_command is probably a bit of a misnomer -- it's used to send
  198.  * bytes *to* the camera.  Generally, these bytes are either commands
  199.  * or arguments to commands, so the name fits, but it still bugs me a
  200.  * bit.  See the documentation for a list of commands. */
  202. static int qc_command(struct qcam_device *q, int command)
  203. {
  204. int n1, n2;
  205. int cmd;
  207. write_lpdata(q, command);
  208. write_lpcontrol(q, 6);
  210. n1 = qc_waithand(q, 1);
  212. write_lpcontrol(q, 0xe);
  213. n2 = qc_waithand(q, 0);
  215. cmd = (n1 & 0xf0) | ((n2 & 0xf0) >> 4);
  216. return cmd;
  217. }
  219. static int qc_readparam(struct qcam_device *q)
  220. {
  221. int n1, n2;
  222. int cmd;
  224. write_lpcontrol(q, 6);
  225. n1 = qc_waithand(q, 1);
  227. write_lpcontrol(q, 0xe);
  228. n2 = qc_waithand(q, 0);
  230. cmd = (n1 & 0xf0) | ((n2 & 0xf0) >> 4);
  231. return cmd;
  232. }
  234. /* qc_waithand busy-waits for a handshake signal from the QuickCam.
  235.  * Almost all communication with the camera requires handshaking. */
  237. static int qc_waithand(struct qcam_device *q, int val)
  238. {
  239. int status;
  240. int runs=0;
  242. if (val)
  243. {
  244. while (!((status = read_lpstatus(q)) & 8))
  245. {
  246. /* 1000 is enough spins on the I/O for all normal
  247.    cases, at that point we start to poll slowly 
  248.    until the camera wakes up. However, we are
  249.    busy blocked until the camera responds, so
  250.    setting it lower is much better for interactive
  251.    response. */
  252.    
  253. if(runs++>maxpoll)
  254. {
  255. current->state=TASK_INTERRUPTIBLE;
  256. schedule_timeout(HZ/200);
  257. }
  258. if(runs>(maxpoll+1000)) /* 5 seconds */
  259. return -1;
  260. }
  261. }
  262. else
  263. {
  264. while (((status = read_lpstatus(q)) & 8))
  265. {
  266. /* 1000 is enough spins on the I/O for all normal
  267.    cases, at that point we start to poll slowly 
  268.    until the camera wakes up. However, we are
  269.    busy blocked until the camera responds, so
  270.    setting it lower is much better for interactive
  271.    response. */
  272.    
  273. if(runs++>maxpoll)
  274. {
  275. current->state=TASK_INTERRUPTIBLE;
  276. schedule_timeout(HZ/200);
  277. }
  278. if(runs++>(maxpoll+1000)) /* 5 seconds */
  279. return -1;
  280. }
  281. }
  283. return status;
  284. }
  286. /* Waithand2 is used when the qcam is in bidirectional mode, and the
  287.  * handshaking signal is CamRdy2 (bit 0 of data reg) instead of CamRdy1
  288.  * (bit 3 of status register).  It also returns the last value read,
  289.  * since this data is useful. */
  291. static unsigned int qc_waithand2(struct qcam_device *q, int val)
  292. {
  293. unsigned int status;
  294. int runs=0;
  296. do 
  297. {
  298. status = read_lpdata(q);
  299. /* 1000 is enough spins on the I/O for all normal
  300.    cases, at that point we start to poll slowly 
  301.    until the camera wakes up. However, we are
  302.    busy blocked until the camera responds, so
  303.    setting it lower is much better for interactive
  304.    response. */
  305.    
  306. if(runs++>maxpoll)
  307. {
  308. current->state=TASK_INTERRUPTIBLE;
  309. schedule_timeout(HZ/200);
  310. }
  311. if(runs++>(maxpoll+1000)) /* 5 seconds */
  312. return 0;
  313. }
  314. while ((status & 1) != val);
  316. return status;
  317. }
  320. /* Try to detect a QuickCam.  It appears to flash the upper 4 bits of
  321.    the status register at 5-10 Hz.  This is only used in the autoprobe
  322.    code.  Be aware that this isn't the way Connectix detects the
  323.    camera (they send a reset and try to handshake), but this should be
  324.    almost completely safe, while their method screws up my printer if
  325.    I plug it in before the camera. */
  327. static int qc_detect(struct qcam_device *q)
  328. {
  329. int reg, lastreg;
  330. int count = 0;
  331. int i;
  333. lastreg = reg = read_lpstatus(q) & 0xf0;
  335. for (i = 0; i < 500; i++) 
  336. {
  337. reg = read_lpstatus(q) & 0xf0;
  338. if (reg != lastreg)
  339. count++;
  340. lastreg = reg;
  341. mdelay(2);
  342. }
  345. #if 0
  346. /* Force camera detection during testing. Sometimes the camera
  347.    won't be flashing these bits. Possibly unloading the module
  348.    in the middle of a grab? Or some timeout condition?
  349.    I've seen this parameter as low as 19 on my 450Mhz box - mpc */
  350. printk("Debugging: QCam detection counter <30-200 counts as detected>: %dn", count);
  351. return 1;
  352. #endif
  354. /* Be (even more) liberal in what you accept...  */
  356. /* if (count > 30 && count < 200) */
  357. if (count > 20 && count < 300)
  358. return 1; /* found */
  359. else
  360. return 0; /* not found */
  361. }
  364. /* Reset the QuickCam.  This uses the same sequence the Windows
  365.  * QuickPic program uses.  Someone with a bi-directional port should
  366.  * check that bi-directional mode is detected right, and then
  367.  * implement bi-directional mode in qc_readbyte(). */
  369. static void qc_reset(struct qcam_device *q)
  370. {
  371. switch (q->port_mode & QC_FORCE_MASK) 
  372. {
  373. case QC_FORCE_UNIDIR:
  374. q->port_mode = (q->port_mode & ~QC_MODE_MASK) | QC_UNIDIR;
  375. break;
  377. case QC_FORCE_BIDIR:
  378. q->port_mode = (q->port_mode & ~QC_MODE_MASK) | QC_BIDIR;
  379. break;
  381. case QC_ANY:
  382. write_lpcontrol(q, 0x20);
  383. write_lpdata(q, 0x75);
  385. if (read_lpdata(q) != 0x75) {
  386. q->port_mode = (q->port_mode & ~QC_MODE_MASK) | QC_BIDIR;
  387. } else {
  388. q->port_mode = (q->port_mode & ~QC_MODE_MASK) | QC_UNIDIR;
  389. }
  390. break;
  391. }
  393. write_lpcontrol(q, 0xb);
  394. udelay(250);
  395. write_lpcontrol(q, 0xe);
  396. qc_setscanmode(q); /* in case port_mode changed */
  397. }
  400. /* Decide which scan mode to use.  There's no real requirement that
  401.  * the scanmode match the resolution in q->height and q-> width -- the
  402.  * camera takes the picture at the resolution specified in the
  403.  * "scanmode" and then returns the image at the resolution specified
  404.  * with the resolution commands.  If the scan is bigger than the
  405.  * requested resolution, the upper-left hand corner of the scan is
  406.  * returned.  If the scan is smaller, then the rest of the image
  407.  * returned contains garbage. */
  409. static int qc_setscanmode(struct qcam_device *q)
  410. {
  411. int old_mode = q->mode;
  413. switch (q->transfer_scale) 
  414. {
  415. case 1:
  416. q->mode = 0;
  417. break;
  418. case 2:
  419. q->mode = 4;
  420. break;
  421. case 4:
  422. q->mode = 8;
  423. break;
  424. }
  426. switch (q->bpp) 
  427. {
  428. case 4:
  429. break;
  430. case 6:
  431. q->mode += 2;
  432. break;
  433. }
  435. switch (q->port_mode & QC_MODE_MASK) 
  436. {
  437. case QC_BIDIR:
  438. q->mode += 1;
  439. break;
  440. case QC_NOTSET:
  441. case QC_UNIDIR:
  442. break;
  443. }
  445. if (q->mode != old_mode)
  446. q->status |= QC_PARAM_CHANGE;
  448. return 0;
  449. }
  452. /* Reset the QuickCam and program for brightness, contrast,
  453.  * white-balance, and resolution. */
  455. void qc_set(struct qcam_device *q)
  456. {
  457. int val;
  458. int val2;
  460. qc_reset(q);
  462. /* Set the brightness.  Yes, this is repetitive, but it works.
  463.  * Shorter versions seem to fail subtly.  Feel free to try :-). */
  464. /* I think the problem was in qc_command, not here -- bls */
  466. qc_command(q, 0xb);
  467. qc_command(q, q->brightness);
  469. val = q->height / q->transfer_scale;
  470. qc_command(q, 0x11);
  471. qc_command(q, val);
  472. if ((q->port_mode & QC_MODE_MASK) == QC_UNIDIR && q->bpp == 6) {
  473. /* The normal "transfers per line" calculation doesn't seem to work
  474.    as expected here (and yet it works fine in qc_scan).  No idea
  475.    why this case is the odd man out.  Fortunately, Laird's original
  476.    working version gives me a good way to guess at working values.
  477.    -- bls */
  478. val = q->width;
  479. val2 = q->transfer_scale * 4;
  480. } else {
  481. val = q->width * q->bpp;
  482. val2 = (((q->port_mode & QC_MODE_MASK) == QC_BIDIR) ? 24 : 8) *
  483.     q->transfer_scale;
  484. }
  485. val = (val + val2 - 1) / val2;
  486. qc_command(q, 0x13);
  487. qc_command(q, val);
  489. /* Setting top and left -- bls */
  490. qc_command(q, 0xd);
  491. qc_command(q, q->top);
  492. qc_command(q, 0xf);
  493. qc_command(q, q->left / 2);
  495. qc_command(q, 0x19);
  496. qc_command(q, q->contrast);
  497. qc_command(q, 0x1f);
  498. qc_command(q, q->whitebal);
  500. /* Clear flag that we must update the grabbing parameters on the camera
  501.    before we grab the next frame */
  502. q->status &= (~QC_PARAM_CHANGE);
  503. }
  505. /* Qc_readbytes reads some bytes from the QC and puts them in
  506.    the supplied buffer.  It returns the number of bytes read,
  507.    or -1 on error. */
  509. extern __inline__ int qc_readbytes(struct qcam_device *q, char buffer[])
  510. {
  511. int ret=1;
  512. unsigned int hi, lo;
  513. unsigned int hi2, lo2;
  514. static int state = 0;
  516. if (buffer == NULL) 
  517. {
  518. state = 0;
  519. return 0;
  520. }
  522. switch (q->port_mode & QC_MODE_MASK) 
  523. {
  524. case QC_BIDIR: /* Bi-directional Port */
  525. write_lpcontrol(q, 0x26);
  526. lo = (qc_waithand2(q, 1) >> 1);
  527. hi = (read_lpstatus(q) >> 3) & 0x1f;
  528. write_lpcontrol(q, 0x2e);
  529. lo2 = (qc_waithand2(q, 0) >> 1);
  530. hi2 = (read_lpstatus(q) >> 3) & 0x1f;
  531. switch (q->bpp) 
  532. {
  533. case 4:
  534. buffer[0] = lo & 0xf;
  535. buffer[1] = ((lo & 0x70) >> 4) | ((hi & 1) << 3);
  536. buffer[2] = (hi & 0x1e) >> 1;
  537. buffer[3] = lo2 & 0xf;
  538. buffer[4] = ((lo2 & 0x70) >> 4) | ((hi2 & 1) << 3);
  539. buffer[5] = (hi2 & 0x1e) >> 1;
  540. ret = 6;
  541. break;
  542. case 6:
  543. buffer[0] = lo & 0x3f;
  544. buffer[1] = ((lo & 0x40) >> 6) | (hi << 1);
  545. buffer[2] = lo2 & 0x3f;
  546. buffer[3] = ((lo2 & 0x40) >> 6) | (hi2 << 1);
  547. ret = 4;
  548. break;
  549. }
  550. break;
  552. case QC_UNIDIR: /* Unidirectional Port */
  553. write_lpcontrol(q, 6);
  554. lo = (qc_waithand(q, 1) & 0xf0) >> 4;
  555. write_lpcontrol(q, 0xe);
  556. hi = (qc_waithand(q, 0) & 0xf0) >> 4;
  558. switch (q->bpp) 
  559. {
  560. case 4:
  561. buffer[0] = lo;
  562. buffer[1] = hi;
  563. ret = 2;
  564. break;
  565. case 6:
  566. switch (state) 
  567. {
  568. case 0:
  569. buffer[0] = (lo << 2) | ((hi & 0xc) >> 2);
  570. q->saved_bits = (hi & 3) << 4;
  571. state = 1;
  572. ret = 1;
  573. break;
  574. case 1:
  575. buffer[0] = lo | q->saved_bits;
  576. q->saved_bits = hi << 2;
  577. state = 2;
  578. ret = 1;
  579. break;
  580. case 2:
  581. buffer[0] = ((lo & 0xc) >> 2) | q->saved_bits;
  582. buffer[1] = ((lo & 3) << 4) | hi;
  583. state = 0;
  584. ret = 2;
  585. break;
  586. }
  587. break;
  588. }
  589. break;
  590. }
  591. return ret;
  592. }
  594. /* requests a scan from the camera.  It sends the correct instructions
  595.  * to the camera and then reads back the correct number of bytes.  In
  596.  * previous versions of this routine the return structure contained
  597.  * the raw output from the camera, and there was a 'qc_convertscan'
  598.  * function that converted that to a useful format.  In version 0.3 I
  599.  * rolled qc_convertscan into qc_scan and now I only return the
  600.  * converted scan.  The format is just an one-dimensional array of
  601.  * characters, one for each pixel, with 0=black up to n=white, where
  602.  * n=2^(bit depth)-1.  Ask me for more details if you don't understand
  603.  * this. */
  605. long qc_capture(struct qcam_device * q, char *buf, unsigned long len)
  606. {
  607. int i, j, k, yield;
  608. int bytes;
  609. int linestotrans, transperline;
  610. int divisor;
  611. int pixels_per_line;
  612. int pixels_read = 0;
  613. int got=0;
  614. char buffer[6];
  615. int  shift=8-q->bpp;
  616. char invert;
  618. if (q->mode == -1) 
  619. return -ENXIO;
  621. qc_command(q, 0x7);
  622. qc_command(q, q->mode);
  624. if ((q->port_mode & QC_MODE_MASK) == QC_BIDIR) 
  625. {
  626. write_lpcontrol(q, 0x2e); /* turn port around */
  627. write_lpcontrol(q, 0x26);
  628. (void) qc_waithand(q, 1);
  629. write_lpcontrol(q, 0x2e);
  630. (void) qc_waithand(q, 0);
  631. }
  633. /* strange -- should be 15:63 below, but 4bpp is odd */
  634. invert = (q->bpp == 4) ? 16 : 63;
  636. linestotrans = q->height / q->transfer_scale;
  637. pixels_per_line = q->width / q->transfer_scale;
  638. transperline = q->width * q->bpp;
  639. divisor = (((q->port_mode & QC_MODE_MASK) == QC_BIDIR) ? 24 : 8) *
  640.     q->transfer_scale;
  641. transperline = (transperline + divisor - 1) / divisor;
  643. for (i = 0, yield = yieldlines; i < linestotrans; i++) 
  644. {
  645. for (pixels_read = j = 0; j < transperline; j++) 
  646. {
  647. bytes = qc_readbytes(q, buffer);
  648. for (k = 0; k < bytes && (pixels_read + k) < pixels_per_line; k++) 
  649. {
  650. int o;
  651. if (buffer[k] == 0 && invert == 16) 
  652. {
  653. /* 4bpp is odd (again) -- inverter is 16, not 15, but output
  654.    must be 0-15 -- bls */
  655. buffer[k] = 16;
  656. }
  657. o=i*pixels_per_line + pixels_read + k;
  658. if(o<len)
  659. {
  660. got++;
  661. put_user((invert - buffer[k])<<shift, buf+o);
  662. }
  663. }
  664. pixels_read += bytes;
  665. }
  666. (void) qc_readbytes(q, 0); /* reset state machine */
  668. /* Grabbing an entire frame from the quickcam is a lengthy
  669.    process. We don't (usually) want to busy-block the
  670.    processor for the entire frame. yieldlines is a module
  671.    parameter. If we yield every line, the minimum frame
  672.    time will be 240 / 200 = 1.2 seconds. The compile-time
  673.    default is to yield every 4 lines. */
  674. if (i >= yield) {
  675. current->state=TASK_INTERRUPTIBLE;
  676. schedule_timeout(HZ/200);
  677. yield = i + yieldlines;
  678. }
  679. }
  681. if ((q->port_mode & QC_MODE_MASK) == QC_BIDIR) 
  682. {
  683. write_lpcontrol(q, 2);
  684. write_lpcontrol(q, 6);
  685. udelay(3);
  686. write_lpcontrol(q, 0xe);
  687. }
  688. if(got<len)
  689. return got;
  690. return len;
  691. }
  693. /*
  694.  * Video4linux interfacing
  695.  */
  697. static int qcam_open(struct video_device *dev, int flags)
  698. {
  699. return 0;
  700. }
  702. static void qcam_close(struct video_device *dev)
  703. {
  704. }
  706. static long qcam_write(struct video_device *v, const char *buf, unsigned long count, int noblock)
  707. {
  708. return -EINVAL;
  709. }
  711. static int qcam_ioctl(struct video_device *dev, unsigned int cmd, void *arg)
  712. {
  713. struct qcam_device *qcam=(struct qcam_device *)dev;
  715. switch(cmd)
  716. {
  717. case VIDIOCGCAP:
  718. {
  719. struct video_capability b;
  720. strcpy(b.name, "Quickcam");
  721. b.type = VID_TYPE_CAPTURE|VID_TYPE_SCALES|VID_TYPE_MONOCHROME;
  722. b.channels = 1;
  723. b.audios = 0;
  724. b.maxwidth = 320;
  725. b.maxheight = 240;
  726. b.minwidth = 80;
  727. b.minheight = 60;
  728. if(copy_to_user(arg, &b,sizeof(b)))
  729. return -EFAULT;
  730. return 0;
  731. }
  732. case VIDIOCGCHAN:
  733. {
  734. struct video_channel v;
  735. if(copy_from_user(&v, arg, sizeof(v)))
  736. return -EFAULT;
  737. if(v.channel!=0)
  738. return -EINVAL;
  739. v.flags=0;
  740. v.tuners=0;
  741. /* Good question.. its composite or SVHS so.. */
  742. v.type = VIDEO_TYPE_CAMERA;
  743. strcpy(v.name, "Camera");
  744. if(copy_to_user(arg, &v, sizeof(v)))
  745. return -EFAULT;
  746. return 0;
  747. }
  748. case VIDIOCSCHAN:
  749. {
  750. int v;
  751. if(copy_from_user(&v, arg,sizeof(v)))
  752. return -EFAULT;
  753. if(v!=0)
  754. return -EINVAL;
  755. return 0;
  756. }
  757. case VIDIOCGTUNER:
  758. {
  759. struct video_tuner v;
  760. if(copy_from_user(&v, arg, sizeof(v))!=0)
  761. return -EFAULT;
  762. if(v.tuner)
  763. return -EINVAL;
  764. strcpy(v.name, "Format");
  765. v.rangelow=0;
  766. v.rangehigh=0;
  767. v.flags= 0;
  768. v.mode = VIDEO_MODE_AUTO;
  769. if(copy_to_user(arg,&v,sizeof(v))!=0)
  770. return -EFAULT;
  771. return 0;
  772. }
  773. case VIDIOCSTUNER:
  774. {
  775. struct video_tuner v;
  776. if(copy_from_user(&v, arg, sizeof(v))!=0)
  777. return -EFAULT;
  778. if(v.tuner)
  779. return -EINVAL;
  780. if(v.mode!=VIDEO_MODE_AUTO)
  781. return -EINVAL;
  782. return 0;
  783. }
  784. case VIDIOCGPICT:
  785. {
  786. struct video_picture p;
  787. p.colour=0x8000;
  788. p.hue=0x8000;
  789. p.brightness=qcam->brightness<<8;
  790. p.contrast=qcam->contrast<<8;
  791. p.whiteness=qcam->whitebal<<8;
  792. p.depth=qcam->bpp;
  793. p.palette=VIDEO_PALETTE_GREY;
  794. if(copy_to_user(arg, &p, sizeof(p)))
  795. return -EFAULT;
  796. return 0;
  797. }
  798. case VIDIOCSPICT:
  799. {
  800. struct video_picture p;
  801. if(copy_from_user(&p, arg, sizeof(p)))
  802. return -EFAULT;
  803. if(p.palette!=VIDEO_PALETTE_GREY)
  804.      return -EINVAL;
  805. if(p.depth!=4 && p.depth!=6)
  806. return -EINVAL;
  808. /*
  809.  * Now load the camera.
  810.  */
  812. qcam->brightness = p.brightness>>8;
  813. qcam->contrast = p.contrast>>8;
  814. qcam->whitebal = p.whiteness>>8;
  815. qcam->bpp = p.depth;
  817. down(&qcam->lock);
  818. qc_setscanmode(qcam);
  819. up(&qcam->lock);
  820. qcam->status |= QC_PARAM_CHANGE;
  822. return 0;
  823. }
  824. case VIDIOCSWIN:
  825. {
  826. struct video_window vw;
  827. if(copy_from_user(&vw, arg,sizeof(vw)))
  828. return -EFAULT;
  829. if(vw.flags)
  830. return -EINVAL;
  831. if(vw.clipcount)
  832. return -EINVAL;
  833. if(vw.height<60||vw.height>240)
  834. return -EINVAL;
  835. if(vw.width<80||vw.width>320)
  836. return -EINVAL;
  838. qcam->width = 320;
  839. qcam->height = 240;
  840. qcam->transfer_scale = 4;
  842. if(vw.width>=160 && vw.height>=120)
  843. {
  844. qcam->transfer_scale = 2;
  845. }
  846. if(vw.width>=320 && vw.height>=240)
  847. {
  848. qcam->width = 320;
  849. qcam->height = 240;
  850. qcam->transfer_scale = 1;
  851. }
  852. down(&qcam->lock);
  853. qc_setscanmode(qcam);
  854. up(&qcam->lock);
  856. /* We must update the camera before we grab. We could
  857.    just have changed the grab size */
  858. qcam->status |= QC_PARAM_CHANGE;
  860. /* Ok we figured out what to use from our wide choice */
  861. return 0;
  862. }
  863. case VIDIOCGWIN:
  864. {
  865. struct video_window vw;
  866. memset(&vw, 0, sizeof(vw));
  867. vw.width=qcam->width/qcam->transfer_scale;
  868. vw.height=qcam->height/qcam->transfer_scale;
  869. if(copy_to_user(arg, &vw, sizeof(vw)))
  870. return -EFAULT;
  871. return 0;
  872. }
  873. case VIDIOCCAPTURE:
  874. return -EINVAL;
  875. case VIDIOCGFBUF:
  876. return -EINVAL;
  877. case VIDIOCSFBUF:
  878. return -EINVAL;
  879. case VIDIOCKEY:
  880. return 0;
  881. case VIDIOCGFREQ:
  882. return -EINVAL;
  883. case VIDIOCSFREQ:
  884. return -EINVAL;
  885. case VIDIOCGAUDIO:
  886. return -EINVAL;
  887. case VIDIOCSAUDIO:
  888. return -EINVAL;
  889. default:
  890. return -ENOIOCTLCMD;
  891. }
  892. return 0;
  893. }
  895. static long qcam_read(struct video_device *v, char *buf, unsigned long count,  int noblock)
  896. {
  897. struct qcam_device *qcam=(struct qcam_device *)v;
  898. int len;
  899. parport_claim_or_block(qcam->pdev);
  901. down(&qcam->lock);
  903. qc_reset(qcam);
  905. /* Update the camera parameters if we need to */
  906. if (qcam->status & QC_PARAM_CHANGE)
  907. qc_set(qcam);
  909. len=qc_capture(qcam, buf,count);
  911. up(&qcam->lock);
  913. parport_release(qcam->pdev);
  914. return len;
  915. }
  916.  
  917. static struct video_device qcam_template=
  918. {
  919. owner: THIS_MODULE,
  920. name: "Connectix Quickcam",
  921. type: VID_TYPE_CAPTURE,
  922. hardware: VID_HARDWARE_QCAM_BW,
  923. open: qcam_open,
  924. close: qcam_close,
  925. read: qcam_read,
  926. write: qcam_write,
  927. ioctl: qcam_ioctl,
  928. };
  930. #define MAX_CAMS 4
  931. static struct qcam_device *qcams[MAX_CAMS];
  932. static unsigned int num_cams = 0;
  934. int init_bwqcam(struct parport *port)
  935. {
  936. struct qcam_device *qcam;
  938. if (num_cams == MAX_CAMS)
  939. {
  940. printk(KERN_ERR "Too many Quickcams (max %d)n", MAX_CAMS);
  941. return -ENOSPC;
  942. }
  944. qcam=qcam_init(port);
  945. if(qcam==NULL)
  946. return -ENODEV;
  948. parport_claim_or_block(qcam->pdev);
  950. qc_reset(qcam);
  952. if(qc_detect(qcam)==0)
  953. {
  954. parport_release(qcam->pdev);
  955. parport_unregister_device(qcam->pdev);
  956. kfree(qcam);
  957. return -ENODEV;
  958. }
  959. qc_calibrate(qcam);
  961. parport_release(qcam->pdev);
  963. printk(KERN_INFO "Connectix Quickcam on %sn", qcam->pport->name);
  965. if(video_register_device(&qcam->vdev, VFL_TYPE_GRABBER, video_nr)==-1)
  966. {
  967. parport_unregister_device(qcam->pdev);
  968. kfree(qcam);
  969. return -ENODEV;
  970. }
  972. qcams[num_cams++] = qcam;
  974. return 0;
  975. }
  977. void close_bwqcam(struct qcam_device *qcam)
  978. {
  979. video_unregister_device(&qcam->vdev);
  980. parport_unregister_device(qcam->pdev);
  981. kfree(qcam);
  982. }
  984. /* The parport parameter controls which parports will be scanned.
  985.  * Scanning all parports causes some printers to print a garbage page.
  986.  *       -- March 14, 1999  Billy Donahue <billy@escape.com> */
  987. #ifdef MODULE
  988. static char *parport[MAX_CAMS] = { NULL, };
  989. MODULE_PARM(parport, "1-" __MODULE_STRING(MAX_CAMS) "s");
  990. #endif
  992. static void __exit exit_bw_qcams(void)
  993. {
  994. unsigned int i;
  996. for (i = 0; i < num_cams; i++)
  997. close_bwqcam(qcams[i]);
  998. }
  1000. static int __init init_bw_qcams(void)
  1001. {
  1002. struct parport *port;
  1003. #ifdef MODULE
  1004. int n;
  1006. if(parport[0] && strncmp(parport[0], "auto", 4)){
  1007. /* user gave parport parameters */
  1008. for(n=0; parport[n] && n<MAX_CAMS; n++){
  1009. char *ep;
  1010. unsigned long r;
  1011. r = simple_strtoul(parport[n], &ep, 0);
  1012. if(ep == parport[n]){
  1013. printk(KERN_ERR
  1014. "bw-qcam: bad port specifier "%s"n",
  1015. parport[n]);
  1016. continue;
  1017. }
  1018. for (port=parport_enumerate(); port; port=port->next){
  1019. if(r!=port->number)
  1020. continue;
  1021. init_bwqcam(port);
  1022. break;
  1023. }
  1024. }
  1025. return (num_cams)?0:-ENODEV;
  1026. } 
  1027. /* no parameter or "auto" */
  1028. for (port = parport_enumerate(); port; port=port->next)
  1029. init_bwqcam(port);
  1031. /* Do some sanity checks on the module parameters. */
  1032. if (maxpoll > 5000) {
  1033. printk("Connectix Quickcam max-poll was above 5000. Using 5000.n");
  1034. maxpoll = 5000;
  1035. }
  1037. if (yieldlines < 1) {
  1038. printk("Connectix Quickcam yieldlines was less than 1. Using 1.n");
  1039. yieldlines = 1;
  1040. }
  1042. return (num_cams)?0:-ENODEV;
  1043. #else
  1044. for (port = parport_enumerate(); port; port=port->next)
  1045. init_bwqcam(port);
  1046. return 0;
  1047. #endif
  1048. }
  1050. module_init(init_bw_qcams);
  1051. module_exit(exit_bw_qcams);
  1053. MODULE_LICENSE("GPL");