Merge branch 'suspend' into release
[linux-2.6] / drivers / media / video / cpia_pp.c
1 /*
2  * cpia_pp CPiA Parallel Port driver
3  *
4  * Supports CPiA based parallel port Video Camera's.
5  *
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>
9  *
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.
14  *
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.
19  *
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.
23  */
24
25 /* define _CPIA_DEBUG_ for verbose debug output (see cpia.h) */
26 /* #define _CPIA_DEBUG_  1 */
27
28
29 #include <linux/module.h>
30 #include <linux/init.h>
31
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/sched.h>
38
39 #include <linux/kmod.h>
40
41 /* #define _CPIA_DEBUG_         define for verbose debug output */
42 #include "cpia.h"
43
44 static int cpia_pp_open(void *privdata);
45 static int cpia_pp_registerCallback(void *privdata, void (*cb) (void *cbdata),
46                                     void *cbdata);
47 static int cpia_pp_transferCmd(void *privdata, u8 *command, u8 *data);
48 static int cpia_pp_streamStart(void *privdata);
49 static int cpia_pp_streamStop(void *privdata);
50 static int cpia_pp_streamRead(void *privdata, u8 *buffer, int noblock);
51 static int cpia_pp_close(void *privdata);
52
53
54 #define ABOUT "Parallel port driver for Vision CPiA based cameras"
55
56 #define PACKET_LENGTH  8
57
58 /* Magic numbers for defining port-device mappings */
59 #define PPCPIA_PARPORT_UNSPEC -4
60 #define PPCPIA_PARPORT_AUTO -3
61 #define PPCPIA_PARPORT_OFF -2
62 #define PPCPIA_PARPORT_NONE -1
63
64 static int parport_nr[PARPORT_MAX] = {[0 ... PARPORT_MAX - 1] = PPCPIA_PARPORT_UNSPEC};
65 static char *parport[PARPORT_MAX] = {NULL,};
66
67 MODULE_AUTHOR("B. Huisman <bhuism@cs.utwente.nl> & Peter Pregler <Peter_Pregler@email.com>");
68 MODULE_DESCRIPTION("Parallel port driver for Vision CPiA based cameras");
69 MODULE_LICENSE("GPL");
70
71 module_param_array(parport, charp, NULL, 0);
72 MODULE_PARM_DESC(parport, "'auto' or a list of parallel port numbers. Just like lp.");
73
74 struct pp_cam_entry {
75         struct pardevice *pdev;
76         struct parport *port;
77         struct work_struct cb_task;
78         void (*cb_func)(void *cbdata);
79         void *cb_data;
80         int open_count;
81         wait_queue_head_t wq_stream;
82         /* image state flags */
83         int image_ready;        /* we got an interrupt */
84         int image_complete;     /* we have seen 4 EOI */
85
86         int streaming; /* we are in streaming mode */
87         int stream_irq;
88 };
89
90 static struct cpia_camera_ops cpia_pp_ops =
91 {
92         cpia_pp_open,
93         cpia_pp_registerCallback,
94         cpia_pp_transferCmd,
95         cpia_pp_streamStart,
96         cpia_pp_streamStop,
97         cpia_pp_streamRead,
98         cpia_pp_close,
99         1,
100         THIS_MODULE
101 };
102
103 static LIST_HEAD(cam_list);
104 static spinlock_t cam_list_lock_pp;
105
106 /* FIXME */
107 static void cpia_parport_enable_irq( struct parport *port ) {
108         parport_enable_irq(port);
109         mdelay(10);
110         return;
111 }
112
113 static void cpia_parport_disable_irq( struct parport *port ) {
114         parport_disable_irq(port);
115         mdelay(10);
116         return;
117 }
118
119 /* Special CPiA PPC modes: These are invoked by using the 1284 Extensibility
120  * Link Flag during negotiation */
121 #define UPLOAD_FLAG  0x08
122 #define NIBBLE_TRANSFER 0x01
123 #define ECP_TRANSFER 0x03
124
125 #define PARPORT_CHUNK_SIZE      PAGE_SIZE
126
127
128 static void cpia_pp_run_callback(struct work_struct *work)
129 {
130         void (*cb_func)(void *cbdata);
131         void *cb_data;
132         struct pp_cam_entry *cam;
133
134         cam = container_of(work, struct pp_cam_entry, cb_task);
135         cb_func = cam->cb_func;
136         cb_data = cam->cb_data;
137
138         cb_func(cb_data);
139 }
140
141 /****************************************************************************
142  *
143  *  CPiA-specific  low-level parport functions for nibble uploads
144  *
145  ***************************************************************************/
146 /*  CPiA nonstandard "Nibble" mode (no nDataAvail signal after each byte). */
147 /* The standard kernel parport_ieee1284_read_nibble() fails with the CPiA... */
148
149 static size_t cpia_read_nibble (struct parport *port,
150                          void *buffer, size_t len,
151                          int flags)
152 {
153         /* adapted verbatim, with one change, from
154            parport_ieee1284_read_nibble() in drivers/parport/ieee1284-ops.c */
155
156         unsigned char *buf = buffer;
157         int i;
158         unsigned char byte = 0;
159
160         len *= 2; /* in nibbles */
161         for (i=0; i < len; i++) {
162                 unsigned char nibble;
163
164                 /* The CPiA firmware suppresses the use of nDataAvail (nFault LO)
165                  * after every second nibble to signal that more
166                  * data is available.  (the total number of Bytes that
167                  * should be sent is known; if too few are received, an error
168                  * will be recorded after a timeout).
169                  * This is incompatible with parport_ieee1284_read_nibble(),
170                  * which expects to find nFault LO after every second nibble.
171                  */
172
173                 /* Solution: modify cpia_read_nibble to only check for
174                  * nDataAvail before the first nibble is sent.
175                  */
176
177                 /* Does the error line indicate end of data? */
178                 if (((i /*& 1*/) == 0) &&
179                     (parport_read_status(port) & PARPORT_STATUS_ERROR)) {
180                         DBG("%s: No more nibble data (%d bytes)\n",
181                             port->name, i/2);
182                         goto end_of_data;
183                 }
184
185                 /* Event 7: Set nAutoFd low. */
186                 parport_frob_control (port,
187                                       PARPORT_CONTROL_AUTOFD,
188                                       PARPORT_CONTROL_AUTOFD);
189
190                 /* Event 9: nAck goes low. */
191                 port->ieee1284.phase = IEEE1284_PH_REV_DATA;
192                 if (parport_wait_peripheral (port,
193                                              PARPORT_STATUS_ACK, 0)) {
194                         /* Timeout -- no more data? */
195                                  DBG("%s: Nibble timeout at event 9 (%d bytes)\n",
196                                  port->name, i/2);
197                         parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0);
198                         break;
199                 }
200
201
202                 /* Read a nibble. */
203                 nibble = parport_read_status (port) >> 3;
204                 nibble &= ~8;
205                 if ((nibble & 0x10) == 0)
206                         nibble |= 8;
207                 nibble &= 0xf;
208
209                 /* Event 10: Set nAutoFd high. */
210                 parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0);
211
212                 /* Event 11: nAck goes high. */
213                 if (parport_wait_peripheral (port,
214                                              PARPORT_STATUS_ACK,
215                                              PARPORT_STATUS_ACK)) {
216                         /* Timeout -- no more data? */
217                         DBG("%s: Nibble timeout at event 11\n",
218                                  port->name);
219                         break;
220                 }
221
222                 if (i & 1) {
223                         /* Second nibble */
224                         byte |= nibble << 4;
225                         *buf++ = byte;
226                 } else
227                         byte = nibble;
228         }
229
230         if (i == len) {
231                 /* Read the last nibble without checking data avail. */
232                 if (parport_read_status (port) & PARPORT_STATUS_ERROR) {
233                 end_of_data:
234                         /* Go to reverse idle phase. */
235                         parport_frob_control (port,
236                                               PARPORT_CONTROL_AUTOFD,
237                                               PARPORT_CONTROL_AUTOFD);
238                         port->physport->ieee1284.phase = IEEE1284_PH_REV_IDLE;
239                 }
240                 else
241                         port->physport->ieee1284.phase = IEEE1284_PH_HBUSY_DAVAIL;
242         }
243
244         return i/2;
245 }
246
247 /* CPiA nonstandard "Nibble Stream" mode (2 nibbles per cycle, instead of 1)
248  * (See CPiA Data sheet p. 31)
249  *
250  * "Nibble Stream" mode used by CPiA for uploads to non-ECP ports is a
251  * nonstandard variant of nibble mode which allows the same (mediocre)
252  * data flow of 8 bits per cycle as software-enabled ECP by TRISTATE-capable
253  * parallel ports, but works also for  non-TRISTATE-capable ports.
254  * (Standard nibble mode only send 4 bits per cycle)
255  *
256  */
257
258 static size_t cpia_read_nibble_stream(struct parport *port,
259                                void *buffer, size_t len,
260                                int flags)
261 {
262         int i;
263         unsigned char *buf = buffer;
264         int endseen = 0;
265
266         for (i=0; i < len; i++) {
267                 unsigned char nibble[2], byte = 0;
268                 int j;
269
270                 /* Image Data is complete when 4 consecutive EOI bytes (0xff) are seen */
271                 if (endseen > 3 )
272                         break;
273
274                 /* Event 7: Set nAutoFd low. */
275                 parport_frob_control (port,
276                                       PARPORT_CONTROL_AUTOFD,
277                                       PARPORT_CONTROL_AUTOFD);
278
279                 /* Event 9: nAck goes low. */
280                 port->ieee1284.phase = IEEE1284_PH_REV_DATA;
281                 if (parport_wait_peripheral (port,
282                                              PARPORT_STATUS_ACK, 0)) {
283                         /* Timeout -- no more data? */
284                                  DBG("%s: Nibble timeout at event 9 (%d bytes)\n",
285                                  port->name, i/2);
286                         parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0);
287                         break;
288                 }
289
290                 /* Read lower nibble */
291                 nibble[0] = parport_read_status (port) >>3;
292
293                 /* Event 10: Set nAutoFd high. */
294                 parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0);
295
296                 /* Event 11: nAck goes high. */
297                 if (parport_wait_peripheral (port,
298                                              PARPORT_STATUS_ACK,
299                                              PARPORT_STATUS_ACK)) {
300                         /* Timeout -- no more data? */
301                         DBG("%s: Nibble timeout at event 11\n",
302                                  port->name);
303                         break;
304                 }
305
306                 /* Read upper nibble */
307                 nibble[1] = parport_read_status (port) >>3;
308
309                 /* reassemble the byte */
310                 for (j = 0; j < 2 ; j++ ) {
311                         nibble[j] &= ~8;
312                         if ((nibble[j] & 0x10) == 0)
313                                 nibble[j] |= 8;
314                         nibble[j] &= 0xf;
315                 }
316                 byte = (nibble[0] |(nibble[1] << 4));
317                 *buf++ = byte;
318
319                 if(byte == EOI)
320                   endseen++;
321                 else
322                   endseen = 0;
323         }
324         return i;
325 }
326
327 /****************************************************************************
328  *
329  *  EndTransferMode
330  *
331  ***************************************************************************/
332 static void EndTransferMode(struct pp_cam_entry *cam)
333 {
334         parport_negotiate(cam->port, IEEE1284_MODE_COMPAT);
335 }
336
337 /****************************************************************************
338  *
339  *  ForwardSetup
340  *
341  ***************************************************************************/
342 static int ForwardSetup(struct pp_cam_entry *cam)
343 {
344         int retry;
345
346         /* The CPiA uses ECP protocol for Downloads from the Host to the camera.
347          * This will be software-emulated if ECP hardware is not present
348          */
349
350         /* the usual camera maximum response time is 10ms, but after receiving
351          * some commands, it needs up to 40ms. (Data Sheet p. 32)*/
352
353         for(retry = 0; retry < 4; ++retry) {
354                 if(!parport_negotiate(cam->port, IEEE1284_MODE_ECP)) {
355                         break;
356                 }
357                 mdelay(10);
358         }
359         if(retry == 4) {
360                 DBG("Unable to negotiate IEEE1284 ECP Download mode\n");
361                 return -1;
362         }
363         return 0;
364 }
365 /****************************************************************************
366  *
367  *  ReverseSetup
368  *
369  ***************************************************************************/
370 static int ReverseSetup(struct pp_cam_entry *cam, int extensibility)
371 {
372         int retry;
373         int upload_mode, mode = IEEE1284_MODE_ECP;
374         int transfer_mode = ECP_TRANSFER;
375
376         if (!(cam->port->modes & PARPORT_MODE_ECP) &&
377              !(cam->port->modes & PARPORT_MODE_TRISTATE)) {
378                 mode = IEEE1284_MODE_NIBBLE;
379                 transfer_mode = NIBBLE_TRANSFER;
380         }
381
382         upload_mode = mode;
383         if(extensibility) mode = UPLOAD_FLAG|transfer_mode|IEEE1284_EXT_LINK;
384
385         /* the usual camera maximum response time is 10ms, but after
386          * receiving some commands, it needs up to 40ms. */
387
388         for(retry = 0; retry < 4; ++retry) {
389                 if(!parport_negotiate(cam->port, mode)) {
390                         break;
391                 }
392                 mdelay(10);
393         }
394         if(retry == 4) {
395                 if(extensibility)
396                         DBG("Unable to negotiate upload extensibility mode\n");
397                 else
398                         DBG("Unable to negotiate upload mode\n");
399                 return -1;
400         }
401         if(extensibility) cam->port->ieee1284.mode = upload_mode;
402         return 0;
403 }
404
405 /****************************************************************************
406  *
407  *  WritePacket
408  *
409  ***************************************************************************/
410 static int WritePacket(struct pp_cam_entry *cam, const u8 *packet, size_t size)
411 {
412         int retval=0;
413         int size_written;
414
415         if (packet == NULL) {
416                 return -EINVAL;
417         }
418         if (ForwardSetup(cam)) {
419                 DBG("Write failed in setup\n");
420                 return -EIO;
421         }
422         size_written = parport_write(cam->port, packet, size);
423         if(size_written != size) {
424                 DBG("Write failed, wrote %d/%d\n", size_written, size);
425                 retval = -EIO;
426         }
427         EndTransferMode(cam);
428         return retval;
429 }
430
431 /****************************************************************************
432  *
433  *  ReadPacket
434  *
435  ***************************************************************************/
436 static int ReadPacket(struct pp_cam_entry *cam, u8 *packet, size_t size)
437 {
438         int retval=0;
439
440         if (packet == NULL) {
441                 return -EINVAL;
442         }
443         if (ReverseSetup(cam, 0)) {
444                 return -EIO;
445         }
446
447         /* support for CPiA variant nibble reads */
448         if(cam->port->ieee1284.mode == IEEE1284_MODE_NIBBLE) {
449                 if(cpia_read_nibble(cam->port, packet, size, 0) != size)
450                         retval = -EIO;
451         } else {
452                 if(parport_read(cam->port, packet, size) != size)
453                         retval = -EIO;
454         }
455         EndTransferMode(cam);
456         return retval;
457 }
458
459 /****************************************************************************
460  *
461  *  cpia_pp_streamStart
462  *
463  ***************************************************************************/
464 static int cpia_pp_streamStart(void *privdata)
465 {
466         struct pp_cam_entry *cam = privdata;
467         DBG("\n");
468         cam->streaming=1;
469         cam->image_ready=0;
470         //if (ReverseSetup(cam,1)) return -EIO;
471         if(cam->stream_irq) cpia_parport_enable_irq(cam->port);
472         return 0;
473 }
474
475 /****************************************************************************
476  *
477  *  cpia_pp_streamStop
478  *
479  ***************************************************************************/
480 static int cpia_pp_streamStop(void *privdata)
481 {
482         struct pp_cam_entry *cam = privdata;
483
484         DBG("\n");
485         cam->streaming=0;
486         cpia_parport_disable_irq(cam->port);
487         //EndTransferMode(cam);
488
489         return 0;
490 }
491
492 /****************************************************************************
493  *
494  *  cpia_pp_streamRead
495  *
496  ***************************************************************************/
497 static int cpia_pp_read(struct parport *port, u8 *buffer, int len)
498 {
499         int bytes_read;
500
501         /* support for CPiA variant "nibble stream" reads */
502         if(port->ieee1284.mode == IEEE1284_MODE_NIBBLE)
503                 bytes_read = cpia_read_nibble_stream(port,buffer,len,0);
504         else {
505                 int new_bytes;
506                 for(bytes_read=0; bytes_read<len; bytes_read += new_bytes) {
507                         new_bytes = parport_read(port, buffer+bytes_read,
508                                                  len-bytes_read);
509                         if(new_bytes < 0) break;
510                 }
511         }
512         return bytes_read;
513 }
514
515 static int cpia_pp_streamRead(void *privdata, u8 *buffer, int noblock)
516 {
517         struct pp_cam_entry *cam = privdata;
518         int read_bytes = 0;
519         int i, endseen, block_size, new_bytes;
520
521         if(cam == NULL) {
522                 DBG("Internal driver error: cam is NULL\n");
523                 return -EINVAL;
524         }
525         if(buffer == NULL) {
526                 DBG("Internal driver error: buffer is NULL\n");
527                 return -EINVAL;
528         }
529         //if(cam->streaming) DBG("%d / %d\n", cam->image_ready, noblock);
530         if( cam->stream_irq ) {
531                 DBG("%d\n", cam->image_ready);
532                 cam->image_ready--;
533         }
534         cam->image_complete=0;
535         if (0/*cam->streaming*/) {
536                 if(!cam->image_ready) {
537                         if(noblock) return -EWOULDBLOCK;
538                         interruptible_sleep_on(&cam->wq_stream);
539                         if( signal_pending(current) ) return -EINTR;
540                         DBG("%d\n", cam->image_ready);
541                 }
542         } else {
543                 if (ReverseSetup(cam, 1)) {
544                         DBG("unable to ReverseSetup\n");
545                         return -EIO;
546                 }
547         }
548         endseen = 0;
549         block_size = PARPORT_CHUNK_SIZE;
550         while( !cam->image_complete ) {
551                 cond_resched();
552
553                 new_bytes = cpia_pp_read(cam->port, buffer, block_size );
554                 if( new_bytes <= 0 ) {
555                         break;
556                 }
557                 i=-1;
558                 while(++i<new_bytes && endseen<4) {
559                         if(*buffer==EOI) {
560                                 endseen++;
561                         } else {
562                                 endseen=0;
563                         }
564                         buffer++;
565                 }
566                 read_bytes += i;
567                 if( endseen==4 ) {
568                         cam->image_complete=1;
569                         break;
570                 }
571                 if( CPIA_MAX_IMAGE_SIZE-read_bytes <= PARPORT_CHUNK_SIZE ) {
572                         block_size=CPIA_MAX_IMAGE_SIZE-read_bytes;
573                 }
574         }
575         EndTransferMode(cam);
576         return cam->image_complete ? read_bytes : -EIO;
577 }
578 /****************************************************************************
579  *
580  *  cpia_pp_transferCmd
581  *
582  ***************************************************************************/
583 static int cpia_pp_transferCmd(void *privdata, u8 *command, u8 *data)
584 {
585         int err;
586         int retval=0;
587         int databytes;
588         struct pp_cam_entry *cam = privdata;
589
590         if(cam == NULL) {
591                 DBG("Internal driver error: cam is NULL\n");
592                 return -EINVAL;
593         }
594         if(command == NULL) {
595                 DBG("Internal driver error: command is NULL\n");
596                 return -EINVAL;
597         }
598         databytes = (((int)command[7])<<8) | command[6];
599         if ((err = WritePacket(cam, command, PACKET_LENGTH)) < 0) {
600                 DBG("Error writing command\n");
601                 return err;
602         }
603         if(command[0] == DATA_IN) {
604                 u8 buffer[8];
605                 if(data == NULL) {
606                         DBG("Internal driver error: data is NULL\n");
607                         return -EINVAL;
608                 }
609                 if((err = ReadPacket(cam, buffer, 8)) < 0) {
610                         DBG("Error reading command result\n");
611                        return err;
612                 }
613                 memcpy(data, buffer, databytes);
614         } else if(command[0] == DATA_OUT) {
615                 if(databytes > 0) {
616                         if(data == NULL) {
617                                 DBG("Internal driver error: data is NULL\n");
618                                 retval = -EINVAL;
619                         } else {
620                                 if((err=WritePacket(cam, data, databytes)) < 0){
621                                         DBG("Error writing command data\n");
622                                         return err;
623                                 }
624                         }
625                 }
626         } else {
627                 DBG("Unexpected first byte of command: %x\n", command[0]);
628                 retval = -EINVAL;
629         }
630         return retval;
631 }
632
633 /****************************************************************************
634  *
635  *  cpia_pp_open
636  *
637  ***************************************************************************/
638 static int cpia_pp_open(void *privdata)
639 {
640         struct pp_cam_entry *cam = (struct pp_cam_entry *)privdata;
641
642         if (cam == NULL)
643                 return -EINVAL;
644
645         if(cam->open_count == 0) {
646                 if (parport_claim(cam->pdev)) {
647                         DBG("failed to claim the port\n");
648                         return -EBUSY;
649                 }
650                 parport_negotiate(cam->port, IEEE1284_MODE_COMPAT);
651                 parport_data_forward(cam->port);
652                 parport_write_control(cam->port, PARPORT_CONTROL_SELECT);
653                 udelay(50);
654                 parport_write_control(cam->port,
655                                       PARPORT_CONTROL_SELECT
656                                       | PARPORT_CONTROL_INIT);
657         }
658
659         ++cam->open_count;
660
661         return 0;
662 }
663
664 /****************************************************************************
665  *
666  *  cpia_pp_registerCallback
667  *
668  ***************************************************************************/
669 static int cpia_pp_registerCallback(void *privdata, void (*cb)(void *cbdata), void *cbdata)
670 {
671         struct pp_cam_entry *cam = privdata;
672         int retval = 0;
673
674         if(cam->port->irq != PARPORT_IRQ_NONE) {
675                 cam->cb_func = cb;
676                 cam->cb_data = cbdata;
677                 INIT_WORK(&cam->cb_task, cpia_pp_run_callback);
678         } else {
679                 retval = -1;
680         }
681         return retval;
682 }
683
684 /****************************************************************************
685  *
686  *  cpia_pp_close
687  *
688  ***************************************************************************/
689 static int cpia_pp_close(void *privdata)
690 {
691         struct pp_cam_entry *cam = privdata;
692         if (--cam->open_count == 0) {
693                 parport_release(cam->pdev);
694         }
695         return 0;
696 }
697
698 /****************************************************************************
699  *
700  *  cpia_pp_register
701  *
702  ***************************************************************************/
703 static int cpia_pp_register(struct parport *port)
704 {
705         struct pardevice *pdev = NULL;
706         struct pp_cam_entry *cam;
707         struct cam_data *cpia;
708
709         if (!(port->modes & PARPORT_MODE_PCSPP)) {
710                 LOG("port is not supported by CPiA driver\n");
711                 return -ENXIO;
712         }
713
714         cam = kzalloc(sizeof(struct pp_cam_entry), GFP_KERNEL);
715         if (cam == NULL) {
716                 LOG("failed to allocate camera structure\n");
717                 return -ENOMEM;
718         }
719
720         pdev = parport_register_device(port, "cpia_pp", NULL, NULL,
721                                        NULL, 0, cam);
722
723         if (!pdev) {
724                 LOG("failed to parport_register_device\n");
725                 kfree(cam);
726                 return -ENXIO;
727         }
728
729         cam->pdev = pdev;
730         cam->port = port;
731         init_waitqueue_head(&cam->wq_stream);
732
733         cam->streaming = 0;
734         cam->stream_irq = 0;
735
736         if((cpia = cpia_register_camera(&cpia_pp_ops, cam)) == NULL) {
737                 LOG("failed to cpia_register_camera\n");
738                 parport_unregister_device(pdev);
739                 kfree(cam);
740                 return -ENXIO;
741         }
742         spin_lock( &cam_list_lock_pp );
743         list_add( &cpia->cam_data_list, &cam_list );
744         spin_unlock( &cam_list_lock_pp );
745
746         return 0;
747 }
748
749 static void cpia_pp_detach (struct parport *port)
750 {
751         struct list_head *tmp;
752         struct cam_data *cpia = NULL;
753         struct pp_cam_entry *cam;
754
755         spin_lock( &cam_list_lock_pp );
756         list_for_each (tmp, &cam_list) {
757                 cpia = list_entry(tmp, struct cam_data, cam_data_list);
758                 cam = (struct pp_cam_entry *) cpia->lowlevel_data;
759                 if (cam && cam->port->number == port->number) {
760                         list_del(&cpia->cam_data_list);
761                         break;
762                 }
763                 cpia = NULL;
764         }
765         spin_unlock( &cam_list_lock_pp );
766
767         if (!cpia) {
768                 DBG("cpia_pp_detach failed to find cam_data in cam_list\n");
769                 return;
770         }
771
772         cam = (struct pp_cam_entry *) cpia->lowlevel_data;
773         cpia_unregister_camera(cpia);
774         if(cam->open_count > 0)
775                 cpia_pp_close(cam);
776         parport_unregister_device(cam->pdev);
777         cpia->lowlevel_data = NULL;
778         kfree(cam);
779 }
780
781 static void cpia_pp_attach (struct parport *port)
782 {
783         unsigned int i;
784
785         switch (parport_nr[0])
786         {
787         case PPCPIA_PARPORT_UNSPEC:
788         case PPCPIA_PARPORT_AUTO:
789                 if (port->probe_info[0].class != PARPORT_CLASS_MEDIA ||
790                     port->probe_info[0].cmdset == NULL ||
791                     strncmp(port->probe_info[0].cmdset, "CPIA_1", 6) != 0)
792                         return;
793
794                 cpia_pp_register(port);
795
796                 break;
797
798         default:
799                 for (i = 0; i < PARPORT_MAX; ++i) {
800                         if (port->number == parport_nr[i]) {
801                                 cpia_pp_register(port);
802                                 break;
803                         }
804                 }
805                 break;
806         }
807 }
808
809 static struct parport_driver cpia_pp_driver = {
810         .name = "cpia_pp",
811         .attach = cpia_pp_attach,
812         .detach = cpia_pp_detach,
813 };
814
815 static int __init cpia_pp_init(void)
816 {
817         printk(KERN_INFO "%s v%d.%d.%d\n",ABOUT,
818                CPIA_PP_MAJ_VER,CPIA_PP_MIN_VER,CPIA_PP_PATCH_VER);
819
820         if(parport_nr[0] == PPCPIA_PARPORT_OFF) {
821                 printk("  disabled\n");
822                 return 0;
823         }
824
825         spin_lock_init( &cam_list_lock_pp );
826
827         if (parport_register_driver (&cpia_pp_driver)) {
828                 LOG ("unable to register with parport\n");
829                 return -EIO;
830         }
831         return 0;
832 }
833
834 static int __init cpia_init(void)
835 {
836         if (parport[0]) {
837                 /* The user gave some parameters.  Let's see what they were. */
838                 if (!strncmp(parport[0], "auto", 4)) {
839                         parport_nr[0] = PPCPIA_PARPORT_AUTO;
840                 } else {
841                         int n;
842                         for (n = 0; n < PARPORT_MAX && parport[n]; n++) {
843                                 if (!strncmp(parport[n], "none", 4)) {
844                                         parport_nr[n] = PPCPIA_PARPORT_NONE;
845                                 } else {
846                                         char *ep;
847                                         unsigned long r = simple_strtoul(parport[n], &ep, 0);
848                                         if (ep != parport[n]) {
849                                                 parport_nr[n] = r;
850                                         } else {
851                                                 LOG("bad port specifier `%s'\n", parport[n]);
852                                                 return -ENODEV;
853                                         }
854                                 }
855                         }
856                 }
857         }
858         return cpia_pp_init();
859 }
860
861 static void __exit cpia_cleanup(void)
862 {
863         parport_unregister_driver(&cpia_pp_driver);
864         return;
865 }
866
867 module_init(cpia_init);
868 module_exit(cpia_cleanup);