char/pcmcia/cm4040_cs.c

0001 /*
0002  * A driver for the Omnikey PCMCIA smartcard reader CardMan 4040
0003  *
0004  * (c) 2000-2004 Omnikey AG (http://www.omnikey.com/)
0005  *
0006  * (C) 2005-2006 Harald Welte <laforge@gnumonks.org>
0007  *  - add support for poll()
0008  *  - driver cleanup
0009  *  - add waitqueues
0010  *  - adhere to linux kernel coding style and policies
0011  *  - support 2.6.13 "new style" pcmcia interface
0012  *  - add class interface for udev device creation
0013  *
0014  * The device basically is a USB CCID compliant device that has been
0015  * attached to an I/O-Mapped FIFO.
0016  *
0017  * All rights reserved, Dual BSD/GPL Licensed.
0018  */
0019
0020 #include <linux/kernel.h>
0021 #include <linux/module.h>
0022 #include <linux/slab.h>
0023 #include <linux/init.h>
0024 #include <linux/fs.h>
0025 #include <linux/delay.h>
0026 #include <linux/poll.h>
0027 #include <linux/mutex.h>
0028 #include <linux/wait.h>
0029 #include <linux/uaccess.h>
0030 #include <asm/io.h>
0031
0032 #include <pcmcia/cistpl.h>
0033 #include <pcmcia/cisreg.h>
0034 #include <pcmcia/ciscode.h>
0035 #include <pcmcia/ds.h>
0036
0037 #include "cm4040_cs.h"
0038
0039
0040 #define reader_to_dev(x)    (&x->p_dev->dev)
0041
0042 /* n (debug level) is ignored */
0043 /* additional debug output may be enabled by re-compiling with
0044  * CM4040_DEBUG set */
0045 /* #define CM4040_DEBUG */
0046 #define DEBUGP(n, rdr, x, args...) do {         \
0047         dev_dbg(reader_to_dev(rdr), "%s:" x,    \
0048                __func__ , ## args);     \
0049     } while (0)
0050
0051 static DEFINE_MUTEX(cm4040_mutex);
0052
0053 #define CCID_DRIVER_BULK_DEFAULT_TIMEOUT    (150*HZ)
0054 #define CCID_DRIVER_ASYNC_POWERUP_TIMEOUT   (35*HZ)
0055 #define CCID_DRIVER_MINIMUM_TIMEOUT         (3*HZ)
0056 #define READ_WRITE_BUFFER_SIZE 512
0057 #define POLL_LOOP_COUNT             1000
0058
0059 /* how often to poll for fifo status change */
0060 #define POLL_PERIOD                 msecs_to_jiffies(10)
0061
0062 static void reader_release(struct pcmcia_device *link);
0063
0064 static int major;
0065 static struct class *cmx_class;
0066
0067 #define     BS_READABLE 0x01
0068 #define     BS_WRITABLE 0x02
0069
0070 struct reader_dev {
0071     struct pcmcia_device    *p_dev;
0072     wait_queue_head_t   devq;
0073     wait_queue_head_t   poll_wait;
0074     wait_queue_head_t   read_wait;
0075     wait_queue_head_t   write_wait;
0076     unsigned long       buffer_status;
0077     unsigned long       timeout;
0078     unsigned char       s_buf[READ_WRITE_BUFFER_SIZE];
0079     unsigned char       r_buf[READ_WRITE_BUFFER_SIZE];
0080     struct timer_list   poll_timer;
0081 };
0082
0083 static struct pcmcia_device *dev_table[CM_MAX_DEV];
0084
0085 #ifndef CM4040_DEBUG
0086 #define xoutb   outb
0087 #define xinb    inb
0088 #else
0089 static inline void xoutb(unsigned char val, unsigned short port)
0090 {
0091     pr_debug("outb(val=%.2x,port=%.4x)\n", val, port);
0092     outb(val, port);
0093 }
0094
0095 static inline unsigned char xinb(unsigned short port)
0096 {
0097     unsigned char val;
0098
0099     val = inb(port);
0100     pr_debug("%.2x=inb(%.4x)\n", val, port);
0101     return val;
0102 }
0103 #endif
0104
0105 /* poll the device fifo status register.  not to be confused with
0106  * the poll syscall. */
0107 static void cm4040_do_poll(struct timer_list *t)
0108 {
0109     struct reader_dev *dev = from_timer(dev, t, poll_timer);
0110     unsigned int obs = xinb(dev->p_dev->resource[0]->start
0111                 + REG_OFFSET_BUFFER_STATUS);
0112
0113     if ((obs & BSR_BULK_IN_FULL)) {
0114         set_bit(BS_READABLE, &dev->buffer_status);
0115         DEBUGP(4, dev, "waking up read_wait\n");
0116         wake_up_interruptible(&dev->read_wait);
0117     } else
0118         clear_bit(BS_READABLE, &dev->buffer_status);
0119
0120     if (!(obs & BSR_BULK_OUT_FULL)) {
0121         set_bit(BS_WRITABLE, &dev->buffer_status);
0122         DEBUGP(4, dev, "waking up write_wait\n");
0123         wake_up_interruptible(&dev->write_wait);
0124     } else
0125         clear_bit(BS_WRITABLE, &dev->buffer_status);
0126
0127     if (dev->buffer_status)
0128         wake_up_interruptible(&dev->poll_wait);
0129
0130     mod_timer(&dev->poll_timer, jiffies + POLL_PERIOD);
0131 }
0132
0133 static void cm4040_stop_poll(struct reader_dev *dev)
0134 {
0135     del_timer_sync(&dev->poll_timer);
0136 }
0137
0138 static int wait_for_bulk_out_ready(struct reader_dev *dev)
0139 {
0140     int i, rc;
0141     int iobase = dev->p_dev->resource[0]->start;
0142
0143     for (i = 0; i < POLL_LOOP_COUNT; i++) {
0144         if ((xinb(iobase + REG_OFFSET_BUFFER_STATUS)
0145             & BSR_BULK_OUT_FULL) == 0) {
0146             DEBUGP(4, dev, "BulkOut empty (i=%d)\n", i);
0147             return 1;
0148         }
0149     }
0150
0151     DEBUGP(4, dev, "wait_event_interruptible_timeout(timeout=%ld\n",
0152         dev->timeout);
0153     rc = wait_event_interruptible_timeout(dev->write_wait,
0154                           test_and_clear_bit(BS_WRITABLE,
0155                                &dev->buffer_status),
0156                           dev->timeout);
0157
0158     if (rc > 0)
0159         DEBUGP(4, dev, "woke up: BulkOut empty\n");
0160     else if (rc == 0)
0161         DEBUGP(4, dev, "woke up: BulkOut full, returning 0 :(\n");
0162     else if (rc < 0)
0163         DEBUGP(4, dev, "woke up: signal arrived\n");
0164
0165     return rc;
0166 }
0167
0168 /* Write to Sync Control Register */
0169 static int write_sync_reg(unsigned char val, struct reader_dev *dev)
0170 {
0171     int iobase = dev->p_dev->resource[0]->start;
0172     int rc;
0173
0174     rc = wait_for_bulk_out_ready(dev);
0175     if (rc <= 0)
0176         return rc;
0177
0178     xoutb(val, iobase + REG_OFFSET_SYNC_CONTROL);
0179     rc = wait_for_bulk_out_ready(dev);
0180     if (rc <= 0)
0181         return rc;
0182
0183     return 1;
0184 }
0185
0186 static int wait_for_bulk_in_ready(struct reader_dev *dev)
0187 {
0188     int i, rc;
0189     int iobase = dev->p_dev->resource[0]->start;
0190
0191     for (i = 0; i < POLL_LOOP_COUNT; i++) {
0192         if ((xinb(iobase + REG_OFFSET_BUFFER_STATUS)
0193             & BSR_BULK_IN_FULL) == BSR_BULK_IN_FULL) {
0194             DEBUGP(3, dev, "BulkIn full (i=%d)\n", i);
0195             return 1;
0196         }
0197     }
0198
0199     DEBUGP(4, dev, "wait_event_interruptible_timeout(timeout=%ld\n",
0200         dev->timeout);
0201     rc = wait_event_interruptible_timeout(dev->read_wait,
0202                           test_and_clear_bit(BS_READABLE,
0203                             &dev->buffer_status),
0204                           dev->timeout);
0205     if (rc > 0)
0206         DEBUGP(4, dev, "woke up: BulkIn full\n");
0207     else if (rc == 0)
0208         DEBUGP(4, dev, "woke up: BulkIn not full, returning 0 :(\n");
0209     else if (rc < 0)
0210         DEBUGP(4, dev, "woke up: signal arrived\n");
0211
0212     return rc;
0213 }
0214
0215 static ssize_t cm4040_read(struct file *filp, char __user *buf,
0216             size_t count, loff_t *ppos)
0217 {
0218     struct reader_dev *dev = filp->private_data;
0219     int iobase = dev->p_dev->resource[0]->start;
0220     size_t bytes_to_read;
0221     unsigned long i;
0222     size_t min_bytes_to_read;
0223     int rc;
0224
0225     DEBUGP(2, dev, "-> cm4040_read(%s,%d)\n", current->comm, current->pid);
0226
0227     if (count == 0)
0228         return 0;
0229
0230     if (count < 10)
0231         return -EFAULT;
0232
0233     if (filp->f_flags & O_NONBLOCK) {
0234         DEBUGP(4, dev, "filep->f_flags O_NONBLOCK set\n");
0235         DEBUGP(2, dev, "<- cm4040_read (failure)\n");
0236         return -EAGAIN;
0237     }
0238
0239     if (!pcmcia_dev_present(dev->p_dev))
0240         return -ENODEV;
0241
0242     for (i = 0; i < 5; i++) {
0243         rc = wait_for_bulk_in_ready(dev);
0244         if (rc <= 0) {
0245             DEBUGP(5, dev, "wait_for_bulk_in_ready rc=%.2x\n", rc);
0246             DEBUGP(2, dev, "<- cm4040_read (failed)\n");
0247             if (rc == -ERESTARTSYS)
0248                 return rc;
0249             return -EIO;
0250         }
0251         dev->r_buf[i] = xinb(iobase + REG_OFFSET_BULK_IN);
0252 #ifdef CM4040_DEBUG
0253         pr_debug("%lu:%2x ", i, dev->r_buf[i]);
0254     }
0255     pr_debug("\n");
0256 #else
0257     }
0258 #endif
0259
0260     bytes_to_read = 5 + le32_to_cpu(*(__le32 *)&dev->r_buf[1]);
0261
0262     DEBUGP(6, dev, "BytesToRead=%zu\n", bytes_to_read);
0263
0264     min_bytes_to_read = min(count, bytes_to_read + 5);
0265     min_bytes_to_read = min_t(size_t, min_bytes_to_read, READ_WRITE_BUFFER_SIZE);
0266
0267     DEBUGP(6, dev, "Min=%zu\n", min_bytes_to_read);
0268
0269     for (i = 0; i < (min_bytes_to_read-5); i++) {
0270         rc = wait_for_bulk_in_ready(dev);
0271         if (rc <= 0) {
0272             DEBUGP(5, dev, "wait_for_bulk_in_ready rc=%.2x\n", rc);
0273             DEBUGP(2, dev, "<- cm4040_read (failed)\n");
0274             if (rc == -ERESTARTSYS)
0275                 return rc;
0276             return -EIO;
0277         }
0278         dev->r_buf[i+5] = xinb(iobase + REG_OFFSET_BULK_IN);
0279 #ifdef CM4040_DEBUG
0280         pr_debug("%lu:%2x ", i, dev->r_buf[i]);
0281     }
0282     pr_debug("\n");
0283 #else
0284     }
0285 #endif
0286
0287     *ppos = min_bytes_to_read;
0288     if (copy_to_user(buf, dev->r_buf, min_bytes_to_read))
0289         return -EFAULT;
0290
0291     rc = wait_for_bulk_in_ready(dev);
0292     if (rc <= 0) {
0293         DEBUGP(5, dev, "wait_for_bulk_in_ready rc=%.2x\n", rc);
0294         DEBUGP(2, dev, "<- cm4040_read (failed)\n");
0295         if (rc == -ERESTARTSYS)
0296             return rc;
0297         return -EIO;
0298     }
0299
0300     rc = write_sync_reg(SCR_READER_TO_HOST_DONE, dev);
0301     if (rc <= 0) {
0302         DEBUGP(5, dev, "write_sync_reg c=%.2x\n", rc);
0303         DEBUGP(2, dev, "<- cm4040_read (failed)\n");
0304         if (rc == -ERESTARTSYS)
0305             return rc;
0306         else
0307             return -EIO;
0308     }
0309
0310     xinb(iobase + REG_OFFSET_BULK_IN);
0311
0312     DEBUGP(2, dev, "<- cm4040_read (successfully)\n");
0313     return min_bytes_to_read;
0314 }
0315
0316 static ssize_t cm4040_write(struct file *filp, const char __user *buf,
0317              size_t count, loff_t *ppos)
0318 {
0319     struct reader_dev *dev = filp->private_data;
0320     int iobase = dev->p_dev->resource[0]->start;
0321     ssize_t rc;
0322     int i;
0323     unsigned int bytes_to_write;
0324
0325     DEBUGP(2, dev, "-> cm4040_write(%s,%d)\n", current->comm, current->pid);
0326
0327     if (count == 0) {
0328         DEBUGP(2, dev, "<- cm4040_write empty read (successfully)\n");
0329         return 0;
0330     }
0331
0332     if ((count < 5) || (count > READ_WRITE_BUFFER_SIZE)) {
0333         DEBUGP(2, dev, "<- cm4040_write buffersize=%zd < 5\n", count);
0334         return -EIO;
0335     }
0336
0337     if (filp->f_flags & O_NONBLOCK) {
0338         DEBUGP(4, dev, "filep->f_flags O_NONBLOCK set\n");
0339         DEBUGP(4, dev, "<- cm4040_write (failure)\n");
0340         return -EAGAIN;
0341     }
0342
0343     if (!pcmcia_dev_present(dev->p_dev))
0344         return -ENODEV;
0345
0346     bytes_to_write = count;
0347     if (copy_from_user(dev->s_buf, buf, bytes_to_write))
0348         return -EFAULT;
0349
0350     switch (dev->s_buf[0]) {
0351         case CMD_PC_TO_RDR_XFRBLOCK:
0352         case CMD_PC_TO_RDR_SECURE:
0353         case CMD_PC_TO_RDR_TEST_SECURE:
0354         case CMD_PC_TO_RDR_OK_SECURE:
0355             dev->timeout = CCID_DRIVER_BULK_DEFAULT_TIMEOUT;
0356             break;
0357
0358         case CMD_PC_TO_RDR_ICCPOWERON:
0359             dev->timeout = CCID_DRIVER_ASYNC_POWERUP_TIMEOUT;
0360             break;
0361
0362         case CMD_PC_TO_RDR_GETSLOTSTATUS:
0363         case CMD_PC_TO_RDR_ICCPOWEROFF:
0364         case CMD_PC_TO_RDR_GETPARAMETERS:
0365         case CMD_PC_TO_RDR_RESETPARAMETERS:
0366         case CMD_PC_TO_RDR_SETPARAMETERS:
0367         case CMD_PC_TO_RDR_ESCAPE:
0368         case CMD_PC_TO_RDR_ICCCLOCK:
0369         default:
0370             dev->timeout = CCID_DRIVER_MINIMUM_TIMEOUT;
0371             break;
0372     }
0373
0374     rc = write_sync_reg(SCR_HOST_TO_READER_START, dev);
0375     if (rc <= 0) {
0376         DEBUGP(5, dev, "write_sync_reg c=%.2zx\n", rc);
0377         DEBUGP(2, dev, "<- cm4040_write (failed)\n");
0378         if (rc == -ERESTARTSYS)
0379             return rc;
0380         else
0381             return -EIO;
0382     }
0383
0384     DEBUGP(4, dev, "start \n");
0385
0386     for (i = 0; i < bytes_to_write; i++) {
0387         rc = wait_for_bulk_out_ready(dev);
0388         if (rc <= 0) {
0389             DEBUGP(5, dev, "wait_for_bulk_out_ready rc=%.2zx\n",
0390                    rc);
0391             DEBUGP(2, dev, "<- cm4040_write (failed)\n");
0392             if (rc == -ERESTARTSYS)
0393                 return rc;
0394             else
0395                 return -EIO;
0396         }
0397
0398         xoutb(dev->s_buf[i],iobase + REG_OFFSET_BULK_OUT);
0399     }
0400     DEBUGP(4, dev, "end\n");
0401
0402     rc = write_sync_reg(SCR_HOST_TO_READER_DONE, dev);
0403
0404     if (rc <= 0) {
0405         DEBUGP(5, dev, "write_sync_reg c=%.2zx\n", rc);
0406         DEBUGP(2, dev, "<- cm4040_write (failed)\n");
0407         if (rc == -ERESTARTSYS)
0408             return rc;
0409         else
0410             return -EIO;
0411     }
0412
0413     DEBUGP(2, dev, "<- cm4040_write (successfully)\n");
0414     return count;
0415 }
0416
0417 static __poll_t cm4040_poll(struct file *filp, poll_table *wait)
0418 {
0419     struct reader_dev *dev = filp->private_data;
0420     __poll_t mask = 0;
0421
0422     poll_wait(filp, &dev->poll_wait, wait);
0423
0424     if (test_and_clear_bit(BS_READABLE, &dev->buffer_status))
0425         mask |= EPOLLIN | EPOLLRDNORM;
0426     if (test_and_clear_bit(BS_WRITABLE, &dev->buffer_status))
0427         mask |= EPOLLOUT | EPOLLWRNORM;
0428
0429     DEBUGP(2, dev, "<- cm4040_poll(%u)\n", mask);
0430
0431     return mask;
0432 }
0433
0434 static int cm4040_open(struct inode *inode, struct file *filp)
0435 {
0436     struct reader_dev *dev;
0437     struct pcmcia_device *link;
0438     int minor = iminor(inode);
0439     int ret;
0440
0441     if (minor >= CM_MAX_DEV)
0442         return -ENODEV;
0443
0444     mutex_lock(&cm4040_mutex);
0445     link = dev_table[minor];
0446     if (link == NULL || !pcmcia_dev_present(link)) {
0447         ret = -ENODEV;
0448         goto out;
0449     }
0450
0451     if (link->open) {
0452         ret = -EBUSY;
0453         goto out;
0454     }
0455
0456     dev = link->priv;
0457     filp->private_data = dev;
0458
0459     if (filp->f_flags & O_NONBLOCK) {
0460         DEBUGP(4, dev, "filep->f_flags O_NONBLOCK set\n");
0461         ret = -EAGAIN;
0462         goto out;
0463     }
0464
0465     link->open = 1;
0466
0467     mod_timer(&dev->poll_timer, jiffies + POLL_PERIOD);
0468
0469     DEBUGP(2, dev, "<- cm4040_open (successfully)\n");
0470     ret = nonseekable_open(inode, filp);
0471 out:
0472     mutex_unlock(&cm4040_mutex);
0473     return ret;
0474 }
0475
0476 static int cm4040_close(struct inode *inode, struct file *filp)
0477 {
0478     struct reader_dev *dev = filp->private_data;
0479     struct pcmcia_device *link;
0480     int minor = iminor(inode);
0481
0482     DEBUGP(2, dev, "-> cm4040_close(maj/min=%d.%d)\n", imajor(inode),
0483           iminor(inode));
0484
0485     if (minor >= CM_MAX_DEV)
0486         return -ENODEV;
0487
0488     link = dev_table[minor];
0489     if (link == NULL)
0490         return -ENODEV;
0491
0492     cm4040_stop_poll(dev);
0493
0494     link->open = 0;
0495     wake_up(&dev->devq);
0496
0497     DEBUGP(2, dev, "<- cm4040_close\n");
0498     return 0;
0499 }
0500
0501 static void cm4040_reader_release(struct pcmcia_device *link)
0502 {
0503     struct reader_dev *dev = link->priv;
0504
0505     DEBUGP(3, dev, "-> cm4040_reader_release\n");
0506     while (link->open) {
0507         DEBUGP(3, dev, MODULE_NAME ": delaying release "
0508                "until process has terminated\n");
0509         wait_event(dev->devq, (link->open == 0));
0510     }
0511     DEBUGP(3, dev, "<- cm4040_reader_release\n");
0512     return;
0513 }
0514
0515 static int cm4040_config_check(struct pcmcia_device *p_dev, void *priv_data)
0516 {
0517     return pcmcia_request_io(p_dev);
0518 }
0519
0520
0521 static int reader_config(struct pcmcia_device *link, int devno)
0522 {
0523     struct reader_dev *dev;
0524     int fail_rc;
0525
0526     link->config_flags |= CONF_AUTO_SET_IO;
0527
0528     if (pcmcia_loop_config(link, cm4040_config_check, NULL))
0529         goto cs_release;
0530
0531     fail_rc = pcmcia_enable_device(link);
0532     if (fail_rc != 0) {
0533         dev_info(&link->dev, "pcmcia_enable_device failed 0x%x\n",
0534              fail_rc);
0535         goto cs_release;
0536     }
0537
0538     dev = link->priv;
0539
0540     DEBUGP(2, dev, "device " DEVICE_NAME "%d at %pR\n", devno,
0541           link->resource[0]);
0542     DEBUGP(2, dev, "<- reader_config (succ)\n");
0543
0544     return 0;
0545
0546 cs_release:
0547     reader_release(link);
0548     return -ENODEV;
0549 }
0550
0551 static void reader_release(struct pcmcia_device *link)
0552 {
0553     cm4040_reader_release(link);
0554     pcmcia_disable_device(link);
0555 }
0556
0557 static int reader_probe(struct pcmcia_device *link)
0558 {
0559     struct reader_dev *dev;
0560     int i, ret;
0561
0562     for (i = 0; i < CM_MAX_DEV; i++) {
0563         if (dev_table[i] == NULL)
0564             break;
0565     }
0566
0567     if (i == CM_MAX_DEV)
0568         return -ENODEV;
0569
0570     dev = kzalloc(sizeof(struct reader_dev), GFP_KERNEL);
0571     if (dev == NULL)
0572         return -ENOMEM;
0573
0574     dev->timeout = CCID_DRIVER_MINIMUM_TIMEOUT;
0575     dev->buffer_status = 0;
0576
0577     link->priv = dev;
0578     dev->p_dev = link;
0579
0580     dev_table[i] = link;
0581
0582     init_waitqueue_head(&dev->devq);
0583     init_waitqueue_head(&dev->poll_wait);
0584     init_waitqueue_head(&dev->read_wait);
0585     init_waitqueue_head(&dev->write_wait);
0586     timer_setup(&dev->poll_timer, cm4040_do_poll, 0);
0587
0588     ret = reader_config(link, i);
0589     if (ret) {
0590         dev_table[i] = NULL;
0591         kfree(dev);
0592         return ret;
0593     }
0594
0595     device_create(cmx_class, NULL, MKDEV(major, i), NULL, "cmx%d", i);
0596
0597     return 0;
0598 }
0599
0600 static void reader_detach(struct pcmcia_device *link)
0601 {
0602     struct reader_dev *dev = link->priv;
0603     int devno;
0604
0605     /* find device */
0606     for (devno = 0; devno < CM_MAX_DEV; devno++) {
0607         if (dev_table[devno] == link)
0608             break;
0609     }
0610     if (devno == CM_MAX_DEV)
0611         return;
0612
0613     reader_release(link);
0614
0615     dev_table[devno] = NULL;
0616     kfree(dev);
0617
0618     device_destroy(cmx_class, MKDEV(major, devno));
0619
0620     return;
0621 }
0622
0623 static const struct file_operations reader_fops = {
0624     .owner      = THIS_MODULE,
0625     .read       = cm4040_read,
0626     .write      = cm4040_write,
0627     .open       = cm4040_open,
0628     .release    = cm4040_close,
0629     .poll       = cm4040_poll,
0630     .llseek     = no_llseek,
0631 };
0632
0633 static const struct pcmcia_device_id cm4040_ids[] = {
0634     PCMCIA_DEVICE_MANF_CARD(0x0223, 0x0200),
0635     PCMCIA_DEVICE_PROD_ID12("OMNIKEY", "CardMan 4040",
0636                 0xE32CDD8C, 0x8F23318B),
0637     PCMCIA_DEVICE_NULL,
0638 };
0639 MODULE_DEVICE_TABLE(pcmcia, cm4040_ids);
0640
0641 static struct pcmcia_driver reader_driver = {
0642     .owner      = THIS_MODULE,
0643     .name       = "cm4040_cs",
0644     .probe      = reader_probe,
0645     .remove     = reader_detach,
0646     .id_table   = cm4040_ids,
0647 };
0648
0649 static int __init cm4040_init(void)
0650 {
0651     int rc;
0652
0653     cmx_class = class_create(THIS_MODULE, "cardman_4040");
0654     if (IS_ERR(cmx_class))
0655         return PTR_ERR(cmx_class);
0656
0657     major = register_chrdev(0, DEVICE_NAME, &reader_fops);
0658     if (major < 0) {
0659         printk(KERN_WARNING MODULE_NAME
0660             ": could not get major number\n");
0661         class_destroy(cmx_class);
0662         return major;
0663     }
0664
0665     rc = pcmcia_register_driver(&reader_driver);
0666     if (rc < 0) {
0667         unregister_chrdev(major, DEVICE_NAME);
0668         class_destroy(cmx_class);
0669         return rc;
0670     }
0671
0672     return 0;
0673 }
0674
0675 static void __exit cm4040_exit(void)
0676 {
0677     pcmcia_unregister_driver(&reader_driver);
0678     unregister_chrdev(major, DEVICE_NAME);
0679     class_destroy(cmx_class);
0680 }
0681
0682 module_init(cm4040_init);
0683 module_exit(cm4040_exit);
0684 MODULE_LICENSE("Dual BSD/GPL");