2 * cpia_pp CPiA Parallel Port driver
4 * Supports CPiA based parallel port Video Camera's.
6 * (C) Copyright 1999 Bas Huisman <bhuism@cs.utwente.nl>
7 * (C) Copyright 1999-2000 Scott J. Bertin <sbertin@securenym.net>,
8 * (C) Copyright 1999-2000 Peter Pregler <Peter_Pregler@email.com>
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 /* define _CPIA_DEBUG_ for verbose debug output (see cpia.h) */
26 /* #define _CPIA_DEBUG_ 1 */
29 #include <linux/module.h>
30 #include <linux/init.h>
32 #include <linux/kernel.h>
33 #include <linux/parport.h>
34 #include <linux/interrupt.h>
35 #include <linux/delay.h>
36 #include <linux/workqueue.h>
37 #include <linux/smp_lock.h>
38 #include <linux/sched.h>
40 #include <linux/kmod.h>
42 /* #define _CPIA_DEBUG_ define for verbose debug output */
45 static int cpia_pp_open(void *privdata);
46 static int cpia_pp_registerCallback(void *privdata, void (*cb) (void *cbdata),
48 static int cpia_pp_transferCmd(void *privdata, u8 *command, u8 *data);
49 static int cpia_pp_streamStart(void *privdata);
50 static int cpia_pp_streamStop(void *privdata);
51 static int cpia_pp_streamRead(void *privdata, u8 *buffer, int noblock);
52 static int cpia_pp_close(void *privdata);
55 #define ABOUT "Parallel port driver for Vision CPiA based cameras"
57 #define PACKET_LENGTH 8
59 /* Magic numbers for defining port-device mappings */
60 #define PPCPIA_PARPORT_UNSPEC -4
61 #define PPCPIA_PARPORT_AUTO -3
62 #define PPCPIA_PARPORT_OFF -2
63 #define PPCPIA_PARPORT_NONE -1
66 static int parport_nr[PARPORT_MAX] = {[0 ... PARPORT_MAX - 1] = PPCPIA_PARPORT_UNSPEC};
67 static char *parport[PARPORT_MAX] = {NULL,};
69 MODULE_AUTHOR("B. Huisman <bhuism@cs.utwente.nl> & Peter Pregler <Peter_Pregler@email.com>");
70 MODULE_DESCRIPTION("Parallel port driver for Vision CPiA based cameras");
71 MODULE_LICENSE("GPL");
73 module_param_array(parport, charp, NULL, 0);
74 MODULE_PARM_DESC(parport, "'auto' or a list of parallel port numbers. Just like lp.");
76 static int parport_nr[PARPORT_MAX] __initdata =
77 {[0 ... PARPORT_MAX - 1] = PPCPIA_PARPORT_UNSPEC};
78 static int parport_ptr = 0;
82 struct pardevice *pdev;
84 struct work_struct cb_task;
85 void (*cb_func)(void *cbdata);
88 wait_queue_head_t wq_stream;
89 /* image state flags */
90 int image_ready; /* we got an interrupt */
91 int image_complete; /* we have seen 4 EOI */
93 int streaming; /* we are in streaming mode */
97 static struct cpia_camera_ops cpia_pp_ops =
100 cpia_pp_registerCallback,
110 static LIST_HEAD(cam_list);
111 static spinlock_t cam_list_lock_pp;
114 static void cpia_parport_enable_irq( struct parport *port ) {
115 parport_enable_irq(port);
120 static void cpia_parport_disable_irq( struct parport *port ) {
121 parport_disable_irq(port);
126 /* Special CPiA PPC modes: These are invoked by using the 1284 Extensibility
127 * Link Flag during negotiation */
128 #define UPLOAD_FLAG 0x08
129 #define NIBBLE_TRANSFER 0x01
130 #define ECP_TRANSFER 0x03
132 #define PARPORT_CHUNK_SIZE PAGE_SIZE
135 static void cpia_pp_run_callback(struct work_struct *work)
137 void (*cb_func)(void *cbdata);
139 struct pp_cam_entry *cam;
141 cam = container_of(work, struct pp_cam_entry, cb_task);
142 cb_func = cam->cb_func;
143 cb_data = cam->cb_data;
148 /****************************************************************************
150 * CPiA-specific low-level parport functions for nibble uploads
152 ***************************************************************************/
153 /* CPiA nonstandard "Nibble" mode (no nDataAvail signal after each byte). */
154 /* The standard kernel parport_ieee1284_read_nibble() fails with the CPiA... */
156 static size_t cpia_read_nibble (struct parport *port,
157 void *buffer, size_t len,
160 /* adapted verbatim, with one change, from
161 parport_ieee1284_read_nibble() in drivers/parport/ieee1284-ops.c */
163 unsigned char *buf = buffer;
165 unsigned char byte = 0;
167 len *= 2; /* in nibbles */
168 for (i=0; i < len; i++) {
169 unsigned char nibble;
171 /* The CPiA firmware suppresses the use of nDataAvail (nFault LO)
172 * after every second nibble to signal that more
173 * data is available. (the total number of Bytes that
174 * should be sent is known; if too few are received, an error
175 * will be recorded after a timeout).
176 * This is incompatible with parport_ieee1284_read_nibble(),
177 * which expects to find nFault LO after every second nibble.
180 /* Solution: modify cpia_read_nibble to only check for
181 * nDataAvail before the first nibble is sent.
184 /* Does the error line indicate end of data? */
185 if (((i /*& 1*/) == 0) &&
186 (parport_read_status(port) & PARPORT_STATUS_ERROR)) {
187 DBG("%s: No more nibble data (%d bytes)\n",
192 /* Event 7: Set nAutoFd low. */
193 parport_frob_control (port,
194 PARPORT_CONTROL_AUTOFD,
195 PARPORT_CONTROL_AUTOFD);
197 /* Event 9: nAck goes low. */
198 port->ieee1284.phase = IEEE1284_PH_REV_DATA;
199 if (parport_wait_peripheral (port,
200 PARPORT_STATUS_ACK, 0)) {
201 /* Timeout -- no more data? */
202 DBG("%s: Nibble timeout at event 9 (%d bytes)\n",
204 parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0);
210 nibble = parport_read_status (port) >> 3;
212 if ((nibble & 0x10) == 0)
216 /* Event 10: Set nAutoFd high. */
217 parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0);
219 /* Event 11: nAck goes high. */
220 if (parport_wait_peripheral (port,
222 PARPORT_STATUS_ACK)) {
223 /* Timeout -- no more data? */
224 DBG("%s: Nibble timeout at event 11\n",
238 /* Read the last nibble without checking data avail. */
239 if (parport_read_status (port) & PARPORT_STATUS_ERROR) {
241 /* Go to reverse idle phase. */
242 parport_frob_control (port,
243 PARPORT_CONTROL_AUTOFD,
244 PARPORT_CONTROL_AUTOFD);
245 port->physport->ieee1284.phase = IEEE1284_PH_REV_IDLE;
248 port->physport->ieee1284.phase = IEEE1284_PH_HBUSY_DAVAIL;
254 /* CPiA nonstandard "Nibble Stream" mode (2 nibbles per cycle, instead of 1)
255 * (See CPiA Data sheet p. 31)
257 * "Nibble Stream" mode used by CPiA for uploads to non-ECP ports is a
258 * nonstandard variant of nibble mode which allows the same (mediocre)
259 * data flow of 8 bits per cycle as software-enabled ECP by TRISTATE-capable
260 * parallel ports, but works also for non-TRISTATE-capable ports.
261 * (Standard nibble mode only send 4 bits per cycle)
265 static size_t cpia_read_nibble_stream(struct parport *port,
266 void *buffer, size_t len,
270 unsigned char *buf = buffer;
273 for (i=0; i < len; i++) {
274 unsigned char nibble[2], byte = 0;
277 /* Image Data is complete when 4 consecutive EOI bytes (0xff) are seen */
281 /* Event 7: Set nAutoFd low. */
282 parport_frob_control (port,
283 PARPORT_CONTROL_AUTOFD,
284 PARPORT_CONTROL_AUTOFD);
286 /* Event 9: nAck goes low. */
287 port->ieee1284.phase = IEEE1284_PH_REV_DATA;
288 if (parport_wait_peripheral (port,
289 PARPORT_STATUS_ACK, 0)) {
290 /* Timeout -- no more data? */
291 DBG("%s: Nibble timeout at event 9 (%d bytes)\n",
293 parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0);
297 /* Read lower nibble */
298 nibble[0] = parport_read_status (port) >>3;
300 /* Event 10: Set nAutoFd high. */
301 parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0);
303 /* Event 11: nAck goes high. */
304 if (parport_wait_peripheral (port,
306 PARPORT_STATUS_ACK)) {
307 /* Timeout -- no more data? */
308 DBG("%s: Nibble timeout at event 11\n",
313 /* Read upper nibble */
314 nibble[1] = parport_read_status (port) >>3;
316 /* reassemble the byte */
317 for (j = 0; j < 2 ; j++ ) {
319 if ((nibble[j] & 0x10) == 0)
323 byte = (nibble[0] |(nibble[1] << 4));
334 /****************************************************************************
338 ***************************************************************************/
339 static void EndTransferMode(struct pp_cam_entry *cam)
341 parport_negotiate(cam->port, IEEE1284_MODE_COMPAT);
344 /****************************************************************************
348 ***************************************************************************/
349 static int ForwardSetup(struct pp_cam_entry *cam)
353 /* The CPiA uses ECP protocol for Downloads from the Host to the camera.
354 * This will be software-emulated if ECP hardware is not present
357 /* the usual camera maximum response time is 10ms, but after receiving
358 * some commands, it needs up to 40ms. (Data Sheet p. 32)*/
360 for(retry = 0; retry < 4; ++retry) {
361 if(!parport_negotiate(cam->port, IEEE1284_MODE_ECP)) {
367 DBG("Unable to negotiate IEEE1284 ECP Download mode\n");
372 /****************************************************************************
376 ***************************************************************************/
377 static int ReverseSetup(struct pp_cam_entry *cam, int extensibility)
380 int upload_mode, mode = IEEE1284_MODE_ECP;
381 int transfer_mode = ECP_TRANSFER;
383 if (!(cam->port->modes & PARPORT_MODE_ECP) &&
384 !(cam->port->modes & PARPORT_MODE_TRISTATE)) {
385 mode = IEEE1284_MODE_NIBBLE;
386 transfer_mode = NIBBLE_TRANSFER;
390 if(extensibility) mode = UPLOAD_FLAG|transfer_mode|IEEE1284_EXT_LINK;
392 /* the usual camera maximum response time is 10ms, but after
393 * receiving some commands, it needs up to 40ms. */
395 for(retry = 0; retry < 4; ++retry) {
396 if(!parport_negotiate(cam->port, mode)) {
403 DBG("Unable to negotiate upload extensibility mode\n");
405 DBG("Unable to negotiate upload mode\n");
408 if(extensibility) cam->port->ieee1284.mode = upload_mode;
412 /****************************************************************************
416 ***************************************************************************/
417 static int WritePacket(struct pp_cam_entry *cam, const u8 *packet, size_t size)
422 if (packet == NULL) {
425 if (ForwardSetup(cam)) {
426 DBG("Write failed in setup\n");
429 size_written = parport_write(cam->port, packet, size);
430 if(size_written != size) {
431 DBG("Write failed, wrote %d/%d\n", size_written, size);
434 EndTransferMode(cam);
438 /****************************************************************************
442 ***************************************************************************/
443 static int ReadPacket(struct pp_cam_entry *cam, u8 *packet, size_t size)
447 if (packet == NULL) {
450 if (ReverseSetup(cam, 0)) {
454 /* support for CPiA variant nibble reads */
455 if(cam->port->ieee1284.mode == IEEE1284_MODE_NIBBLE) {
456 if(cpia_read_nibble(cam->port, packet, size, 0) != size)
459 if(parport_read(cam->port, packet, size) != size)
462 EndTransferMode(cam);
466 /****************************************************************************
468 * cpia_pp_streamStart
470 ***************************************************************************/
471 static int cpia_pp_streamStart(void *privdata)
473 struct pp_cam_entry *cam = privdata;
477 //if (ReverseSetup(cam,1)) return -EIO;
478 if(cam->stream_irq) cpia_parport_enable_irq(cam->port);
482 /****************************************************************************
486 ***************************************************************************/
487 static int cpia_pp_streamStop(void *privdata)
489 struct pp_cam_entry *cam = privdata;
493 cpia_parport_disable_irq(cam->port);
494 //EndTransferMode(cam);
499 /****************************************************************************
503 ***************************************************************************/
504 static int cpia_pp_read(struct parport *port, u8 *buffer, int len)
508 /* support for CPiA variant "nibble stream" reads */
509 if(port->ieee1284.mode == IEEE1284_MODE_NIBBLE)
510 bytes_read = cpia_read_nibble_stream(port,buffer,len,0);
513 for(bytes_read=0; bytes_read<len; bytes_read += new_bytes) {
514 new_bytes = parport_read(port, buffer+bytes_read,
516 if(new_bytes < 0) break;
522 static int cpia_pp_streamRead(void *privdata, u8 *buffer, int noblock)
524 struct pp_cam_entry *cam = privdata;
526 int i, endseen, block_size, new_bytes;
529 DBG("Internal driver error: cam is NULL\n");
533 DBG("Internal driver error: buffer is NULL\n");
536 //if(cam->streaming) DBG("%d / %d\n", cam->image_ready, noblock);
537 if( cam->stream_irq ) {
538 DBG("%d\n", cam->image_ready);
541 cam->image_complete=0;
542 if (0/*cam->streaming*/) {
543 if(!cam->image_ready) {
544 if(noblock) return -EWOULDBLOCK;
545 interruptible_sleep_on(&cam->wq_stream);
546 if( signal_pending(current) ) return -EINTR;
547 DBG("%d\n", cam->image_ready);
550 if (ReverseSetup(cam, 1)) {
551 DBG("unable to ReverseSetup\n");
556 block_size = PARPORT_CHUNK_SIZE;
557 while( !cam->image_complete ) {
560 new_bytes = cpia_pp_read(cam->port, buffer, block_size );
561 if( new_bytes <= 0 ) {
565 while(++i<new_bytes && endseen<4) {
575 cam->image_complete=1;
578 if( CPIA_MAX_IMAGE_SIZE-read_bytes <= PARPORT_CHUNK_SIZE ) {
579 block_size=CPIA_MAX_IMAGE_SIZE-read_bytes;
582 EndTransferMode(cam);
583 return cam->image_complete ? read_bytes : -EIO;
585 /****************************************************************************
587 * cpia_pp_transferCmd
589 ***************************************************************************/
590 static int cpia_pp_transferCmd(void *privdata, u8 *command, u8 *data)
595 struct pp_cam_entry *cam = privdata;
598 DBG("Internal driver error: cam is NULL\n");
601 if(command == NULL) {
602 DBG("Internal driver error: command is NULL\n");
605 databytes = (((int)command[7])<<8) | command[6];
606 if ((err = WritePacket(cam, command, PACKET_LENGTH)) < 0) {
607 DBG("Error writing command\n");
610 if(command[0] == DATA_IN) {
613 DBG("Internal driver error: data is NULL\n");
616 if((err = ReadPacket(cam, buffer, 8)) < 0) {
617 DBG("Error reading command result\n");
620 memcpy(data, buffer, databytes);
621 } else if(command[0] == DATA_OUT) {
624 DBG("Internal driver error: data is NULL\n");
627 if((err=WritePacket(cam, data, databytes)) < 0){
628 DBG("Error writing command data\n");
634 DBG("Unexpected first byte of command: %x\n", command[0]);
640 /****************************************************************************
644 ***************************************************************************/
645 static int cpia_pp_open(void *privdata)
647 struct pp_cam_entry *cam = (struct pp_cam_entry *)privdata;
652 if(cam->open_count == 0) {
653 if (parport_claim(cam->pdev)) {
654 DBG("failed to claim the port\n");
657 parport_negotiate(cam->port, IEEE1284_MODE_COMPAT);
658 parport_data_forward(cam->port);
659 parport_write_control(cam->port, PARPORT_CONTROL_SELECT);
661 parport_write_control(cam->port,
662 PARPORT_CONTROL_SELECT
663 | PARPORT_CONTROL_INIT);
671 /****************************************************************************
673 * cpia_pp_registerCallback
675 ***************************************************************************/
676 static int cpia_pp_registerCallback(void *privdata, void (*cb)(void *cbdata), void *cbdata)
678 struct pp_cam_entry *cam = privdata;
681 if(cam->port->irq != PARPORT_IRQ_NONE) {
683 cam->cb_data = cbdata;
684 INIT_WORK(&cam->cb_task, cpia_pp_run_callback);
691 /****************************************************************************
695 ***************************************************************************/
696 static int cpia_pp_close(void *privdata)
698 struct pp_cam_entry *cam = privdata;
699 if (--cam->open_count == 0) {
700 parport_release(cam->pdev);
705 /****************************************************************************
709 ***************************************************************************/
710 static int cpia_pp_register(struct parport *port)
712 struct pardevice *pdev = NULL;
713 struct pp_cam_entry *cam;
714 struct cam_data *cpia;
716 if (!(port->modes & PARPORT_MODE_PCSPP)) {
717 LOG("port is not supported by CPiA driver\n");
721 cam = kzalloc(sizeof(struct pp_cam_entry), GFP_KERNEL);
723 LOG("failed to allocate camera structure\n");
727 pdev = parport_register_device(port, "cpia_pp", NULL, NULL,
731 LOG("failed to parport_register_device\n");
738 init_waitqueue_head(&cam->wq_stream);
743 if((cpia = cpia_register_camera(&cpia_pp_ops, cam)) == NULL) {
744 LOG("failed to cpia_register_camera\n");
745 parport_unregister_device(pdev);
749 spin_lock( &cam_list_lock_pp );
750 list_add( &cpia->cam_data_list, &cam_list );
751 spin_unlock( &cam_list_lock_pp );
756 static void cpia_pp_detach (struct parport *port)
758 struct list_head *tmp;
759 struct cam_data *cpia = NULL;
760 struct pp_cam_entry *cam;
762 spin_lock( &cam_list_lock_pp );
763 list_for_each (tmp, &cam_list) {
764 cpia = list_entry(tmp, struct cam_data, cam_data_list);
765 cam = (struct pp_cam_entry *) cpia->lowlevel_data;
766 if (cam && cam->port->number == port->number) {
767 list_del(&cpia->cam_data_list);
772 spin_unlock( &cam_list_lock_pp );
775 DBG("cpia_pp_detach failed to find cam_data in cam_list\n");
779 cam = (struct pp_cam_entry *) cpia->lowlevel_data;
780 cpia_unregister_camera(cpia);
781 if(cam->open_count > 0)
783 parport_unregister_device(cam->pdev);
784 cpia->lowlevel_data = NULL;
788 static void cpia_pp_attach (struct parport *port)
792 switch (parport_nr[0])
794 case PPCPIA_PARPORT_UNSPEC:
795 case PPCPIA_PARPORT_AUTO:
796 if (port->probe_info[0].class != PARPORT_CLASS_MEDIA ||
797 port->probe_info[0].cmdset == NULL ||
798 strncmp(port->probe_info[0].cmdset, "CPIA_1", 6) != 0)
801 cpia_pp_register(port);
806 for (i = 0; i < PARPORT_MAX; ++i) {
807 if (port->number == parport_nr[i]) {
808 cpia_pp_register(port);
816 static struct parport_driver cpia_pp_driver = {
818 .attach = cpia_pp_attach,
819 .detach = cpia_pp_detach,
822 static int cpia_pp_init(void)
824 printk(KERN_INFO "%s v%d.%d.%d\n",ABOUT,
825 CPIA_PP_MAJ_VER,CPIA_PP_MIN_VER,CPIA_PP_PATCH_VER);
827 if(parport_nr[0] == PPCPIA_PARPORT_OFF) {
828 printk(" disabled\n");
832 spin_lock_init( &cam_list_lock_pp );
834 if (parport_register_driver (&cpia_pp_driver)) {
835 LOG ("unable to register with parport\n");
842 int init_module(void)
845 /* The user gave some parameters. Let's see what they were. */
846 if (!strncmp(parport[0], "auto", 4)) {
847 parport_nr[0] = PPCPIA_PARPORT_AUTO;
850 for (n = 0; n < PARPORT_MAX && parport[n]; n++) {
851 if (!strncmp(parport[n], "none", 4)) {
852 parport_nr[n] = PPCPIA_PARPORT_NONE;
855 unsigned long r = simple_strtoul(parport[n], &ep, 0);
856 if (ep != parport[n]) {
859 LOG("bad port specifier `%s'\n", parport[n]);
866 return cpia_pp_init();
869 void cleanup_module(void)
871 parport_unregister_driver (&cpia_pp_driver);
877 static int __init cpia_pp_setup(char *str)
881 if (!strncmp(str, "parport", 7)) {
882 int n = simple_strtoul(str + 7, NULL, 10);
883 if (parport_ptr < PARPORT_MAX) {
884 parport_nr[parport_ptr++] = n;
886 LOG("too many ports, %s ignored.\n", str);
888 } else if (!strcmp(str, "auto")) {
889 parport_nr[0] = PPCPIA_PARPORT_AUTO;
890 } else if (!strcmp(str, "none")) {
891 parport_nr[parport_ptr++] = PPCPIA_PARPORT_NONE;
901 __setup("cpia_pp=", cpia_pp_setup);