drivers/char/pcmcia/cm4040_cs.c

   1 /*
   2  * A driver for the Omnikey PCMCIA smartcard reader CardMan 4040
   3  *
   4  * (c) 2000-2004 Omnikey AG (http://www.omnikey.com/)
   5  *
   6  * (C) 2005-2006 Harald Welte <laforge@gnumonks.org>
   7  *      - add support for poll()
   8  *      - driver cleanup
   9  *      - add waitqueues
  10  *      - adhere to linux kernel coding style and policies
  11  *      - support 2.6.13 "new style" pcmcia interface
  12  *      - add class interface for udev device creation
  13  *
  14  * The device basically is a USB CCID compliant device that has been
  15  * attached to an I/O-Mapped FIFO.
  16  *
  17  * All rights reserved, Dual BSD/GPL Licensed.
  18  */
  19
  20 #include <linux/kernel.h>
  21 #include <linux/module.h>
  22 #include <linux/slab.h>
  23 #include <linux/init.h>
  24 #include <linux/fs.h>
  25 #include <linux/delay.h>
  26 #include <linux/poll.h>
  27 #include <linux/smp_lock.h>
  28 #include <linux/wait.h>
  29 #include <asm/uaccess.h>
  30 #include <asm/io.h>
  31
  32 #include <pcmcia/cistpl.h>
  33 #include <pcmcia/cisreg.h>
  34 #include <pcmcia/ciscode.h>
  35 #include <pcmcia/ds.h>
  36
  37 #include "cm4040_cs.h"
  38
  39
  40 #define reader_to_dev(x)        (&x->p_dev->dev)
  41
  42 /* n (debug level) is ignored */
  43 /* additional debug output may be enabled by re-compiling with
  44  * CM4040_DEBUG set */
  45 /* #define CM4040_DEBUG */
  46 #define DEBUGP(n, rdr, x, args...) do {                 \
  47                 dev_dbg(reader_to_dev(rdr), "%s:" x,    \
  48                            __func__ , ## args);         \
  49         } while (0)
  50
  51 #define CCID_DRIVER_BULK_DEFAULT_TIMEOUT        (150*HZ)
  52 #define CCID_DRIVER_ASYNC_POWERUP_TIMEOUT       (35*HZ)
  53 #define CCID_DRIVER_MINIMUM_TIMEOUT             (3*HZ)
  54 #define READ_WRITE_BUFFER_SIZE 512
  55 #define POLL_LOOP_COUNT                         1000
  56
  57 /* how often to poll for fifo status change */
  58 #define POLL_PERIOD                             msecs_to_jiffies(10)
  59
  60 static void reader_release(struct pcmcia_device *link);
  61
  62 static int major;
  63 static struct class *cmx_class;
  64
  65 #define         BS_READABLE     0x01
  66 #define         BS_WRITABLE     0x02
  67
  68 struct reader_dev {
  69         struct pcmcia_device    *p_dev;
  70         wait_queue_head_t       devq;
  71         wait_queue_head_t       poll_wait;
  72         wait_queue_head_t       read_wait;
  73         wait_queue_head_t       write_wait;
  74         unsigned long           buffer_status;
  75         unsigned long           timeout;
  76         unsigned char           s_buf[READ_WRITE_BUFFER_SIZE];
  77         unsigned char           r_buf[READ_WRITE_BUFFER_SIZE];
  78         struct timer_list       poll_timer;
  79 };
  80
  81 static struct pcmcia_device *dev_table[CM_MAX_DEV];
  82
  83 #ifndef CM4040_DEBUG
  84 #define xoutb   outb
  85 #define xinb    inb
  86 #else
  87 static inline void xoutb(unsigned char val, unsigned short port)
  88 {
  89         pr_debug("outb(val=%.2x,port=%.4x)\n", val, port);
  90         outb(val, port);
  91 }
  92
  93 static inline unsigned char xinb(unsigned short port)
  94 {
  95         unsigned char val;
  96
  97         val = inb(port);
  98         pr_debug("%.2x=inb(%.4x)\n", val, port);
  99         return val;
 100 }
 101 #endif
 102
 103 /* poll the device fifo status register.  not to be confused with
 104  * the poll syscall. */
 105 static void cm4040_do_poll(unsigned long dummy)
 106 {
 107         struct reader_dev *dev = (struct reader_dev *) dummy;
 108         unsigned int obs = xinb(dev->p_dev->resource[0]->start
 109                                 + REG_OFFSET_BUFFER_STATUS);
 110
 111         if ((obs & BSR_BULK_IN_FULL)) {
 112                 set_bit(BS_READABLE, &dev->buffer_status);
 113                 DEBUGP(4, dev, "waking up read_wait\n");
 114                 wake_up_interruptible(&dev->read_wait);
 115         } else
 116                 clear_bit(BS_READABLE, &dev->buffer_status);
 117
 118         if (!(obs & BSR_BULK_OUT_FULL)) {
 119                 set_bit(BS_WRITABLE, &dev->buffer_status);
 120                 DEBUGP(4, dev, "waking up write_wait\n");
 121                 wake_up_interruptible(&dev->write_wait);
 122         } else
 123                 clear_bit(BS_WRITABLE, &dev->buffer_status);
 124
 125         if (dev->buffer_status)
 126                 wake_up_interruptible(&dev->poll_wait);
 127
 128         mod_timer(&dev->poll_timer, jiffies + POLL_PERIOD);
 129 }
 130
 131 static void cm4040_stop_poll(struct reader_dev *dev)
 132 {
 133         del_timer_sync(&dev->poll_timer);
 134 }
 135
 136 static int wait_for_bulk_out_ready(struct reader_dev *dev)
 137 {
 138         int i, rc;
 139         int iobase = dev->p_dev->resource[0]->start;
 140
 141         for (i = 0; i < POLL_LOOP_COUNT; i++) {
 142                 if ((xinb(iobase + REG_OFFSET_BUFFER_STATUS)
 143                     & BSR_BULK_OUT_FULL) == 0) {
 144                         DEBUGP(4, dev, "BulkOut empty (i=%d)\n", i);
 145                         return 1;
 146                 }
 147         }
 148
 149         DEBUGP(4, dev, "wait_event_interruptible_timeout(timeout=%ld\n",
 150                 dev->timeout);
 151         rc = wait_event_interruptible_timeout(dev->write_wait,
 152                                               test_and_clear_bit(BS_WRITABLE,
 153                                                        &dev->buffer_status),
 154                                               dev->timeout);
 155
 156         if (rc > 0)
 157                 DEBUGP(4, dev, "woke up: BulkOut empty\n");
 158         else if (rc == 0)
 159                 DEBUGP(4, dev, "woke up: BulkOut full, returning 0 :(\n");
 160         else if (rc < 0)
 161                 DEBUGP(4, dev, "woke up: signal arrived\n");
 162
 163         return rc;
 164 }
 165
 166 /* Write to Sync Control Register */
 167 static int write_sync_reg(unsigned char val, struct reader_dev *dev)
 168 {
 169         int iobase = dev->p_dev->resource[0]->start;
 170         int rc;
 171
 172         rc = wait_for_bulk_out_ready(dev);
 173         if (rc <= 0)
 174                 return rc;
 175
 176         xoutb(val, iobase + REG_OFFSET_SYNC_CONTROL);
 177         rc = wait_for_bulk_out_ready(dev);
 178         if (rc <= 0)
 179                 return rc;
 180
 181         return 1;
 182 }
 183
 184 static int wait_for_bulk_in_ready(struct reader_dev *dev)
 185 {
 186         int i, rc;
 187         int iobase = dev->p_dev->resource[0]->start;
 188
 189         for (i = 0; i < POLL_LOOP_COUNT; i++) {
 190                 if ((xinb(iobase + REG_OFFSET_BUFFER_STATUS)
 191                     & BSR_BULK_IN_FULL) == BSR_BULK_IN_FULL) {
 192                         DEBUGP(3, dev, "BulkIn full (i=%d)\n", i);
 193                         return 1;
 194                 }
 195         }
 196
 197         DEBUGP(4, dev, "wait_event_interruptible_timeout(timeout=%ld\n",
 198                 dev->timeout);
 199         rc = wait_event_interruptible_timeout(dev->read_wait,
 200                                               test_and_clear_bit(BS_READABLE,
 201                                                         &dev->buffer_status),
 202                                               dev->timeout);
 203         if (rc > 0)
 204                 DEBUGP(4, dev, "woke up: BulkIn full\n");
 205         else if (rc == 0)
 206                 DEBUGP(4, dev, "woke up: BulkIn not full, returning 0 :(\n");
 207         else if (rc < 0)
 208                 DEBUGP(4, dev, "woke up: signal arrived\n");
 209
 210         return rc;
 211 }
 212
 213 static ssize_t cm4040_read(struct file *filp, char __user *buf,
 214                         size_t count, loff_t *ppos)
 215 {
 216         struct reader_dev *dev = filp->private_data;
 217         int iobase = dev->p_dev->resource[0]->start;
 218         size_t bytes_to_read;
 219         unsigned long i;
 220         size_t min_bytes_to_read;
 221         int rc;
 222         unsigned char uc;
 223
 224         DEBUGP(2, dev, "-> cm4040_read(%s,%d)\n", current->comm, current->pid);
 225
 226         if (count == 0)
 227                 return 0;
 228
 229         if (count < 10)
 230                 return -EFAULT;
 231
 232         if (filp->f_flags & O_NONBLOCK) {
 233                 DEBUGP(4, dev, "filep->f_flags O_NONBLOCK set\n");
 234                 DEBUGP(2, dev, "<- cm4040_read (failure)\n");
 235                 return -EAGAIN;
 236         }
 237
 238         if (!pcmcia_dev_present(dev->p_dev))
 239                 return -ENODEV;
 240
 241         for (i = 0; i < 5; i++) {
 242                 rc = wait_for_bulk_in_ready(dev);
 243                 if (rc <= 0) {
 244                         DEBUGP(5, dev, "wait_for_bulk_in_ready rc=%.2x\n", rc);
 245                         DEBUGP(2, dev, "<- cm4040_read (failed)\n");
 246                         if (rc == -ERESTARTSYS)
 247                                 return rc;
 248                         return -EIO;
 249                 }
 250                 dev->r_buf[i] = xinb(iobase + REG_OFFSET_BULK_IN);
 251 #ifdef CM4040_DEBUG
 252                 pr_debug("%lu:%2x ", i, dev->r_buf[i]);
 253         }
 254         pr_debug("\n");
 255 #else
 256         }
 257 #endif
 258
 259         bytes_to_read = 5 + le32_to_cpu(*(__le32 *)&dev->r_buf[1]);
 260
 261         DEBUGP(6, dev, "BytesToRead=%zu\n", bytes_to_read);
 262
 263         min_bytes_to_read = min(count, bytes_to_read + 5);
 264         min_bytes_to_read = min_t(size_t, min_bytes_to_read, READ_WRITE_BUFFER_SIZE);
 265
 266         DEBUGP(6, dev, "Min=%zu\n", min_bytes_to_read);
 267
 268         for (i = 0; i < (min_bytes_to_read-5); i++) {
 269                 rc = wait_for_bulk_in_ready(dev);
 270                 if (rc <= 0) {
 271                         DEBUGP(5, dev, "wait_for_bulk_in_ready rc=%.2x\n", rc);
 272                         DEBUGP(2, dev, "<- cm4040_read (failed)\n");
 273                         if (rc == -ERESTARTSYS)
 274                                 return rc;
 275                         return -EIO;
 276                 }
 277                 dev->r_buf[i+5] = xinb(iobase + REG_OFFSET_BULK_IN);
 278 #ifdef CM4040_DEBUG
 279                 pr_debug("%lu:%2x ", i, dev->r_buf[i]);
 280         }
 281         pr_debug("\n");
 282 #else
 283         }
 284 #endif
 285
 286         *ppos = min_bytes_to_read;
 287         if (copy_to_user(buf, dev->r_buf, min_bytes_to_read))
 288                 return -EFAULT;
 289
 290         rc = wait_for_bulk_in_ready(dev);
 291         if (rc <= 0) {
 292                 DEBUGP(5, dev, "wait_for_bulk_in_ready rc=%.2x\n", rc);
 293                 DEBUGP(2, dev, "<- cm4040_read (failed)\n");
 294                 if (rc == -ERESTARTSYS)
 295                         return rc;
 296                 return -EIO;
 297         }
 298
 299         rc = write_sync_reg(SCR_READER_TO_HOST_DONE, dev);
 300         if (rc <= 0) {
 301                 DEBUGP(5, dev, "write_sync_reg c=%.2x\n", rc);
 302                 DEBUGP(2, dev, "<- cm4040_read (failed)\n");
 303                 if (rc == -ERESTARTSYS)
 304                         return rc;
 305                 else
 306                         return -EIO;
 307         }
 308
 309         uc = xinb(iobase + REG_OFFSET_BULK_IN);
 310
 311         DEBUGP(2, dev, "<- cm4040_read (successfully)\n");
 312         return min_bytes_to_read;
 313 }
 314
 315 static ssize_t cm4040_write(struct file *filp, const char __user *buf,
 316                          size_t count, loff_t *ppos)
 317 {
 318         struct reader_dev *dev = filp->private_data;
 319         int iobase = dev->p_dev->resource[0]->start;
 320         ssize_t rc;
 321         int i;
 322         unsigned int bytes_to_write;
 323
 324         DEBUGP(2, dev, "-> cm4040_write(%s,%d)\n", current->comm, current->pid);
 325
 326         if (count == 0) {
 327                 DEBUGP(2, dev, "<- cm4040_write empty read (successfully)\n");
 328                 return 0;
 329         }
 330
 331         if ((count < 5) || (count > READ_WRITE_BUFFER_SIZE)) {
 332                 DEBUGP(2, dev, "<- cm4040_write buffersize=%Zd < 5\n", count);
 333                 return -EIO;
 334         }
 335
 336         if (filp->f_flags & O_NONBLOCK) {
 337                 DEBUGP(4, dev, "filep->f_flags O_NONBLOCK set\n");
 338                 DEBUGP(4, dev, "<- cm4040_write (failure)\n");
 339                 return -EAGAIN;
 340         }
 341
 342         if (!pcmcia_dev_present(dev->p_dev))
 343                 return -ENODEV;
 344
 345         bytes_to_write = count;
 346         if (copy_from_user(dev->s_buf, buf, bytes_to_write))
 347                 return -EFAULT;
 348
 349         switch (dev->s_buf[0]) {
 350                 case CMD_PC_TO_RDR_XFRBLOCK:
 351                 case CMD_PC_TO_RDR_SECURE:
 352                 case CMD_PC_TO_RDR_TEST_SECURE:
 353                 case CMD_PC_TO_RDR_OK_SECURE:
 354                         dev->timeout = CCID_DRIVER_BULK_DEFAULT_TIMEOUT;
 355                         break;
 356
 357                 case CMD_PC_TO_RDR_ICCPOWERON:
 358                         dev->timeout = CCID_DRIVER_ASYNC_POWERUP_TIMEOUT;
 359                         break;
 360
 361                 case CMD_PC_TO_RDR_GETSLOTSTATUS:
 362                 case CMD_PC_TO_RDR_ICCPOWEROFF:
 363                 case CMD_PC_TO_RDR_GETPARAMETERS:
 364                 case CMD_PC_TO_RDR_RESETPARAMETERS:
 365                 case CMD_PC_TO_RDR_SETPARAMETERS:
 366                 case CMD_PC_TO_RDR_ESCAPE:
 367                 case CMD_PC_TO_RDR_ICCCLOCK:
 368                 default:
 369                         dev->timeout = CCID_DRIVER_MINIMUM_TIMEOUT;
 370                         break;
 371         }
 372
 373         rc = write_sync_reg(SCR_HOST_TO_READER_START, dev);
 374         if (rc <= 0) {
 375                 DEBUGP(5, dev, "write_sync_reg c=%.2Zx\n", rc);
 376                 DEBUGP(2, dev, "<- cm4040_write (failed)\n");
 377                 if (rc == -ERESTARTSYS)
 378                         return rc;
 379                 else
 380                         return -EIO;
 381         }
 382
 383         DEBUGP(4, dev, "start \n");
 384
 385         for (i = 0; i < bytes_to_write; i++) {
 386                 rc = wait_for_bulk_out_ready(dev);
 387                 if (rc <= 0) {
 388                         DEBUGP(5, dev, "wait_for_bulk_out_ready rc=%.2Zx\n",
 389                                rc);
 390                         DEBUGP(2, dev, "<- cm4040_write (failed)\n");
 391                         if (rc == -ERESTARTSYS)
 392                                 return rc;
 393                         else
 394                                 return -EIO;
 395                 }
 396
 397                 xoutb(dev->s_buf[i],iobase + REG_OFFSET_BULK_OUT);
 398         }
 399         DEBUGP(4, dev, "end\n");
 400
 401         rc = write_sync_reg(SCR_HOST_TO_READER_DONE, dev);
 402
 403         if (rc <= 0) {
 404                 DEBUGP(5, dev, "write_sync_reg c=%.2Zx\n", rc);
 405                 DEBUGP(2, dev, "<- cm4040_write (failed)\n");
 406                 if (rc == -ERESTARTSYS)
 407                         return rc;
 408                 else
 409                         return -EIO;
 410         }
 411
 412         DEBUGP(2, dev, "<- cm4040_write (successfully)\n");
 413         return count;
 414 }
 415
 416 static unsigned int cm4040_poll(struct file *filp, poll_table *wait)
 417 {
 418         struct reader_dev *dev = filp->private_data;
 419         unsigned int mask = 0;
 420
 421         poll_wait(filp, &dev->poll_wait, wait);
 422
 423         if (test_and_clear_bit(BS_READABLE, &dev->buffer_status))
 424                 mask |= POLLIN | POLLRDNORM;
 425         if (test_and_clear_bit(BS_WRITABLE, &dev->buffer_status))
 426                 mask |= POLLOUT | POLLWRNORM;
 427
 428         DEBUGP(2, dev, "<- cm4040_poll(%u)\n", mask);
 429
 430         return mask;
 431 }
 432
 433 static int cm4040_open(struct inode *inode, struct file *filp)
 434 {
 435         struct reader_dev *dev;
 436         struct pcmcia_device *link;
 437         int minor = iminor(inode);
 438         int ret;
 439
 440         if (minor >= CM_MAX_DEV)
 441                 return -ENODEV;
 442
 443         lock_kernel();
 444         link = dev_table[minor];
 445         if (link == NULL || !pcmcia_dev_present(link)) {
 446                 ret = -ENODEV;
 447                 goto out;
 448         }
 449
 450         if (link->open) {
 451                 ret = -EBUSY;
 452                 goto out;
 453         }
 454
 455         dev = link->priv;
 456         filp->private_data = dev;
 457
 458         if (filp->f_flags & O_NONBLOCK) {
 459                 DEBUGP(4, dev, "filep->f_flags O_NONBLOCK set\n");
 460                 ret = -EAGAIN;
 461                 goto out;
 462         }
 463
 464         link->open = 1;
 465
 466         dev->poll_timer.data = (unsigned long) dev;
 467         mod_timer(&dev->poll_timer, jiffies + POLL_PERIOD);
 468
 469         DEBUGP(2, dev, "<- cm4040_open (successfully)\n");
 470         ret = nonseekable_open(inode, filp);
 471 out:
 472         unlock_kernel();
 473         return ret;
 474 }
 475
 476 static int cm4040_close(struct inode *inode, struct file *filp)
 477 {
 478         struct reader_dev *dev = filp->private_data;
 479         struct pcmcia_device *link;
 480         int minor = iminor(inode);
 481
 482         DEBUGP(2, dev, "-> cm4040_close(maj/min=%d.%d)\n", imajor(inode),
 483               iminor(inode));
 484
 485         if (minor >= CM_MAX_DEV)
 486                 return -ENODEV;
 487
 488         link = dev_table[minor];
 489         if (link == NULL)
 490                 return -ENODEV;
 491
 492         cm4040_stop_poll(dev);
 493
 494         link->open = 0;
 495         wake_up(&dev->devq);
 496
 497         DEBUGP(2, dev, "<- cm4040_close\n");
 498         return 0;
 499 }
 500
 501 static void cm4040_reader_release(struct pcmcia_device *link)
 502 {
 503         struct reader_dev *dev = link->priv;
 504
 505         DEBUGP(3, dev, "-> cm4040_reader_release\n");
 506         while (link->open) {
 507                 DEBUGP(3, dev, KERN_INFO MODULE_NAME ": delaying release "
 508                        "until process has terminated\n");
 509                 wait_event(dev->devq, (link->open == 0));
 510         }
 511         DEBUGP(3, dev, "<- cm4040_reader_release\n");
 512         return;
 513 }
 514
 515 static int cm4040_config_check(struct pcmcia_device *p_dev, void *priv_data)
 516 {
 517         return pcmcia_request_io(p_dev);
 518 }
 519
 520
 521 static int reader_config(struct pcmcia_device *link, int devno)
 522 {
 523         struct reader_dev *dev;
 524         int fail_rc;
 525
 526         link->config_flags |= CONF_AUTO_SET_IO;
 527
 528         if (pcmcia_loop_config(link, cm4040_config_check, NULL))
 529                 goto cs_release;
 530
 531         fail_rc = pcmcia_enable_device(link);
 532         if (fail_rc != 0) {
 533                 dev_printk(KERN_INFO, &link->dev,
 534                            "pcmcia_enable_device failed 0x%x\n",
 535                            fail_rc);
 536                 goto cs_release;
 537         }
 538
 539         dev = link->priv;
 540
 541         DEBUGP(2, dev, "device " DEVICE_NAME "%d at %pR\n", devno,
 542               link->resource[0]);
 543         DEBUGP(2, dev, "<- reader_config (succ)\n");
 544
 545         return 0;
 546
 547 cs_release:
 548         reader_release(link);
 549         return -ENODEV;
 550 }
 551
 552 static void reader_release(struct pcmcia_device *link)
 553 {
 554         cm4040_reader_release(link);
 555         pcmcia_disable_device(link);
 556 }
 557
 558 static int reader_probe(struct pcmcia_device *link)
 559 {
 560         struct reader_dev *dev;
 561         int i, ret;
 562
 563         for (i = 0; i < CM_MAX_DEV; i++) {
 564                 if (dev_table[i] == NULL)
 565                         break;
 566         }
 567
 568         if (i == CM_MAX_DEV)
 569                 return -ENODEV;
 570
 571         dev = kzalloc(sizeof(struct reader_dev), GFP_KERNEL);
 572         if (dev == NULL)
 573                 return -ENOMEM;
 574
 575         dev->timeout = CCID_DRIVER_MINIMUM_TIMEOUT;
 576         dev->buffer_status = 0;
 577
 578         link->priv = dev;
 579         dev->p_dev = link;
 580
 581         dev_table[i] = link;
 582
 583         init_waitqueue_head(&dev->devq);
 584         init_waitqueue_head(&dev->poll_wait);
 585         init_waitqueue_head(&dev->read_wait);
 586         init_waitqueue_head(&dev->write_wait);
 587         setup_timer(&dev->poll_timer, cm4040_do_poll, 0);
 588
 589         ret = reader_config(link, i);
 590         if (ret) {
 591                 dev_table[i] = NULL;
 592                 kfree(dev);
 593                 return ret;
 594         }
 595
 596         device_create(cmx_class, NULL, MKDEV(major, i), NULL, "cmx%d", i);
 597
 598         return 0;
 599 }
 600
 601 static void reader_detach(struct pcmcia_device *link)
 602 {
 603         struct reader_dev *dev = link->priv;
 604         int devno;
 605
 606         /* find device */
 607         for (devno = 0; devno < CM_MAX_DEV; devno++) {
 608                 if (dev_table[devno] == link)
 609                         break;
 610         }
 611         if (devno == CM_MAX_DEV)
 612                 return;
 613
 614         reader_release(link);
 615
 616         dev_table[devno] = NULL;
 617         kfree(dev);
 618
 619         device_destroy(cmx_class, MKDEV(major, devno));
 620
 621         return;
 622 }
 623
 624 static const struct file_operations reader_fops = {
 625         .owner          = THIS_MODULE,
 626         .read           = cm4040_read,
 627         .write          = cm4040_write,
 628         .open           = cm4040_open,
 629         .release        = cm4040_close,
 630         .poll           = cm4040_poll,
 631 };
 632
 633 static struct pcmcia_device_id cm4040_ids[] = {
 634         PCMCIA_DEVICE_MANF_CARD(0x0223, 0x0200),
 635         PCMCIA_DEVICE_PROD_ID12("OMNIKEY", "CardMan 4040",
 636                                 0xE32CDD8C, 0x8F23318B),
 637         PCMCIA_DEVICE_NULL,
 638 };
 639 MODULE_DEVICE_TABLE(pcmcia, cm4040_ids);
 640
 641 static struct pcmcia_driver reader_driver = {
 642         .owner          = THIS_MODULE,
 643         .name           = "cm4040_cs",
 644         .probe          = reader_probe,
 645         .remove         = reader_detach,
 646         .id_table       = cm4040_ids,
 647 };
 648
 649 static int __init cm4040_init(void)
 650 {
 651         int rc;
 652
 653         cmx_class = class_create(THIS_MODULE, "cardman_4040");
 654         if (IS_ERR(cmx_class))
 655                 return PTR_ERR(cmx_class);
 656
 657         major = register_chrdev(0, DEVICE_NAME, &reader_fops);
 658         if (major < 0) {
 659                 printk(KERN_WARNING MODULE_NAME
 660                         ": could not get major number\n");
 661                 class_destroy(cmx_class);
 662                 return major;
 663         }
 664
 665         rc = pcmcia_register_driver(&reader_driver);
 666         if (rc < 0) {
 667                 unregister_chrdev(major, DEVICE_NAME);
 668                 class_destroy(cmx_class);
 669                 return rc;
 670         }
 671
 672         return 0;
 673 }
 674
 675 static void __exit cm4040_exit(void)
 676 {
 677         pcmcia_unregister_driver(&reader_driver);
 678         unregister_chrdev(major, DEVICE_NAME);
 679         class_destroy(cmx_class);
 680 }
 681
 682 module_init(cm4040_init);
 683 module_exit(cm4040_exit);
 684 MODULE_LICENSE("Dual BSD/GPL");