SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/media/video/cpia_pp.c

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