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