drivers/pcmcia/pd6729.c

0001 /*
0002  * Driver for the Cirrus PD6729 PCI-PCMCIA bridge.
0003  *
0004  * Based on the i82092.c driver.
0005  *
0006  * This software may be used and distributed according to the terms of
0007  * the GNU General Public License, incorporated herein by reference.
0008  */
0009
0010 #include <linux/kernel.h>
0011 #include <linux/module.h>
0012 #include <linux/slab.h>
0013 #include <linux/pci.h>
0014 #include <linux/init.h>
0015 #include <linux/workqueue.h>
0016 #include <linux/interrupt.h>
0017 #include <linux/device.h>
0018 #include <linux/io.h>
0019
0020 #include <pcmcia/ss.h>
0021
0022
0023 #include "pd6729.h"
0024 #include "i82365.h"
0025 #include "cirrus.h"
0026
0027 MODULE_LICENSE("GPL");
0028 MODULE_DESCRIPTION("Driver for the Cirrus PD6729 PCI-PCMCIA bridge");
0029 MODULE_AUTHOR("Jun Komuro <komurojun-mbn@nifty.com>");
0030
0031 #define MAX_SOCKETS 2
0032
0033 /*
0034  * simple helper functions
0035  * External clock time, in nanoseconds.  120 ns = 8.33 MHz
0036  */
0037 #define to_cycles(ns)   ((ns)/120)
0038
0039 #ifndef NO_IRQ
0040 #define NO_IRQ  ((unsigned int)(0))
0041 #endif
0042
0043 /*
0044  * PARAMETERS
0045  *  irq_mode=n
0046  *     Specifies the interrupt delivery mode.  The default (1) is to use PCI
0047  *     interrupts; a value of 0 selects ISA interrupts. This must be set for
0048  *     correct operation of PCI card readers.
0049  */
0050
0051 static int irq_mode = 1; /* 0 = ISA interrupt, 1 = PCI interrupt */
0052
0053 module_param(irq_mode, int, 0444);
0054 MODULE_PARM_DESC(irq_mode,
0055         "interrupt delivery mode. 0 = ISA, 1 = PCI. default is 1");
0056
0057 static DEFINE_SPINLOCK(port_lock);
0058
0059 /* basic value read/write functions */
0060
0061 static unsigned char indirect_read(struct pd6729_socket *socket,
0062                    unsigned short reg)
0063 {
0064     unsigned long port;
0065     unsigned char val;
0066     unsigned long flags;
0067
0068     spin_lock_irqsave(&port_lock, flags);
0069     reg += socket->number * 0x40;
0070     port = socket->io_base;
0071     outb(reg, port);
0072     val = inb(port + 1);
0073     spin_unlock_irqrestore(&port_lock, flags);
0074
0075     return val;
0076 }
0077
0078 static unsigned short indirect_read16(struct pd6729_socket *socket,
0079                       unsigned short reg)
0080 {
0081     unsigned long port;
0082     unsigned short tmp;
0083     unsigned long flags;
0084
0085     spin_lock_irqsave(&port_lock, flags);
0086     reg  = reg + socket->number * 0x40;
0087     port = socket->io_base;
0088     outb(reg, port);
0089     tmp = inb(port + 1);
0090     reg++;
0091     outb(reg, port);
0092     tmp = tmp | (inb(port + 1) << 8);
0093     spin_unlock_irqrestore(&port_lock, flags);
0094
0095     return tmp;
0096 }
0097
0098 static void indirect_write(struct pd6729_socket *socket, unsigned short reg,
0099                unsigned char value)
0100 {
0101     unsigned long port;
0102     unsigned long flags;
0103
0104     spin_lock_irqsave(&port_lock, flags);
0105     reg = reg + socket->number * 0x40;
0106     port = socket->io_base;
0107     outb(reg, port);
0108     outb(value, port + 1);
0109     spin_unlock_irqrestore(&port_lock, flags);
0110 }
0111
0112 static void indirect_setbit(struct pd6729_socket *socket, unsigned short reg,
0113                 unsigned char mask)
0114 {
0115     unsigned long port;
0116     unsigned char val;
0117     unsigned long flags;
0118
0119     spin_lock_irqsave(&port_lock, flags);
0120     reg = reg + socket->number * 0x40;
0121     port = socket->io_base;
0122     outb(reg, port);
0123     val = inb(port + 1);
0124     val |= mask;
0125     outb(reg, port);
0126     outb(val, port + 1);
0127     spin_unlock_irqrestore(&port_lock, flags);
0128 }
0129
0130 static void indirect_resetbit(struct pd6729_socket *socket, unsigned short reg,
0131                   unsigned char mask)
0132 {
0133     unsigned long port;
0134     unsigned char val;
0135     unsigned long flags;
0136
0137     spin_lock_irqsave(&port_lock, flags);
0138     reg = reg + socket->number * 0x40;
0139     port = socket->io_base;
0140     outb(reg, port);
0141     val = inb(port + 1);
0142     val &= ~mask;
0143     outb(reg, port);
0144     outb(val, port + 1);
0145     spin_unlock_irqrestore(&port_lock, flags);
0146 }
0147
0148 static void indirect_write16(struct pd6729_socket *socket, unsigned short reg,
0149                  unsigned short value)
0150 {
0151     unsigned long port;
0152     unsigned char val;
0153     unsigned long flags;
0154
0155     spin_lock_irqsave(&port_lock, flags);
0156     reg = reg + socket->number * 0x40;
0157     port = socket->io_base;
0158
0159     outb(reg, port);
0160     val = value & 255;
0161     outb(val, port + 1);
0162
0163     reg++;
0164
0165     outb(reg, port);
0166     val = value >> 8;
0167     outb(val, port + 1);
0168     spin_unlock_irqrestore(&port_lock, flags);
0169 }
0170
0171 /* Interrupt handler functionality */
0172
0173 static irqreturn_t pd6729_interrupt(int irq, void *dev)
0174 {
0175     struct pd6729_socket *socket = (struct pd6729_socket *)dev;
0176     int i;
0177     int loopcount = 0;
0178     int handled = 0;
0179     unsigned int events, active = 0;
0180
0181     while (1) {
0182         loopcount++;
0183         if (loopcount > 20) {
0184             printk(KERN_ERR "pd6729: infinite eventloop "
0185                    "in interrupt\n");
0186             break;
0187         }
0188
0189         active = 0;
0190
0191         for (i = 0; i < MAX_SOCKETS; i++) {
0192             unsigned int csc;
0193
0194             /* card status change register */
0195             csc = indirect_read(&socket[i], I365_CSC);
0196             if (csc == 0)  /* no events on this socket */
0197                 continue;
0198
0199             handled = 1;
0200             events = 0;
0201
0202             if (csc & I365_CSC_DETECT) {
0203                 events |= SS_DETECT;
0204                 dev_vdbg(&socket[i].socket.dev,
0205                     "Card detected in socket %i!\n", i);
0206             }
0207
0208             if (indirect_read(&socket[i], I365_INTCTL)
0209                         & I365_PC_IOCARD) {
0210                 /* For IO/CARDS, bit 0 means "read the card" */
0211                 events |= (csc & I365_CSC_STSCHG)
0212                         ? SS_STSCHG : 0;
0213             } else {
0214                 /* Check for battery/ready events */
0215                 events |= (csc & I365_CSC_BVD1)
0216                         ? SS_BATDEAD : 0;
0217                 events |= (csc & I365_CSC_BVD2)
0218                         ? SS_BATWARN : 0;
0219                 events |= (csc & I365_CSC_READY)
0220                         ? SS_READY : 0;
0221             }
0222
0223             if (events)
0224                 pcmcia_parse_events(&socket[i].socket, events);
0225
0226             active |= events;
0227         }
0228
0229         if (active == 0) /* no more events to handle */
0230             break;
0231     }
0232     return IRQ_RETVAL(handled);
0233 }
0234
0235 /* socket functions */
0236
0237 static void pd6729_interrupt_wrapper(struct timer_list *t)
0238 {
0239     struct pd6729_socket *socket = from_timer(socket, t, poll_timer);
0240
0241     pd6729_interrupt(0, (void *)socket);
0242     mod_timer(&socket->poll_timer, jiffies + HZ);
0243 }
0244
0245 static int pd6729_get_status(struct pcmcia_socket *sock, u_int *value)
0246 {
0247     struct pd6729_socket *socket
0248             = container_of(sock, struct pd6729_socket, socket);
0249     unsigned int status;
0250     unsigned int data;
0251     struct pd6729_socket *t;
0252
0253     /* Interface Status Register */
0254     status = indirect_read(socket, I365_STATUS);
0255     *value = 0;
0256
0257     if ((status & I365_CS_DETECT) == I365_CS_DETECT)
0258         *value |= SS_DETECT;
0259
0260     /*
0261      * IO cards have a different meaning of bits 0,1
0262      * Also notice the inverse-logic on the bits
0263      */
0264     if (indirect_read(socket, I365_INTCTL) & I365_PC_IOCARD) {
0265         /* IO card */
0266         if (!(status & I365_CS_STSCHG))
0267             *value |= SS_STSCHG;
0268     } else {
0269         /* non I/O card */
0270         if (!(status & I365_CS_BVD1))
0271             *value |= SS_BATDEAD;
0272         if (!(status & I365_CS_BVD2))
0273             *value |= SS_BATWARN;
0274     }
0275
0276     if (status & I365_CS_WRPROT)
0277         *value |= SS_WRPROT;    /* card is write protected */
0278
0279     if (status & I365_CS_READY)
0280         *value |= SS_READY; /* card is not busy */
0281
0282     if (status & I365_CS_POWERON)
0283         *value |= SS_POWERON;   /* power is applied to the card */
0284
0285     t = (socket->number) ? socket : socket + 1;
0286     indirect_write(t, PD67_EXT_INDEX, PD67_EXTERN_DATA);
0287     data = indirect_read16(t, PD67_EXT_DATA);
0288     *value |= (data & PD67_EXD_VS1(socket->number)) ? 0 : SS_3VCARD;
0289
0290     return 0;
0291 }
0292
0293
0294 static int pd6729_set_socket(struct pcmcia_socket *sock, socket_state_t *state)
0295 {
0296     struct pd6729_socket *socket
0297             = container_of(sock, struct pd6729_socket, socket);
0298     unsigned char reg, data;
0299
0300     /* First, set the global controller options */
0301     indirect_write(socket, I365_GBLCTL, 0x00);
0302     indirect_write(socket, I365_GENCTL, 0x00);
0303
0304     /* Values for the IGENC register */
0305     socket->card_irq = state->io_irq;
0306
0307     reg = 0;
0308     /* The reset bit has "inverse" logic */
0309     if (!(state->flags & SS_RESET))
0310         reg |= I365_PC_RESET;
0311     if (state->flags & SS_IOCARD)
0312         reg |= I365_PC_IOCARD;
0313
0314     /* IGENC, Interrupt and General Control Register */
0315     indirect_write(socket, I365_INTCTL, reg);
0316
0317     /* Power registers */
0318
0319     reg = I365_PWR_NORESET; /* default: disable resetdrv on resume */
0320
0321     if (state->flags & SS_PWR_AUTO) {
0322         dev_dbg(&sock->dev, "Auto power\n");
0323         reg |= I365_PWR_AUTO;   /* automatic power mngmnt */
0324     }
0325     if (state->flags & SS_OUTPUT_ENA) {
0326         dev_dbg(&sock->dev, "Power Enabled\n");
0327         reg |= I365_PWR_OUT;    /* enable power */
0328     }
0329
0330     switch (state->Vcc) {
0331     case 0:
0332         break;
0333     case 33:
0334         dev_dbg(&sock->dev,
0335             "setting voltage to Vcc to 3.3V on socket %i\n",
0336             socket->number);
0337         reg |= I365_VCC_5V;
0338         indirect_setbit(socket, PD67_MISC_CTL_1, PD67_MC1_VCC_3V);
0339         break;
0340     case 50:
0341         dev_dbg(&sock->dev,
0342             "setting voltage to Vcc to 5V on socket %i\n",
0343             socket->number);
0344         reg |= I365_VCC_5V;
0345         indirect_resetbit(socket, PD67_MISC_CTL_1, PD67_MC1_VCC_3V);
0346         break;
0347     default:
0348         dev_dbg(&sock->dev,
0349             "pd6729_set_socket called with invalid VCC power "
0350             "value: %i\n", state->Vcc);
0351         return -EINVAL;
0352     }
0353
0354     switch (state->Vpp) {
0355     case 0:
0356         dev_dbg(&sock->dev, "not setting Vpp on socket %i\n",
0357             socket->number);
0358         break;
0359     case 33:
0360     case 50:
0361         dev_dbg(&sock->dev, "setting Vpp to Vcc for socket %i\n",
0362             socket->number);
0363         reg |= I365_VPP1_5V;
0364         break;
0365     case 120:
0366         dev_dbg(&sock->dev, "setting Vpp to 12.0\n");
0367         reg |= I365_VPP1_12V;
0368         break;
0369     default:
0370         dev_dbg(&sock->dev, "pd6729: pd6729_set_socket called with "
0371             "invalid VPP power value: %i\n", state->Vpp);
0372         return -EINVAL;
0373     }
0374
0375     /* only write if changed */
0376     if (reg != indirect_read(socket, I365_POWER))
0377         indirect_write(socket, I365_POWER, reg);
0378
0379     if (irq_mode == 1) {
0380         /* all interrupts are to be done as PCI interrupts */
0381         data = PD67_EC1_INV_MGMT_IRQ | PD67_EC1_INV_CARD_IRQ;
0382     } else
0383         data = 0;
0384
0385     indirect_write(socket, PD67_EXT_INDEX, PD67_EXT_CTL_1);
0386     indirect_write(socket, PD67_EXT_DATA, data);
0387
0388     /* Enable specific interrupt events */
0389
0390     reg = 0x00;
0391     if (state->csc_mask & SS_DETECT)
0392         reg |= I365_CSC_DETECT;
0393
0394     if (state->flags & SS_IOCARD) {
0395         if (state->csc_mask & SS_STSCHG)
0396             reg |= I365_CSC_STSCHG;
0397     } else {
0398         if (state->csc_mask & SS_BATDEAD)
0399             reg |= I365_CSC_BVD1;
0400         if (state->csc_mask & SS_BATWARN)
0401             reg |= I365_CSC_BVD2;
0402         if (state->csc_mask & SS_READY)
0403             reg |= I365_CSC_READY;
0404     }
0405     if (irq_mode == 1)
0406         reg |= 0x30;    /* management IRQ: PCI INTA# = "irq 3" */
0407     indirect_write(socket, I365_CSCINT, reg);
0408
0409     reg = indirect_read(socket, I365_INTCTL);
0410     if (irq_mode == 1)
0411         reg |= 0x03;    /* card IRQ: PCI INTA# = "irq 3" */
0412     else
0413         reg |= socket->card_irq;
0414     indirect_write(socket, I365_INTCTL, reg);
0415
0416     /* now clear the (probably bogus) pending stuff by doing a dummy read */
0417     (void)indirect_read(socket, I365_CSC);
0418
0419     return 0;
0420 }
0421
0422 static int pd6729_set_io_map(struct pcmcia_socket *sock,
0423                  struct pccard_io_map *io)
0424 {
0425     struct pd6729_socket *socket
0426             = container_of(sock, struct pd6729_socket, socket);
0427     unsigned char map, ioctl;
0428
0429     map = io->map;
0430
0431     /* Check error conditions */
0432     if (map > 1) {
0433         dev_dbg(&sock->dev, "pd6729_set_io_map with invalid map\n");
0434         return -EINVAL;
0435     }
0436
0437     /* Turn off the window before changing anything */
0438     if (indirect_read(socket, I365_ADDRWIN) & I365_ENA_IO(map))
0439         indirect_resetbit(socket, I365_ADDRWIN, I365_ENA_IO(map));
0440
0441     /* dev_dbg(&sock->dev, "set_io_map: Setting range to %x - %x\n",
0442        io->start, io->stop);*/
0443
0444     /* write the new values */
0445     indirect_write16(socket, I365_IO(map)+I365_W_START, io->start);
0446     indirect_write16(socket, I365_IO(map)+I365_W_STOP, io->stop);
0447
0448     ioctl = indirect_read(socket, I365_IOCTL) & ~I365_IOCTL_MASK(map);
0449
0450     if (io->flags & MAP_0WS)
0451         ioctl |= I365_IOCTL_0WS(map);
0452     if (io->flags & MAP_16BIT)
0453         ioctl |= I365_IOCTL_16BIT(map);
0454     if (io->flags & MAP_AUTOSZ)
0455         ioctl |= I365_IOCTL_IOCS16(map);
0456
0457     indirect_write(socket, I365_IOCTL, ioctl);
0458
0459     /* Turn the window back on if needed */
0460     if (io->flags & MAP_ACTIVE)
0461         indirect_setbit(socket, I365_ADDRWIN, I365_ENA_IO(map));
0462
0463     return 0;
0464 }
0465
0466 static int pd6729_set_mem_map(struct pcmcia_socket *sock,
0467                   struct pccard_mem_map *mem)
0468 {
0469     struct pd6729_socket *socket
0470              = container_of(sock, struct pd6729_socket, socket);
0471     unsigned short base, i;
0472     unsigned char map;
0473
0474     map = mem->map;
0475     if (map > 4) {
0476         dev_warn(&sock->dev, "invalid map requested\n");
0477         return -EINVAL;
0478     }
0479
0480     if ((mem->res->start > mem->res->end) || (mem->speed > 1000)) {
0481         dev_warn(&sock->dev, "invalid invalid address / speed\n");
0482         return -EINVAL;
0483     }
0484
0485     /* Turn off the window before changing anything */
0486     if (indirect_read(socket, I365_ADDRWIN) & I365_ENA_MEM(map))
0487         indirect_resetbit(socket, I365_ADDRWIN, I365_ENA_MEM(map));
0488
0489     /* write the start address */
0490     base = I365_MEM(map);
0491     i = (mem->res->start >> 12) & 0x0fff;
0492     if (mem->flags & MAP_16BIT)
0493         i |= I365_MEM_16BIT;
0494     if (mem->flags & MAP_0WS)
0495         i |= I365_MEM_0WS;
0496     indirect_write16(socket, base + I365_W_START, i);
0497
0498     /* write the stop address */
0499
0500     i = (mem->res->end >> 12) & 0x0fff;
0501     switch (to_cycles(mem->speed)) {
0502     case 0:
0503         break;
0504     case 1:
0505         i |= I365_MEM_WS0;
0506         break;
0507     case 2:
0508         i |= I365_MEM_WS1;
0509         break;
0510     default:
0511         i |= I365_MEM_WS1 | I365_MEM_WS0;
0512         break;
0513     }
0514
0515     indirect_write16(socket, base + I365_W_STOP, i);
0516
0517     /* Take care of high byte */
0518     indirect_write(socket, PD67_EXT_INDEX, PD67_MEM_PAGE(map));
0519     indirect_write(socket, PD67_EXT_DATA, mem->res->start >> 24);
0520
0521     /* card start */
0522
0523     i = ((mem->card_start - mem->res->start) >> 12) & 0x3fff;
0524     if (mem->flags & MAP_WRPROT)
0525         i |= I365_MEM_WRPROT;
0526     if (mem->flags & MAP_ATTRIB) {
0527         /* dev_dbg(&sock->dev, "requesting attribute memory for "
0528            "socket %i\n", socket->number);*/
0529         i |= I365_MEM_REG;
0530     } else {
0531         /* dev_dbg(&sock->dev, "requesting normal memory for "
0532            "socket %i\n", socket->number);*/
0533     }
0534     indirect_write16(socket, base + I365_W_OFF, i);
0535
0536     /* Enable the window if necessary */
0537     if (mem->flags & MAP_ACTIVE)
0538         indirect_setbit(socket, I365_ADDRWIN, I365_ENA_MEM(map));
0539
0540     return 0;
0541 }
0542
0543 static int pd6729_init(struct pcmcia_socket *sock)
0544 {
0545     int i;
0546     struct resource res = { .end = 0x0fff };
0547     pccard_io_map io = { 0, 0, 0, 0, 1 };
0548     pccard_mem_map mem = { .res = &res, };
0549
0550     pd6729_set_socket(sock, &dead_socket);
0551     for (i = 0; i < 2; i++) {
0552         io.map = i;
0553         pd6729_set_io_map(sock, &io);
0554     }
0555     for (i = 0; i < 5; i++) {
0556         mem.map = i;
0557         pd6729_set_mem_map(sock, &mem);
0558     }
0559
0560     return 0;
0561 }
0562
0563
0564 /* the pccard structure and its functions */
0565 static struct pccard_operations pd6729_operations = {
0566     .init           = pd6729_init,
0567     .get_status     = pd6729_get_status,
0568     .set_socket     = pd6729_set_socket,
0569     .set_io_map     = pd6729_set_io_map,
0570     .set_mem_map        = pd6729_set_mem_map,
0571 };
0572
0573 static irqreturn_t pd6729_test(int irq, void *dev)
0574 {
0575     pr_devel("-> hit on irq %d\n", irq);
0576     return IRQ_HANDLED;
0577 }
0578
0579 static int pd6729_check_irq(int irq)
0580 {
0581     int ret;
0582
0583     ret = request_irq(irq, pd6729_test, IRQF_PROBE_SHARED, "x",
0584               pd6729_test);
0585     if (ret)
0586         return -1;
0587
0588     free_irq(irq, pd6729_test);
0589     return 0;
0590 }
0591
0592 static u_int pd6729_isa_scan(void)
0593 {
0594     u_int mask0, mask = 0;
0595     int i;
0596
0597     if (irq_mode == 1) {
0598         printk(KERN_INFO "pd6729: PCI card interrupts, "
0599                "PCI status changes\n");
0600         return 0;
0601     }
0602
0603     mask0 = PD67_MASK;
0604
0605     /* just find interrupts that aren't in use */
0606     for (i = 0; i < 16; i++)
0607         if ((mask0 & (1 << i)) && (pd6729_check_irq(i) == 0))
0608             mask |= (1 << i);
0609
0610     printk(KERN_INFO "pd6729: ISA irqs = ");
0611     for (i = 0; i < 16; i++)
0612         if (mask & (1<<i))
0613             printk("%s%d", ((mask & ((1<<i)-1)) ? "," : ""), i);
0614
0615     if (mask == 0)
0616         printk("none!");
0617     else
0618         printk("  polling status changes.\n");
0619
0620     return mask;
0621 }
0622
0623 static int pd6729_pci_probe(struct pci_dev *dev,
0624                       const struct pci_device_id *id)
0625 {
0626     int i, j, ret;
0627     u_int mask;
0628     char configbyte;
0629     struct pd6729_socket *socket;
0630
0631     socket = kcalloc(MAX_SOCKETS, sizeof(struct pd6729_socket),
0632              GFP_KERNEL);
0633     if (!socket) {
0634         dev_warn(&dev->dev, "failed to kzalloc socket.\n");
0635         return -ENOMEM;
0636     }
0637
0638     ret = pci_enable_device(dev);
0639     if (ret) {
0640         dev_warn(&dev->dev, "failed to enable pci_device.\n");
0641         goto err_out_free_mem;
0642     }
0643
0644     if (!pci_resource_start(dev, 0)) {
0645         dev_warn(&dev->dev, "refusing to load the driver as the "
0646             "io_base is NULL.\n");
0647         ret = -ENOMEM;
0648         goto err_out_disable;
0649     }
0650
0651     dev_info(&dev->dev, "Cirrus PD6729 PCI to PCMCIA Bridge at 0x%llx "
0652         "on irq %d\n",
0653         (unsigned long long)pci_resource_start(dev, 0), dev->irq);
0654     /*
0655      * Since we have no memory BARs some firmware may not
0656      * have had PCI_COMMAND_MEMORY enabled, yet the device needs it.
0657      */
0658     pci_read_config_byte(dev, PCI_COMMAND, &configbyte);
0659     if (!(configbyte & PCI_COMMAND_MEMORY)) {
0660         dev_dbg(&dev->dev, "pd6729: Enabling PCI_COMMAND_MEMORY.\n");
0661         configbyte |= PCI_COMMAND_MEMORY;
0662         pci_write_config_byte(dev, PCI_COMMAND, configbyte);
0663     }
0664
0665     ret = pci_request_regions(dev, "pd6729");
0666     if (ret) {
0667         dev_warn(&dev->dev, "pci request region failed.\n");
0668         goto err_out_disable;
0669     }
0670
0671     if (dev->irq == NO_IRQ)
0672         irq_mode = 0;   /* fall back to ISA interrupt mode */
0673
0674     mask = pd6729_isa_scan();
0675     if (irq_mode == 0 && mask == 0) {
0676         dev_warn(&dev->dev, "no ISA interrupt is available.\n");
0677         ret = -ENODEV;
0678         goto err_out_free_res;
0679     }
0680
0681     for (i = 0; i < MAX_SOCKETS; i++) {
0682         socket[i].io_base = pci_resource_start(dev, 0);
0683         socket[i].socket.features |= SS_CAP_PAGE_REGS | SS_CAP_PCCARD;
0684         socket[i].socket.map_size = 0x1000;
0685         socket[i].socket.irq_mask = mask;
0686         socket[i].socket.pci_irq  = dev->irq;
0687         socket[i].socket.cb_dev = dev;
0688         socket[i].socket.owner = THIS_MODULE;
0689
0690         socket[i].number = i;
0691
0692         socket[i].socket.ops = &pd6729_operations;
0693         socket[i].socket.resource_ops = &pccard_nonstatic_ops;
0694         socket[i].socket.dev.parent = &dev->dev;
0695         socket[i].socket.driver_data = &socket[i];
0696     }
0697
0698     pci_set_drvdata(dev, socket);
0699     if (irq_mode == 1) {
0700         /* Register the interrupt handler */
0701         ret = request_irq(dev->irq, pd6729_interrupt, IRQF_SHARED,
0702                   "pd6729", socket);
0703         if (ret) {
0704             dev_err(&dev->dev, "Failed to register irq %d\n",
0705                 dev->irq);
0706             goto err_out_free_res;
0707         }
0708     } else {
0709         /* poll Card status change */
0710         timer_setup(&socket->poll_timer, pd6729_interrupt_wrapper, 0);
0711         mod_timer(&socket->poll_timer, jiffies + HZ);
0712     }
0713
0714     for (i = 0; i < MAX_SOCKETS; i++) {
0715         ret = pcmcia_register_socket(&socket[i].socket);
0716         if (ret) {
0717             dev_warn(&dev->dev, "pcmcia_register_socket failed.\n");
0718             for (j = 0; j < i ; j++)
0719                 pcmcia_unregister_socket(&socket[j].socket);
0720             goto err_out_free_res2;
0721         }
0722     }
0723
0724     return 0;
0725
0726 err_out_free_res2:
0727     if (irq_mode == 1)
0728         free_irq(dev->irq, socket);
0729     else
0730         del_timer_sync(&socket->poll_timer);
0731 err_out_free_res:
0732     pci_release_regions(dev);
0733 err_out_disable:
0734     pci_disable_device(dev);
0735
0736 err_out_free_mem:
0737     kfree(socket);
0738     return ret;
0739 }
0740
0741 static void pd6729_pci_remove(struct pci_dev *dev)
0742 {
0743     int i;
0744     struct pd6729_socket *socket = pci_get_drvdata(dev);
0745
0746     for (i = 0; i < MAX_SOCKETS; i++) {
0747         /* Turn off all interrupt sources */
0748         indirect_write(&socket[i], I365_CSCINT, 0);
0749         indirect_write(&socket[i], I365_INTCTL, 0);
0750
0751         pcmcia_unregister_socket(&socket[i].socket);
0752     }
0753
0754     if (irq_mode == 1)
0755         free_irq(dev->irq, socket);
0756     else
0757         del_timer_sync(&socket->poll_timer);
0758     pci_release_regions(dev);
0759     pci_disable_device(dev);
0760
0761     kfree(socket);
0762 }
0763
0764 static const struct pci_device_id pd6729_pci_ids[] = {
0765     { PCI_DEVICE(PCI_VENDOR_ID_CIRRUS, PCI_DEVICE_ID_CIRRUS_6729) },
0766     { }
0767 };
0768 MODULE_DEVICE_TABLE(pci, pd6729_pci_ids);
0769
0770 static struct pci_driver pd6729_pci_driver = {
0771     .name       = "pd6729",
0772     .id_table   = pd6729_pci_ids,
0773     .probe      = pd6729_pci_probe,
0774     .remove     = pd6729_pci_remove,
0775 };
0776
0777 module_pci_driver(pd6729_pci_driver);