Linux-2.6.12-rc2v2.6.12-rc2

Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.

Let it rip!

1 files changed, 886 insertions, 0 deletions

diff --git a/drivers/media/video/cpia_pp.c b/drivers/media/video/cpia_pp.c
new file mode 100644
index 000000000000..ddf184f95d80
--- /dev/null
+++ b/drivers/media/video/cpia_pp.c
@@ -0,0 +1,886 @@
+/*
+ * cpia_pp CPiA Parallel Port driver
+ *
+ * Supports CPiA based parallel port Video Camera's.
+ *
+ * (C) Copyright 1999 Bas Huisman <bhuism@cs.utwente.nl>
+ * (C) Copyright 1999-2000 Scott J. Bertin <sbertin@securenym.net>,
+ * (C) Copyright 1999-2000 Peter Pregler <Peter_Pregler@email.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/* define _CPIA_DEBUG_ for verbose debug output (see cpia.h) */
+/* #define _CPIA_DEBUG_  1 */  
+
+#include <linux/config.h>
+
+#include <linux/module.h>
+#include <linux/init.h>
+
+#include <linux/kernel.h>
+#include <linux/parport.h>
+#include <linux/interrupt.h>
+#include <linux/delay.h>
+#include <linux/workqueue.h>
+#include <linux/smp_lock.h>
+#include <linux/sched.h>
+
+#include <linux/kmod.h>
+
+/* #define _CPIA_DEBUG_         define for verbose debug output */
+#include "cpia.h"
+
+static int cpia_pp_open(void *privdata);
+static int cpia_pp_registerCallback(void *privdata, void (*cb) (void *cbdata),
+                                    void *cbdata);
+static int cpia_pp_transferCmd(void *privdata, u8 *command, u8 *data);
+static int cpia_pp_streamStart(void *privdata);
+static int cpia_pp_streamStop(void *privdata);
+static int cpia_pp_streamRead(void *privdata, u8 *buffer, int noblock);
+static int cpia_pp_close(void *privdata);
+
+
+#define ABOUT "Parallel port driver for Vision CPiA based cameras"
+
+#define PACKET_LENGTH  8
+
+/* Magic numbers for defining port-device mappings */
+#define PPCPIA_PARPORT_UNSPEC -4
+#define PPCPIA_PARPORT_AUTO -3
+#define PPCPIA_PARPORT_OFF -2
+#define PPCPIA_PARPORT_NONE -1
+
+#ifdef MODULE
+static int parport_nr[PARPORT_MAX] = {[0 ... PARPORT_MAX - 1] = PPCPIA_PARPORT_UNSPEC};
+static char *parport[PARPORT_MAX] = {NULL,};
+
+MODULE_AUTHOR("B. Huisman <bhuism@cs.utwente.nl> & Peter Pregler <Peter_Pregler@email.com>");
+MODULE_DESCRIPTION("Parallel port driver for Vision CPiA based cameras");
+MODULE_LICENSE("GPL");
+
+module_param_array(parport, charp, NULL, 0);
+MODULE_PARM_DESC(parport, "'auto' or a list of parallel port numbers. Just like lp.");
+#else
+static int parport_nr[PARPORT_MAX] __initdata =
+        {[0 ... PARPORT_MAX - 1] = PPCPIA_PARPORT_UNSPEC};
+static int parport_ptr = 0;
+#endif
+
+struct pp_cam_entry {
+        struct pardevice *pdev;
+        struct parport *port;
+        struct work_struct cb_task;
+        int open_count;
+        wait_queue_head_t wq_stream;
+        /* image state flags */
+        int image_ready;        /* we got an interrupt */
+        int image_complete;     /* we have seen 4 EOI */
+
+        int streaming; /* we are in streaming mode */
+        int stream_irq;
+};
+
+static struct cpia_camera_ops cpia_pp_ops = 
+{
+        cpia_pp_open,
+        cpia_pp_registerCallback,
+        cpia_pp_transferCmd,
+        cpia_pp_streamStart,
+        cpia_pp_streamStop,
+        cpia_pp_streamRead,
+        cpia_pp_close,
+        1,
+        THIS_MODULE
+};
+
+static LIST_HEAD(cam_list);
+static spinlock_t cam_list_lock_pp;
+
+/* FIXME */
+static void cpia_parport_enable_irq( struct parport *port ) {
+        parport_enable_irq(port);
+        mdelay(10);
+        return;
+}
+
+static void cpia_parport_disable_irq( struct parport *port ) {
+        parport_disable_irq(port);
+        mdelay(10);
+        return;
+}
+
+/* Special CPiA PPC modes: These are invoked by using the 1284 Extensibility
+ * Link Flag during negotiation */  
+#define UPLOAD_FLAG  0x08
+#define NIBBLE_TRANSFER 0x01
+#define ECP_TRANSFER 0x03
+
+#define PARPORT_CHUNK_SIZE      PAGE_SIZE
+
+
+/****************************************************************************
+ *
+ *  CPiA-specific  low-level parport functions for nibble uploads
+ *
+ ***************************************************************************/
+/*  CPiA nonstandard "Nibble" mode (no nDataAvail signal after each byte). */
+/* The standard kernel parport_ieee1284_read_nibble() fails with the CPiA... */
+
+static size_t cpia_read_nibble (struct parport *port, 
+                         void *buffer, size_t len, 
+                         int flags)
+{
+        /* adapted verbatim, with one change, from 
+           parport_ieee1284_read_nibble() in drivers/parport/ieee1284-ops.c */
+
+        unsigned char *buf = buffer;
+        int i;
+        unsigned char byte = 0;
+        
+        len *= 2; /* in nibbles */
+        for (i=0; i < len; i++) {
+                unsigned char nibble;
+
+                /* The CPiA firmware suppresses the use of nDataAvail (nFault LO)
+                 * after every second nibble to signal that more
+                 * data is available.  (the total number of Bytes that
+                 * should be sent is known; if too few are received, an error
+                 * will be recorded after a timeout).  
+                 * This is incompatible with parport_ieee1284_read_nibble(),
+                 * which expects to find nFault LO after every second nibble.
+                 */
+
+                /* Solution: modify cpia_read_nibble to only check for 
+                 * nDataAvail before the first nibble is sent.
+                 */
+
+                /* Does the error line indicate end of data? */
+                if (((i /*& 1*/) == 0) &&
+                    (parport_read_status(port) & PARPORT_STATUS_ERROR)) {
+                        port->physport->ieee1284.phase = IEEE1284_PH_HBUSY_DNA;
+                                DBG("%s: No more nibble data (%d bytes)\n",
+                                port->name, i/2);
+
+                        /* Go to reverse idle phase. */
+                        parport_frob_control (port,
+                                              PARPORT_CONTROL_AUTOFD,
+                                              PARPORT_CONTROL_AUTOFD);
+                        port->physport->ieee1284.phase = IEEE1284_PH_REV_IDLE;
+                        break;
+                }
+
+                /* Event 7: Set nAutoFd low. */
+                parport_frob_control (port,
+                                      PARPORT_CONTROL_AUTOFD,
+                                      PARPORT_CONTROL_AUTOFD);
+
+                /* Event 9: nAck goes low. */
+                port->ieee1284.phase = IEEE1284_PH_REV_DATA;
+                if (parport_wait_peripheral (port,
+                                             PARPORT_STATUS_ACK, 0)) {
+                        /* Timeout -- no more data? */
+                                 DBG("%s: Nibble timeout at event 9 (%d bytes)\n",
+                                 port->name, i/2);
+                        parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0);
+                        break;
+                }
+
+
+                /* Read a nibble. */
+                nibble = parport_read_status (port) >> 3;
+                nibble &= ~8;
+                if ((nibble & 0x10) == 0)
+                        nibble |= 8;
+                nibble &= 0xf;
+
+                /* Event 10: Set nAutoFd high. */
+                parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0);
+
+                /* Event 11: nAck goes high. */
+                if (parport_wait_peripheral (port,
+                                             PARPORT_STATUS_ACK,
+                                             PARPORT_STATUS_ACK)) {
+                        /* Timeout -- no more data? */
+                        DBG("%s: Nibble timeout at event 11\n",
+                                 port->name);
+                        break;
+                }
+
+                if (i & 1) {
+                        /* Second nibble */
+                        byte |= nibble << 4;
+                        *buf++ = byte;
+                } else 
+                        byte = nibble;
+        }
+
+        i /= 2; /* i is now in bytes */
+
+        if (i == len) {
+                /* Read the last nibble without checking data avail. */
+                port = port->physport;
+                if (parport_read_status (port) & PARPORT_STATUS_ERROR)
+                        port->ieee1284.phase = IEEE1284_PH_HBUSY_DNA;
+                else
+                        port->ieee1284.phase = IEEE1284_PH_HBUSY_DAVAIL;
+        }
+
+        return i;
+}
+
+/* CPiA nonstandard "Nibble Stream" mode (2 nibbles per cycle, instead of 1)
+ * (See CPiA Data sheet p. 31) 
+ * 
+ * "Nibble Stream" mode used by CPiA for uploads to non-ECP ports is a 
+ * nonstandard variant of nibble mode which allows the same (mediocre) 
+ * data flow of 8 bits per cycle as software-enabled ECP by TRISTATE-capable 
+ * parallel ports, but works also for  non-TRISTATE-capable ports.
+ * (Standard nibble mode only send 4 bits per cycle)
+ *
+ */
+
+static size_t cpia_read_nibble_stream(struct parport *port, 
+                               void *buffer, size_t len, 
+                               int flags)
+{
+        int i;
+        unsigned char *buf = buffer;
+        int endseen = 0;
+
+        for (i=0; i < len; i++) {
+                unsigned char nibble[2], byte = 0;
+                int j;
+
+                /* Image Data is complete when 4 consecutive EOI bytes (0xff) are seen */ 
+                if (endseen > 3 )
+                        break;
+
+                /* Event 7: Set nAutoFd low. */
+                parport_frob_control (port,
+                                      PARPORT_CONTROL_AUTOFD,
+                                      PARPORT_CONTROL_AUTOFD);
+                
+                /* Event 9: nAck goes low. */
+                port->ieee1284.phase = IEEE1284_PH_REV_DATA;
+                if (parport_wait_peripheral (port,
+                                             PARPORT_STATUS_ACK, 0)) {
+                        /* Timeout -- no more data? */
+                                 DBG("%s: Nibble timeout at event 9 (%d bytes)\n",
+                                 port->name, i/2);
+                        parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0);
+                        break;
+                }
+
+                /* Read lower nibble */
+                nibble[0] = parport_read_status (port) >>3;
+                
+                /* Event 10: Set nAutoFd high. */
+                parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0);
+
+                /* Event 11: nAck goes high. */
+                if (parport_wait_peripheral (port,
+                                             PARPORT_STATUS_ACK,
+                                             PARPORT_STATUS_ACK)) {
+                        /* Timeout -- no more data? */
+                        DBG("%s: Nibble timeout at event 11\n",
+                                 port->name);
+                        break;
+                }
+                
+                /* Read upper nibble */
+                nibble[1] = parport_read_status (port) >>3;
+                
+                /* reassemble the byte */
+                for (j = 0; j < 2 ; j++ ) {
+                        nibble[j] &= ~8;
+                        if ((nibble[j] & 0x10) == 0)
+                                nibble[j] |= 8;
+                        nibble[j] &= 0xf;
+                }
+                byte = (nibble[0] |(nibble[1] << 4));
+                *buf++ = byte;
+
+                if(byte == EOI)
+                  endseen++;
+                else
+                  endseen = 0;
+        }
+        return i;
+}
+
+/****************************************************************************
+ *
+ *  EndTransferMode
+ *
+ ***************************************************************************/
+static void EndTransferMode(struct pp_cam_entry *cam)
+{
+        parport_negotiate(cam->port, IEEE1284_MODE_COMPAT);
+}
+
+/****************************************************************************
+ *
+ *  ForwardSetup
+ *
+ ***************************************************************************/
+static int ForwardSetup(struct pp_cam_entry *cam)
+{
+        int retry;
+        
+        /* The CPiA uses ECP protocol for Downloads from the Host to the camera. 
+         * This will be software-emulated if ECP hardware is not present
+         */
+
+        /* the usual camera maximum response time is 10ms, but after receiving
+         * some commands, it needs up to 40ms. (Data Sheet p. 32)*/
+
+        for(retry = 0; retry < 4; ++retry) {
+                if(!parport_negotiate(cam->port, IEEE1284_MODE_ECP)) {
+                        break;
+                }
+                mdelay(10);
+        }
+        if(retry == 4) {
+                DBG("Unable to negotiate IEEE1284 ECP Download mode\n");
+                return -1;
+        }
+        return 0;
+}
+/****************************************************************************
+ *
+ *  ReverseSetup
+ *
+ ***************************************************************************/
+static int ReverseSetup(struct pp_cam_entry *cam, int extensibility)
+{
+        int retry;
+        int upload_mode, mode = IEEE1284_MODE_ECP;
+        int transfer_mode = ECP_TRANSFER;
+
+        if (!(cam->port->modes & PARPORT_MODE_ECP) &&
+             !(cam->port->modes & PARPORT_MODE_TRISTATE)) {
+                mode = IEEE1284_MODE_NIBBLE;
+                transfer_mode = NIBBLE_TRANSFER;
+        }
+
+        upload_mode = mode;
+        if(extensibility) mode = UPLOAD_FLAG|transfer_mode|IEEE1284_EXT_LINK;
+
+        /* the usual camera maximum response time is 10ms, but after 
+         * receiving some commands, it needs up to 40ms. */
+                
+        for(retry = 0; retry < 4; ++retry) {
+                if(!parport_negotiate(cam->port, mode)) {
+                        break;
+                }
+                mdelay(10);
+        }
+        if(retry == 4) {
+                if(extensibility)
+                        DBG("Unable to negotiate upload extensibility mode\n");
+                else
+                        DBG("Unable to negotiate upload mode\n");
+                return -1;
+        }
+        if(extensibility) cam->port->ieee1284.mode = upload_mode;
+        return 0;
+}
+
+/****************************************************************************
+ *
+ *  WritePacket
+ *
+ ***************************************************************************/
+static int WritePacket(struct pp_cam_entry *cam, const u8 *packet, size_t size)
+{
+        int retval=0;
+        int size_written;
+
+        if (packet == NULL) {
+                return -EINVAL;
+        }
+        if (ForwardSetup(cam)) {
+                DBG("Write failed in setup\n");
+                return -EIO;
+        }
+        size_written = parport_write(cam->port, packet, size);
+        if(size_written != size) {
+                DBG("Write failed, wrote %d/%d\n", size_written, size);
+                retval = -EIO;
+        }
+        EndTransferMode(cam);
+        return retval;
+}
+
+/****************************************************************************
+ *
+ *  ReadPacket
+ *
+ ***************************************************************************/
+static int ReadPacket(struct pp_cam_entry *cam, u8 *packet, size_t size)
+{
+        int retval=0;
+
+        if (packet == NULL) {
+                return -EINVAL;
+        }
+        if (ReverseSetup(cam, 0)) {
+                return -EIO;
+        }
+
+        /* support for CPiA variant nibble reads */
+        if(cam->port->ieee1284.mode == IEEE1284_MODE_NIBBLE) {
+                if(cpia_read_nibble(cam->port, packet, size, 0) != size) 
+                        retval = -EIO;                  
+        } else {
+                if(parport_read(cam->port, packet, size) != size) 
+                        retval = -EIO;
+        }
+        EndTransferMode(cam);
+        return retval;
+}
+
+/****************************************************************************
+ *
+ *  cpia_pp_streamStart
+ *
+ ***************************************************************************/
+static int cpia_pp_streamStart(void *privdata)
+{
+        struct pp_cam_entry *cam = privdata;
+        DBG("\n");
+        cam->streaming=1;
+        cam->image_ready=0;
+        //if (ReverseSetup(cam,1)) return -EIO;
+        if(cam->stream_irq) cpia_parport_enable_irq(cam->port);
+        return 0;
+}
+
+/****************************************************************************
+ *
+ *  cpia_pp_streamStop
+ *
+ ***************************************************************************/
+static int cpia_pp_streamStop(void *privdata)
+{
+        struct pp_cam_entry *cam = privdata;
+
+        DBG("\n");
+        cam->streaming=0;
+        cpia_parport_disable_irq(cam->port);
+        //EndTransferMode(cam);
+
+        return 0;
+}
+
+/****************************************************************************
+ *
+ *  cpia_pp_streamRead
+ *
+ ***************************************************************************/
+static int cpia_pp_read(struct parport *port, u8 *buffer, int len)
+{
+        int bytes_read;
+
+        /* support for CPiA variant "nibble stream" reads */
+        if(port->ieee1284.mode == IEEE1284_MODE_NIBBLE)
+                bytes_read = cpia_read_nibble_stream(port,buffer,len,0);
+        else {
+                int new_bytes;
+                for(bytes_read=0; bytes_read<len; bytes_read += new_bytes) {
+                        new_bytes = parport_read(port, buffer+bytes_read,
+                                                 len-bytes_read);
+                        if(new_bytes < 0) break;
+                }
+        }
+        return bytes_read;
+}
+
+static int cpia_pp_streamRead(void *privdata, u8 *buffer, int noblock)
+{
+        struct pp_cam_entry *cam = privdata;
+        int read_bytes = 0;
+        int i, endseen, block_size, new_bytes;
+
+        if(cam == NULL) {
+                DBG("Internal driver error: cam is NULL\n");
+                return -EINVAL;
+        }
+        if(buffer == NULL) {
+                DBG("Internal driver error: buffer is NULL\n");
+                return -EINVAL;
+        }
+        //if(cam->streaming) DBG("%d / %d\n", cam->image_ready, noblock);
+        if( cam->stream_irq ) {
+                DBG("%d\n", cam->image_ready);
+                cam->image_ready--;
+        }
+        cam->image_complete=0;
+        if (0/*cam->streaming*/) {
+                if(!cam->image_ready) {
+                        if(noblock) return -EWOULDBLOCK;
+                        interruptible_sleep_on(&cam->wq_stream);
+                        if( signal_pending(current) ) return -EINTR;
+                        DBG("%d\n", cam->image_ready);
+                }
+        } else {
+                if (ReverseSetup(cam, 1)) {
+                        DBG("unable to ReverseSetup\n");
+                        return -EIO;
+                }
+        }
+        endseen = 0;
+        block_size = PARPORT_CHUNK_SIZE;
+        while( !cam->image_complete ) {
+                cond_resched();
+                
+                new_bytes = cpia_pp_read(cam->port, buffer, block_size );
+                if( new_bytes <= 0 ) {
+                        break;
+                }
+                i=-1;
+                while(++i<new_bytes && endseen<4) {
+                        if(*buffer==EOI) {
+                                endseen++;
+                        } else {
+                                endseen=0;
+                        }
+                        buffer++;
+                }
+                read_bytes += i;
+                if( endseen==4 ) {
+                        cam->image_complete=1;
+                        break;
+                }
+                if( CPIA_MAX_IMAGE_SIZE-read_bytes <= PARPORT_CHUNK_SIZE ) {
+                        block_size=CPIA_MAX_IMAGE_SIZE-read_bytes;
+                }
+        }
+        EndTransferMode(cam);
+        return cam->image_complete ? read_bytes : -EIO;
+}
+/****************************************************************************
+ *
+ *  cpia_pp_transferCmd
+ *
+ ***************************************************************************/
+static int cpia_pp_transferCmd(void *privdata, u8 *command, u8 *data)
+{
+        int err;
+        int retval=0;
+        int databytes;
+        struct pp_cam_entry *cam = privdata;
+
+        if(cam == NULL) {
+                DBG("Internal driver error: cam is NULL\n");
+                return -EINVAL;
+        }
+        if(command == NULL) {
+                DBG("Internal driver error: command is NULL\n");
+                return -EINVAL;
+        }
+        databytes = (((int)command[7])<<8) | command[6];
+        if ((err = WritePacket(cam, command, PACKET_LENGTH)) < 0) {
+                DBG("Error writing command\n");
+                return err;
+        }
+        if(command[0] == DATA_IN) {
+                u8 buffer[8];
+                if(data == NULL) {
+                        DBG("Internal driver error: data is NULL\n");
+                        return -EINVAL;
+                }
+                if((err = ReadPacket(cam, buffer, 8)) < 0) {
+                        DBG("Error reading command result\n");
+                       return err;
+                }
+                memcpy(data, buffer, databytes);
+        } else if(command[0] == DATA_OUT) {
+                if(databytes > 0) {
+                        if(data == NULL) {
+                                DBG("Internal driver error: data is NULL\n");
+                                retval = -EINVAL;
+                        } else {
+                                if((err=WritePacket(cam, data, databytes)) < 0){
+                                        DBG("Error writing command data\n");
+                                        return err;
+                                }
+                        }
+                }
+        } else {
+                DBG("Unexpected first byte of command: %x\n", command[0]);
+                retval = -EINVAL;
+        }
+        return retval;
+}
+
+/****************************************************************************
+ *
+ *  cpia_pp_open
+ *
+ ***************************************************************************/
+static int cpia_pp_open(void *privdata)
+{
+        struct pp_cam_entry *cam = (struct pp_cam_entry *)privdata;
+        
+        if (cam == NULL)
+                return -EINVAL;
+        
+        if(cam->open_count == 0) {
+                if (parport_claim(cam->pdev)) {
+                        DBG("failed to claim the port\n");
+                        return -EBUSY;
+                }
+                parport_negotiate(cam->port, IEEE1284_MODE_COMPAT);
+                parport_data_forward(cam->port);
+                parport_write_control(cam->port, PARPORT_CONTROL_SELECT);
+                udelay(50);
+                parport_write_control(cam->port,
+                                      PARPORT_CONTROL_SELECT
+                                      | PARPORT_CONTROL_INIT);
+        }
+        
+        ++cam->open_count;
+        
+        return 0;
+}
+
+/****************************************************************************
+ *
+ *  cpia_pp_registerCallback
+ *
+ ***************************************************************************/
+static int cpia_pp_registerCallback(void *privdata, void (*cb)(void *cbdata), void *cbdata)
+{
+        struct pp_cam_entry *cam = privdata;
+        int retval = 0;
+        
+        if(cam->port->irq != PARPORT_IRQ_NONE) {
+                INIT_WORK(&cam->cb_task, cb, cbdata);
+        } else {
+                retval = -1;
+        }
+        return retval;
+}
+
+/****************************************************************************
+ *
+ *  cpia_pp_close
+ *
+ ***************************************************************************/
+static int cpia_pp_close(void *privdata)
+{
+        struct pp_cam_entry *cam = privdata;
+        if (--cam->open_count == 0) {
+                parport_release(cam->pdev);
+        }
+        return 0;
+}
+
+/****************************************************************************
+ *
+ *  cpia_pp_register
+ *
+ ***************************************************************************/
+static int cpia_pp_register(struct parport *port)
+{
+        struct pardevice *pdev = NULL;
+        struct pp_cam_entry *cam;
+        struct cam_data *cpia;
+
+        if (!(port->modes & PARPORT_MODE_PCSPP)) {
+                LOG("port is not supported by CPiA driver\n");
+                return -ENXIO;
+        }
+
+        cam = kmalloc(sizeof(struct pp_cam_entry), GFP_KERNEL);
+        if (cam == NULL) {
+                LOG("failed to allocate camera structure\n");
+                return -ENOMEM;
+        }
+        memset(cam,0,sizeof(struct pp_cam_entry));
+        
+        pdev = parport_register_device(port, "cpia_pp", NULL, NULL,
+                                       NULL, 0, cam);
+
+        if (!pdev) {
+                LOG("failed to parport_register_device\n");
+                kfree(cam);
+                return -ENXIO;
+        }
+
+        cam->pdev = pdev;
+        cam->port = port;
+        init_waitqueue_head(&cam->wq_stream);
+
+        cam->streaming = 0;
+        cam->stream_irq = 0;
+
+        if((cpia = cpia_register_camera(&cpia_pp_ops, cam)) == NULL) {
+                LOG("failed to cpia_register_camera\n");
+                parport_unregister_device(pdev);
+                kfree(cam);
+                return -ENXIO;
+        }
+        spin_lock( &cam_list_lock_pp );
+        list_add( &cpia->cam_data_list, &cam_list );
+        spin_unlock( &cam_list_lock_pp );
+
+        return 0;
+}
+
+static void cpia_pp_detach (struct parport *port)
+{
+        struct list_head *tmp;
+        struct cam_data *cpia = NULL;
+        struct pp_cam_entry *cam;
+
+        spin_lock( &cam_list_lock_pp );
+        list_for_each (tmp, &cam_list) {
+                cpia = list_entry(tmp, struct cam_data, cam_data_list);
+                cam = (struct pp_cam_entry *) cpia->lowlevel_data;
+                if (cam && cam->port->number == port->number) {
+                        list_del(&cpia->cam_data_list);
+                        break;
+                }
+                cpia = NULL;
+        }
+        spin_unlock( &cam_list_lock_pp );                       
+
+        if (!cpia) {
+                DBG("cpia_pp_detach failed to find cam_data in cam_list\n");
+                return;
+        }
+        
+        cam = (struct pp_cam_entry *) cpia->lowlevel_data;      
+        cpia_unregister_camera(cpia);
+        if(cam->open_count > 0) 
+                cpia_pp_close(cam);
+        parport_unregister_device(cam->pdev);
+        cpia->lowlevel_data = NULL;     
+        kfree(cam);
+}
+
+static void cpia_pp_attach (struct parport *port)
+{
+        unsigned int i;
+
+        switch (parport_nr[0])
+        {
+        case PPCPIA_PARPORT_UNSPEC:
+        case PPCPIA_PARPORT_AUTO:
+                if (port->probe_info[0].class != PARPORT_CLASS_MEDIA ||
+                    port->probe_info[0].cmdset == NULL ||
+                    strncmp(port->probe_info[0].cmdset, "CPIA_1", 6) != 0)
+                        return;
+
+                cpia_pp_register(port);
+
+                break;
+
+        default:
+                for (i = 0; i < PARPORT_MAX; ++i) {
+                        if (port->number == parport_nr[i]) {
+                                cpia_pp_register(port);
+                                break;
+                        }
+                }
+                break;
+        }
+}
+
+static struct parport_driver cpia_pp_driver = {
+        .name = "cpia_pp",
+        .attach = cpia_pp_attach,
+        .detach = cpia_pp_detach,
+};
+
+int cpia_pp_init(void)
+{
+        printk(KERN_INFO "%s v%d.%d.%d\n",ABOUT, 
+               CPIA_PP_MAJ_VER,CPIA_PP_MIN_VER,CPIA_PP_PATCH_VER);
+
+        if(parport_nr[0] == PPCPIA_PARPORT_OFF) {
+                printk("  disabled\n");
+                return 0;
+        }
+        
+        spin_lock_init( &cam_list_lock_pp );
+
+        if (parport_register_driver (&cpia_pp_driver)) {
+                LOG ("unable to register with parport\n");
+                return -EIO;
+        }
+        return 0;
+}
+
+#ifdef MODULE
+int init_module(void)
+{
+        if (parport[0]) {
+                /* The user gave some parameters.  Let's see what they were. */
+                if (!strncmp(parport[0], "auto", 4)) {
+                        parport_nr[0] = PPCPIA_PARPORT_AUTO;
+                } else {
+                        int n;
+                        for (n = 0; n < PARPORT_MAX && parport[n]; n++) {
+                                if (!strncmp(parport[n], "none", 4)) {
+                                        parport_nr[n] = PPCPIA_PARPORT_NONE;
+                                } else {
+                                        char *ep;
+                                        unsigned long r = simple_strtoul(parport[n], &ep, 0);
+                                        if (ep != parport[n]) {
+                                                parport_nr[n] = r;
+                                        } else {
+                                                LOG("bad port specifier `%s'\n", parport[n]);
+                                                return -ENODEV;
+                                        }
+                                }
+                        }
+                }
+        }
+        return cpia_pp_init();
+}
+
+void cleanup_module(void)
+{
+        parport_unregister_driver (&cpia_pp_driver);
+        return;
+}
+
+#else /* !MODULE */
+
+static int __init cpia_pp_setup(char *str)
+{
+        if (!strncmp(str, "parport", 7)) {
+                int n = simple_strtoul(str + 7, NULL, 10);
+                if (parport_ptr < PARPORT_MAX) {
+                        parport_nr[parport_ptr++] = n;
+                } else {
+                        LOG("too many ports, %s ignored.\n", str);
+                }
+        } else if (!strcmp(str, "auto")) {
+                parport_nr[0] = PPCPIA_PARPORT_AUTO;
+        } else if (!strcmp(str, "none")) {
+                parport_nr[parport_ptr++] = PPCPIA_PARPORT_NONE;
+        }
+
+        return 0;
+}
+
+__setup("cpia_pp=", cpia_pp_setup);
+
+#endif /* !MODULE */