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