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