?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Committer: Michael Beasley <mike@snafu.setup>
[mikesnafu-overlay.git] / drivers / media / video / cpia_pp.c
blobc431df8248d659199c66da758e6afcd35a918575
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);
mah project overlay