OpenCores
URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [media/] [video/] [cpia_pp.c] - Blame information for rev 62

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 62 marcus.erl
/*
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);

powered by: WebSVN 2.1.0

© copyright 1999-2025 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.