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