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
;
86 wait_queue_head_t wq_stream
;
87 /* image state flags */
88 int image_ready
; /* we got an interrupt */
89 int image_complete
; /* we have seen 4 EOI */
91 int streaming
; /* we are in streaming mode */
95 static struct cpia_camera_ops cpia_pp_ops
=
98 cpia_pp_registerCallback
,
108 static LIST_HEAD(cam_list
);
109 static spinlock_t cam_list_lock_pp
;
112 static void cpia_parport_enable_irq( struct parport
*port
) {
113 parport_enable_irq(port
);
118 static void cpia_parport_disable_irq( struct parport
*port
) {
119 parport_disable_irq(port
);
124 /* Special CPiA PPC modes: These are invoked by using the 1284 Extensibility
125 * Link Flag during negotiation */
126 #define UPLOAD_FLAG 0x08
127 #define NIBBLE_TRANSFER 0x01
128 #define ECP_TRANSFER 0x03
130 #define PARPORT_CHUNK_SIZE PAGE_SIZE
133 /****************************************************************************
135 * CPiA-specific low-level parport functions for nibble uploads
137 ***************************************************************************/
138 /* CPiA nonstandard "Nibble" mode (no nDataAvail signal after each byte). */
139 /* The standard kernel parport_ieee1284_read_nibble() fails with the CPiA... */
141 static size_t cpia_read_nibble (struct parport
*port
,
142 void *buffer
, size_t len
,
145 /* adapted verbatim, with one change, from
146 parport_ieee1284_read_nibble() in drivers/parport/ieee1284-ops.c */
148 unsigned char *buf
= buffer
;
150 unsigned char byte
= 0;
152 len
*= 2; /* in nibbles */
153 for (i
=0; i
< len
; i
++) {
154 unsigned char nibble
;
156 /* The CPiA firmware suppresses the use of nDataAvail (nFault LO)
157 * after every second nibble to signal that more
158 * data is available. (the total number of Bytes that
159 * should be sent is known; if too few are received, an error
160 * will be recorded after a timeout).
161 * This is incompatible with parport_ieee1284_read_nibble(),
162 * which expects to find nFault LO after every second nibble.
165 /* Solution: modify cpia_read_nibble to only check for
166 * nDataAvail before the first nibble is sent.
169 /* Does the error line indicate end of data? */
170 if (((i
/*& 1*/) == 0) &&
171 (parport_read_status(port
) & PARPORT_STATUS_ERROR
)) {
172 DBG("%s: No more nibble data (%d bytes)\n",
177 /* Event 7: Set nAutoFd low. */
178 parport_frob_control (port
,
179 PARPORT_CONTROL_AUTOFD
,
180 PARPORT_CONTROL_AUTOFD
);
182 /* Event 9: nAck goes low. */
183 port
->ieee1284
.phase
= IEEE1284_PH_REV_DATA
;
184 if (parport_wait_peripheral (port
,
185 PARPORT_STATUS_ACK
, 0)) {
186 /* Timeout -- no more data? */
187 DBG("%s: Nibble timeout at event 9 (%d bytes)\n",
189 parport_frob_control (port
, PARPORT_CONTROL_AUTOFD
, 0);
195 nibble
= parport_read_status (port
) >> 3;
197 if ((nibble
& 0x10) == 0)
201 /* Event 10: Set nAutoFd high. */
202 parport_frob_control (port
, PARPORT_CONTROL_AUTOFD
, 0);
204 /* Event 11: nAck goes high. */
205 if (parport_wait_peripheral (port
,
207 PARPORT_STATUS_ACK
)) {
208 /* Timeout -- no more data? */
209 DBG("%s: Nibble timeout at event 11\n",
223 /* Read the last nibble without checking data avail. */
224 if (parport_read_status (port
) & PARPORT_STATUS_ERROR
) {
226 /* Go to reverse idle phase. */
227 parport_frob_control (port
,
228 PARPORT_CONTROL_AUTOFD
,
229 PARPORT_CONTROL_AUTOFD
);
230 port
->physport
->ieee1284
.phase
= IEEE1284_PH_REV_IDLE
;
233 port
->physport
->ieee1284
.phase
= IEEE1284_PH_HBUSY_DAVAIL
;
239 /* CPiA nonstandard "Nibble Stream" mode (2 nibbles per cycle, instead of 1)
240 * (See CPiA Data sheet p. 31)
242 * "Nibble Stream" mode used by CPiA for uploads to non-ECP ports is a
243 * nonstandard variant of nibble mode which allows the same (mediocre)
244 * data flow of 8 bits per cycle as software-enabled ECP by TRISTATE-capable
245 * parallel ports, but works also for non-TRISTATE-capable ports.
246 * (Standard nibble mode only send 4 bits per cycle)
250 static size_t cpia_read_nibble_stream(struct parport
*port
,
251 void *buffer
, size_t len
,
255 unsigned char *buf
= buffer
;
258 for (i
=0; i
< len
; i
++) {
259 unsigned char nibble
[2], byte
= 0;
262 /* Image Data is complete when 4 consecutive EOI bytes (0xff) are seen */
266 /* Event 7: Set nAutoFd low. */
267 parport_frob_control (port
,
268 PARPORT_CONTROL_AUTOFD
,
269 PARPORT_CONTROL_AUTOFD
);
271 /* Event 9: nAck goes low. */
272 port
->ieee1284
.phase
= IEEE1284_PH_REV_DATA
;
273 if (parport_wait_peripheral (port
,
274 PARPORT_STATUS_ACK
, 0)) {
275 /* Timeout -- no more data? */
276 DBG("%s: Nibble timeout at event 9 (%d bytes)\n",
278 parport_frob_control (port
, PARPORT_CONTROL_AUTOFD
, 0);
282 /* Read lower nibble */
283 nibble
[0] = parport_read_status (port
) >>3;
285 /* Event 10: Set nAutoFd high. */
286 parport_frob_control (port
, PARPORT_CONTROL_AUTOFD
, 0);
288 /* Event 11: nAck goes high. */
289 if (parport_wait_peripheral (port
,
291 PARPORT_STATUS_ACK
)) {
292 /* Timeout -- no more data? */
293 DBG("%s: Nibble timeout at event 11\n",
298 /* Read upper nibble */
299 nibble
[1] = parport_read_status (port
) >>3;
301 /* reassemble the byte */
302 for (j
= 0; j
< 2 ; j
++ ) {
304 if ((nibble
[j
] & 0x10) == 0)
308 byte
= (nibble
[0] |(nibble
[1] << 4));
319 /****************************************************************************
323 ***************************************************************************/
324 static void EndTransferMode(struct pp_cam_entry
*cam
)
326 parport_negotiate(cam
->port
, IEEE1284_MODE_COMPAT
);
329 /****************************************************************************
333 ***************************************************************************/
334 static int ForwardSetup(struct pp_cam_entry
*cam
)
338 /* The CPiA uses ECP protocol for Downloads from the Host to the camera.
339 * This will be software-emulated if ECP hardware is not present
342 /* the usual camera maximum response time is 10ms, but after receiving
343 * some commands, it needs up to 40ms. (Data Sheet p. 32)*/
345 for(retry
= 0; retry
< 4; ++retry
) {
346 if(!parport_negotiate(cam
->port
, IEEE1284_MODE_ECP
)) {
352 DBG("Unable to negotiate IEEE1284 ECP Download mode\n");
357 /****************************************************************************
361 ***************************************************************************/
362 static int ReverseSetup(struct pp_cam_entry
*cam
, int extensibility
)
365 int upload_mode
, mode
= IEEE1284_MODE_ECP
;
366 int transfer_mode
= ECP_TRANSFER
;
368 if (!(cam
->port
->modes
& PARPORT_MODE_ECP
) &&
369 !(cam
->port
->modes
& PARPORT_MODE_TRISTATE
)) {
370 mode
= IEEE1284_MODE_NIBBLE
;
371 transfer_mode
= NIBBLE_TRANSFER
;
375 if(extensibility
) mode
= UPLOAD_FLAG
|transfer_mode
|IEEE1284_EXT_LINK
;
377 /* the usual camera maximum response time is 10ms, but after
378 * receiving some commands, it needs up to 40ms. */
380 for(retry
= 0; retry
< 4; ++retry
) {
381 if(!parport_negotiate(cam
->port
, mode
)) {
388 DBG("Unable to negotiate upload extensibility mode\n");
390 DBG("Unable to negotiate upload mode\n");
393 if(extensibility
) cam
->port
->ieee1284
.mode
= upload_mode
;
397 /****************************************************************************
401 ***************************************************************************/
402 static int WritePacket(struct pp_cam_entry
*cam
, const u8
*packet
, size_t size
)
407 if (packet
== NULL
) {
410 if (ForwardSetup(cam
)) {
411 DBG("Write failed in setup\n");
414 size_written
= parport_write(cam
->port
, packet
, size
);
415 if(size_written
!= size
) {
416 DBG("Write failed, wrote %d/%d\n", size_written
, size
);
419 EndTransferMode(cam
);
423 /****************************************************************************
427 ***************************************************************************/
428 static int ReadPacket(struct pp_cam_entry
*cam
, u8
*packet
, size_t size
)
432 if (packet
== NULL
) {
435 if (ReverseSetup(cam
, 0)) {
439 /* support for CPiA variant nibble reads */
440 if(cam
->port
->ieee1284
.mode
== IEEE1284_MODE_NIBBLE
) {
441 if(cpia_read_nibble(cam
->port
, packet
, size
, 0) != size
)
444 if(parport_read(cam
->port
, packet
, size
) != size
)
447 EndTransferMode(cam
);
451 /****************************************************************************
453 * cpia_pp_streamStart
455 ***************************************************************************/
456 static int cpia_pp_streamStart(void *privdata
)
458 struct pp_cam_entry
*cam
= privdata
;
462 //if (ReverseSetup(cam,1)) return -EIO;
463 if(cam
->stream_irq
) cpia_parport_enable_irq(cam
->port
);
467 /****************************************************************************
471 ***************************************************************************/
472 static int cpia_pp_streamStop(void *privdata
)
474 struct pp_cam_entry
*cam
= privdata
;
478 cpia_parport_disable_irq(cam
->port
);
479 //EndTransferMode(cam);
484 /****************************************************************************
488 ***************************************************************************/
489 static int cpia_pp_read(struct parport
*port
, u8
*buffer
, int len
)
493 /* support for CPiA variant "nibble stream" reads */
494 if(port
->ieee1284
.mode
== IEEE1284_MODE_NIBBLE
)
495 bytes_read
= cpia_read_nibble_stream(port
,buffer
,len
,0);
498 for(bytes_read
=0; bytes_read
<len
; bytes_read
+= new_bytes
) {
499 new_bytes
= parport_read(port
, buffer
+bytes_read
,
501 if(new_bytes
< 0) break;
507 static int cpia_pp_streamRead(void *privdata
, u8
*buffer
, int noblock
)
509 struct pp_cam_entry
*cam
= privdata
;
511 int i
, endseen
, block_size
, new_bytes
;
514 DBG("Internal driver error: cam is NULL\n");
518 DBG("Internal driver error: buffer is NULL\n");
521 //if(cam->streaming) DBG("%d / %d\n", cam->image_ready, noblock);
522 if( cam
->stream_irq
) {
523 DBG("%d\n", cam
->image_ready
);
526 cam
->image_complete
=0;
527 if (0/*cam->streaming*/) {
528 if(!cam
->image_ready
) {
529 if(noblock
) return -EWOULDBLOCK
;
530 interruptible_sleep_on(&cam
->wq_stream
);
531 if( signal_pending(current
) ) return -EINTR
;
532 DBG("%d\n", cam
->image_ready
);
535 if (ReverseSetup(cam
, 1)) {
536 DBG("unable to ReverseSetup\n");
541 block_size
= PARPORT_CHUNK_SIZE
;
542 while( !cam
->image_complete
) {
545 new_bytes
= cpia_pp_read(cam
->port
, buffer
, block_size
);
546 if( new_bytes
<= 0 ) {
550 while(++i
<new_bytes
&& endseen
<4) {
560 cam
->image_complete
=1;
563 if( CPIA_MAX_IMAGE_SIZE
-read_bytes
<= PARPORT_CHUNK_SIZE
) {
564 block_size
=CPIA_MAX_IMAGE_SIZE
-read_bytes
;
567 EndTransferMode(cam
);
568 return cam
->image_complete
? read_bytes
: -EIO
;
570 /****************************************************************************
572 * cpia_pp_transferCmd
574 ***************************************************************************/
575 static int cpia_pp_transferCmd(void *privdata
, u8
*command
, u8
*data
)
580 struct pp_cam_entry
*cam
= privdata
;
583 DBG("Internal driver error: cam is NULL\n");
586 if(command
== NULL
) {
587 DBG("Internal driver error: command is NULL\n");
590 databytes
= (((int)command
[7])<<8) | command
[6];
591 if ((err
= WritePacket(cam
, command
, PACKET_LENGTH
)) < 0) {
592 DBG("Error writing command\n");
595 if(command
[0] == DATA_IN
) {
598 DBG("Internal driver error: data is NULL\n");
601 if((err
= ReadPacket(cam
, buffer
, 8)) < 0) {
602 DBG("Error reading command result\n");
605 memcpy(data
, buffer
, databytes
);
606 } else if(command
[0] == DATA_OUT
) {
609 DBG("Internal driver error: data is NULL\n");
612 if((err
=WritePacket(cam
, data
, databytes
)) < 0){
613 DBG("Error writing command data\n");
619 DBG("Unexpected first byte of command: %x\n", command
[0]);
625 /****************************************************************************
629 ***************************************************************************/
630 static int cpia_pp_open(void *privdata
)
632 struct pp_cam_entry
*cam
= (struct pp_cam_entry
*)privdata
;
637 if(cam
->open_count
== 0) {
638 if (parport_claim(cam
->pdev
)) {
639 DBG("failed to claim the port\n");
642 parport_negotiate(cam
->port
, IEEE1284_MODE_COMPAT
);
643 parport_data_forward(cam
->port
);
644 parport_write_control(cam
->port
, PARPORT_CONTROL_SELECT
);
646 parport_write_control(cam
->port
,
647 PARPORT_CONTROL_SELECT
648 | PARPORT_CONTROL_INIT
);
656 /****************************************************************************
658 * cpia_pp_registerCallback
660 ***************************************************************************/
661 static int cpia_pp_registerCallback(void *privdata
, void (*cb
)(void *cbdata
), void *cbdata
)
663 struct pp_cam_entry
*cam
= privdata
;
666 if(cam
->port
->irq
!= PARPORT_IRQ_NONE
) {
667 INIT_WORK(&cam
->cb_task
, cb
, cbdata
);
674 /****************************************************************************
678 ***************************************************************************/
679 static int cpia_pp_close(void *privdata
)
681 struct pp_cam_entry
*cam
= privdata
;
682 if (--cam
->open_count
== 0) {
683 parport_release(cam
->pdev
);
688 /****************************************************************************
692 ***************************************************************************/
693 static int cpia_pp_register(struct parport
*port
)
695 struct pardevice
*pdev
= NULL
;
696 struct pp_cam_entry
*cam
;
697 struct cam_data
*cpia
;
699 if (!(port
->modes
& PARPORT_MODE_PCSPP
)) {
700 LOG("port is not supported by CPiA driver\n");
704 cam
= kzalloc(sizeof(struct pp_cam_entry
), GFP_KERNEL
);
706 LOG("failed to allocate camera structure\n");
710 pdev
= parport_register_device(port
, "cpia_pp", NULL
, NULL
,
714 LOG("failed to parport_register_device\n");
721 init_waitqueue_head(&cam
->wq_stream
);
726 if((cpia
= cpia_register_camera(&cpia_pp_ops
, cam
)) == NULL
) {
727 LOG("failed to cpia_register_camera\n");
728 parport_unregister_device(pdev
);
732 spin_lock( &cam_list_lock_pp
);
733 list_add( &cpia
->cam_data_list
, &cam_list
);
734 spin_unlock( &cam_list_lock_pp
);
739 static void cpia_pp_detach (struct parport
*port
)
741 struct list_head
*tmp
;
742 struct cam_data
*cpia
= NULL
;
743 struct pp_cam_entry
*cam
;
745 spin_lock( &cam_list_lock_pp
);
746 list_for_each (tmp
, &cam_list
) {
747 cpia
= list_entry(tmp
, struct cam_data
, cam_data_list
);
748 cam
= (struct pp_cam_entry
*) cpia
->lowlevel_data
;
749 if (cam
&& cam
->port
->number
== port
->number
) {
750 list_del(&cpia
->cam_data_list
);
755 spin_unlock( &cam_list_lock_pp
);
758 DBG("cpia_pp_detach failed to find cam_data in cam_list\n");
762 cam
= (struct pp_cam_entry
*) cpia
->lowlevel_data
;
763 cpia_unregister_camera(cpia
);
764 if(cam
->open_count
> 0)
766 parport_unregister_device(cam
->pdev
);
767 cpia
->lowlevel_data
= NULL
;
771 static void cpia_pp_attach (struct parport
*port
)
775 switch (parport_nr
[0])
777 case PPCPIA_PARPORT_UNSPEC
:
778 case PPCPIA_PARPORT_AUTO
:
779 if (port
->probe_info
[0].class != PARPORT_CLASS_MEDIA
||
780 port
->probe_info
[0].cmdset
== NULL
||
781 strncmp(port
->probe_info
[0].cmdset
, "CPIA_1", 6) != 0)
784 cpia_pp_register(port
);
789 for (i
= 0; i
< PARPORT_MAX
; ++i
) {
790 if (port
->number
== parport_nr
[i
]) {
791 cpia_pp_register(port
);
799 static struct parport_driver cpia_pp_driver
= {
801 .attach
= cpia_pp_attach
,
802 .detach
= cpia_pp_detach
,
805 static int cpia_pp_init(void)
807 printk(KERN_INFO
"%s v%d.%d.%d\n",ABOUT
,
808 CPIA_PP_MAJ_VER
,CPIA_PP_MIN_VER
,CPIA_PP_PATCH_VER
);
810 if(parport_nr
[0] == PPCPIA_PARPORT_OFF
) {
811 printk(" disabled\n");
815 spin_lock_init( &cam_list_lock_pp
);
817 if (parport_register_driver (&cpia_pp_driver
)) {
818 LOG ("unable to register with parport\n");
825 int init_module(void)
828 /* The user gave some parameters. Let's see what they were. */
829 if (!strncmp(parport
[0], "auto", 4)) {
830 parport_nr
[0] = PPCPIA_PARPORT_AUTO
;
833 for (n
= 0; n
< PARPORT_MAX
&& parport
[n
]; n
++) {
834 if (!strncmp(parport
[n
], "none", 4)) {
835 parport_nr
[n
] = PPCPIA_PARPORT_NONE
;
838 unsigned long r
= simple_strtoul(parport
[n
], &ep
, 0);
839 if (ep
!= parport
[n
]) {
842 LOG("bad port specifier `%s'\n", parport
[n
]);
849 return cpia_pp_init();
852 void cleanup_module(void)
854 parport_unregister_driver (&cpia_pp_driver
);
860 static int __init
cpia_pp_setup(char *str
)
864 if (!strncmp(str
, "parport", 7)) {
865 int n
= simple_strtoul(str
+ 7, NULL
, 10);
866 if (parport_ptr
< PARPORT_MAX
) {
867 parport_nr
[parport_ptr
++] = n
;
869 LOG("too many ports, %s ignored.\n", str
);
871 } else if (!strcmp(str
, "auto")) {
872 parport_nr
[0] = PPCPIA_PARPORT_AUTO
;
873 } else if (!strcmp(str
, "none")) {
874 parport_nr
[parport_ptr
++] = PPCPIA_PARPORT_NONE
;
884 __setup("cpia_pp=", cpia_pp_setup
);