Revert "ARM: tegra: tegratab: dummy change"
[linux-2.6.git] / drivers / pcmcia / pd6729.c
1 /*
2  * Driver for the Cirrus PD6729 PCI-PCMCIA bridge.
3  *
4  * Based on the i82092.c driver.
5  *
6  * This software may be used and distributed according to the terms of
7  * the GNU General Public License, incorporated herein by reference.
8  */
9
10 #include <linux/kernel.h>
11 #include <linux/module.h>
12 #include <linux/slab.h>
13 #include <linux/pci.h>
14 #include <linux/init.h>
15 #include <linux/workqueue.h>
16 #include <linux/interrupt.h>
17 #include <linux/device.h>
18 #include <linux/io.h>
19
20 #include <pcmcia/ss.h>
21
22
23 #include "pd6729.h"
24 #include "i82365.h"
25 #include "cirrus.h"
26
27 MODULE_LICENSE("GPL");
28 MODULE_DESCRIPTION("Driver for the Cirrus PD6729 PCI-PCMCIA bridge");
29 MODULE_AUTHOR("Jun Komuro <komurojun-mbn@nifty.com>");
30
31 #define MAX_SOCKETS 2
32
33 /*
34  * simple helper functions
35  * External clock time, in nanoseconds.  120 ns = 8.33 MHz
36  */
37 #define to_cycles(ns)   ((ns)/120)
38
39 #ifndef NO_IRQ
40 #define NO_IRQ  ((unsigned int)(0))
41 #endif
42
43 /*
44  * PARAMETERS
45  *  irq_mode=n
46  *     Specifies the interrupt delivery mode.  The default (1) is to use PCI
47  *     interrupts; a value of 0 selects ISA interrupts. This must be set for
48  *     correct operation of PCI card readers.
49  */
50
51 static int irq_mode = 1; /* 0 = ISA interrupt, 1 = PCI interrupt */
52
53 module_param(irq_mode, int, 0444);
54 MODULE_PARM_DESC(irq_mode,
55                 "interrupt delivery mode. 0 = ISA, 1 = PCI. default is 1");
56
57 static DEFINE_SPINLOCK(port_lock);
58
59 /* basic value read/write functions */
60
61 static unsigned char indirect_read(struct pd6729_socket *socket,
62                                    unsigned short reg)
63 {
64         unsigned long port;
65         unsigned char val;
66         unsigned long flags;
67
68         spin_lock_irqsave(&port_lock, flags);
69         reg += socket->number * 0x40;
70         port = socket->io_base;
71         outb(reg, port);
72         val = inb(port + 1);
73         spin_unlock_irqrestore(&port_lock, flags);
74
75         return val;
76 }
77
78 static unsigned short indirect_read16(struct pd6729_socket *socket,
79                                       unsigned short reg)
80 {
81         unsigned long port;
82         unsigned short tmp;
83         unsigned long flags;
84
85         spin_lock_irqsave(&port_lock, flags);
86         reg  = reg + socket->number * 0x40;
87         port = socket->io_base;
88         outb(reg, port);
89         tmp = inb(port + 1);
90         reg++;
91         outb(reg, port);
92         tmp = tmp | (inb(port + 1) << 8);
93         spin_unlock_irqrestore(&port_lock, flags);
94
95         return tmp;
96 }
97
98 static void indirect_write(struct pd6729_socket *socket, unsigned short reg,
99                            unsigned char value)
100 {
101         unsigned long port;
102         unsigned long flags;
103
104         spin_lock_irqsave(&port_lock, flags);
105         reg = reg + socket->number * 0x40;
106         port = socket->io_base;
107         outb(reg, port);
108         outb(value, port + 1);
109         spin_unlock_irqrestore(&port_lock, flags);
110 }
111
112 static void indirect_setbit(struct pd6729_socket *socket, unsigned short reg,
113                             unsigned char mask)
114 {
115         unsigned long port;
116         unsigned char val;
117         unsigned long flags;
118
119         spin_lock_irqsave(&port_lock, flags);
120         reg = reg + socket->number * 0x40;
121         port = socket->io_base;
122         outb(reg, port);
123         val = inb(port + 1);
124         val |= mask;
125         outb(reg, port);
126         outb(val, port + 1);
127         spin_unlock_irqrestore(&port_lock, flags);
128 }
129
130 static void indirect_resetbit(struct pd6729_socket *socket, unsigned short reg,
131                               unsigned char mask)
132 {
133         unsigned long port;
134         unsigned char val;
135         unsigned long flags;
136
137         spin_lock_irqsave(&port_lock, flags);
138         reg = reg + socket->number * 0x40;
139         port = socket->io_base;
140         outb(reg, port);
141         val = inb(port + 1);
142         val &= ~mask;
143         outb(reg, port);
144         outb(val, port + 1);
145         spin_unlock_irqrestore(&port_lock, flags);
146 }
147
148 static void indirect_write16(struct pd6729_socket *socket, unsigned short reg,
149                              unsigned short value)
150 {
151         unsigned long port;
152         unsigned char val;
153         unsigned long flags;
154
155         spin_lock_irqsave(&port_lock, flags);
156         reg = reg + socket->number * 0x40;
157         port = socket->io_base;
158
159         outb(reg, port);
160         val = value & 255;
161         outb(val, port + 1);
162
163         reg++;
164
165         outb(reg, port);
166         val = value >> 8;
167         outb(val, port + 1);
168         spin_unlock_irqrestore(&port_lock, flags);
169 }
170
171 /* Interrupt handler functionality */
172
173 static irqreturn_t pd6729_interrupt(int irq, void *dev)
174 {
175         struct pd6729_socket *socket = (struct pd6729_socket *)dev;
176         int i;
177         int loopcount = 0;
178         int handled = 0;
179         unsigned int events, active = 0;
180
181         while (1) {
182                 loopcount++;
183                 if (loopcount > 20) {
184                         printk(KERN_ERR "pd6729: infinite eventloop "
185                                "in interrupt\n");
186                         break;
187                 }
188
189                 active = 0;
190
191                 for (i = 0; i < MAX_SOCKETS; i++) {
192                         unsigned int csc;
193
194                         /* card status change register */
195                         csc = indirect_read(&socket[i], I365_CSC);
196                         if (csc == 0)  /* no events on this socket */
197                                 continue;
198
199                         handled = 1;
200                         events = 0;
201
202                         if (csc & I365_CSC_DETECT) {
203                                 events |= SS_DETECT;
204                                 dev_vdbg(&socket[i].socket.dev,
205                                         "Card detected in socket %i!\n", i);
206                         }
207
208                         if (indirect_read(&socket[i], I365_INTCTL)
209                                                 & I365_PC_IOCARD) {
210                                 /* For IO/CARDS, bit 0 means "read the card" */
211                                 events |= (csc & I365_CSC_STSCHG)
212                                                 ? SS_STSCHG : 0;
213                         } else {
214                                 /* Check for battery/ready events */
215                                 events |= (csc & I365_CSC_BVD1)
216                                                 ? SS_BATDEAD : 0;
217                                 events |= (csc & I365_CSC_BVD2)
218                                                 ? SS_BATWARN : 0;
219                                 events |= (csc & I365_CSC_READY)
220                                                 ? SS_READY : 0;
221                         }
222
223                         if (events)
224                                 pcmcia_parse_events(&socket[i].socket, events);
225
226                         active |= events;
227                 }
228
229                 if (active == 0) /* no more events to handle */
230                         break;
231         }
232         return IRQ_RETVAL(handled);
233 }
234
235 /* socket functions */
236
237 static void pd6729_interrupt_wrapper(unsigned long data)
238 {
239         struct pd6729_socket *socket = (struct pd6729_socket *) data;
240
241         pd6729_interrupt(0, (void *)socket);
242         mod_timer(&socket->poll_timer, jiffies + HZ);
243 }
244
245 static int pd6729_get_status(struct pcmcia_socket *sock, u_int *value)
246 {
247         struct pd6729_socket *socket
248                         = container_of(sock, struct pd6729_socket, socket);
249         unsigned int status;
250         unsigned int data;
251         struct pd6729_socket *t;
252
253         /* Interface Status Register */
254         status = indirect_read(socket, I365_STATUS);
255         *value = 0;
256
257         if ((status & I365_CS_DETECT) == I365_CS_DETECT)
258                 *value |= SS_DETECT;
259
260         /*
261          * IO cards have a different meaning of bits 0,1
262          * Also notice the inverse-logic on the bits
263          */
264         if (indirect_read(socket, I365_INTCTL) & I365_PC_IOCARD) {
265                 /* IO card */
266                 if (!(status & I365_CS_STSCHG))
267                         *value |= SS_STSCHG;
268         } else {
269                 /* non I/O card */
270                 if (!(status & I365_CS_BVD1))
271                         *value |= SS_BATDEAD;
272                 if (!(status & I365_CS_BVD2))
273                         *value |= SS_BATWARN;
274         }
275
276         if (status & I365_CS_WRPROT)
277                 *value |= SS_WRPROT;    /* card is write protected */
278
279         if (status & I365_CS_READY)
280                 *value |= SS_READY;     /* card is not busy */
281
282         if (status & I365_CS_POWERON)
283                 *value |= SS_POWERON;   /* power is applied to the card */
284
285         t = (socket->number) ? socket : socket + 1;
286         indirect_write(t, PD67_EXT_INDEX, PD67_EXTERN_DATA);
287         data = indirect_read16(t, PD67_EXT_DATA);
288         *value |= (data & PD67_EXD_VS1(socket->number)) ? 0 : SS_3VCARD;
289
290         return 0;
291 }
292
293
294 static int pd6729_set_socket(struct pcmcia_socket *sock, socket_state_t *state)
295 {
296         struct pd6729_socket *socket
297                         = container_of(sock, struct pd6729_socket, socket);
298         unsigned char reg, data;
299
300         /* First, set the global controller options */
301         indirect_write(socket, I365_GBLCTL, 0x00);
302         indirect_write(socket, I365_GENCTL, 0x00);
303
304         /* Values for the IGENC register */
305         socket->card_irq = state->io_irq;
306
307         reg = 0;
308         /* The reset bit has "inverse" logic */
309         if (!(state->flags & SS_RESET))
310                 reg |= I365_PC_RESET;
311         if (state->flags & SS_IOCARD)
312                 reg |= I365_PC_IOCARD;
313
314         /* IGENC, Interrupt and General Control Register */
315         indirect_write(socket, I365_INTCTL, reg);
316
317         /* Power registers */
318
319         reg = I365_PWR_NORESET; /* default: disable resetdrv on resume */
320
321         if (state->flags & SS_PWR_AUTO) {
322                 dev_dbg(&sock->dev, "Auto power\n");
323                 reg |= I365_PWR_AUTO;   /* automatic power mngmnt */
324         }
325         if (state->flags & SS_OUTPUT_ENA) {
326                 dev_dbg(&sock->dev, "Power Enabled\n");
327                 reg |= I365_PWR_OUT;    /* enable power */
328         }
329
330         switch (state->Vcc) {
331         case 0:
332                 break;
333         case 33:
334                 dev_dbg(&sock->dev,
335                         "setting voltage to Vcc to 3.3V on socket %i\n",
336                         socket->number);
337                 reg |= I365_VCC_5V;
338                 indirect_setbit(socket, PD67_MISC_CTL_1, PD67_MC1_VCC_3V);
339                 break;
340         case 50:
341                 dev_dbg(&sock->dev,
342                         "setting voltage to Vcc to 5V on socket %i\n",
343                         socket->number);
344                 reg |= I365_VCC_5V;
345                 indirect_resetbit(socket, PD67_MISC_CTL_1, PD67_MC1_VCC_3V);
346                 break;
347         default:
348                 dev_dbg(&sock->dev,
349                         "pd6729_set_socket called with invalid VCC power "
350                         "value: %i\n", state->Vcc);
351                 return -EINVAL;
352         }
353
354         switch (state->Vpp) {
355         case 0:
356                 dev_dbg(&sock->dev, "not setting Vpp on socket %i\n",
357                         socket->number);
358                 break;
359         case 33:
360         case 50:
361                 dev_dbg(&sock->dev, "setting Vpp to Vcc for socket %i\n",
362                         socket->number);
363                 reg |= I365_VPP1_5V;
364                 break;
365         case 120:
366                 dev_dbg(&sock->dev, "setting Vpp to 12.0\n");
367                 reg |= I365_VPP1_12V;
368                 break;
369         default:
370                 dev_dbg(&sock->dev, "pd6729: pd6729_set_socket called with "
371                         "invalid VPP power value: %i\n", state->Vpp);
372                 return -EINVAL;
373         }
374
375         /* only write if changed */
376         if (reg != indirect_read(socket, I365_POWER))
377                 indirect_write(socket, I365_POWER, reg);
378
379         if (irq_mode == 1) {
380                 /* all interrupts are to be done as PCI interrupts */
381                 data = PD67_EC1_INV_MGMT_IRQ | PD67_EC1_INV_CARD_IRQ;
382         } else
383                 data = 0;
384
385         indirect_write(socket, PD67_EXT_INDEX, PD67_EXT_CTL_1);
386         indirect_write(socket, PD67_EXT_DATA, data);
387
388         /* Enable specific interrupt events */
389
390         reg = 0x00;
391         if (state->csc_mask & SS_DETECT)
392                 reg |= I365_CSC_DETECT;
393
394         if (state->flags & SS_IOCARD) {
395                 if (state->csc_mask & SS_STSCHG)
396                         reg |= I365_CSC_STSCHG;
397         } else {
398                 if (state->csc_mask & SS_BATDEAD)
399                         reg |= I365_CSC_BVD1;
400                 if (state->csc_mask & SS_BATWARN)
401                         reg |= I365_CSC_BVD2;
402                 if (state->csc_mask & SS_READY)
403                         reg |= I365_CSC_READY;
404         }
405         if (irq_mode == 1)
406                 reg |= 0x30;    /* management IRQ: PCI INTA# = "irq 3" */
407         indirect_write(socket, I365_CSCINT, reg);
408
409         reg = indirect_read(socket, I365_INTCTL);
410         if (irq_mode == 1)
411                 reg |= 0x03;    /* card IRQ: PCI INTA# = "irq 3" */
412         else
413                 reg |= socket->card_irq;
414         indirect_write(socket, I365_INTCTL, reg);
415
416         /* now clear the (probably bogus) pending stuff by doing a dummy read */
417         (void)indirect_read(socket, I365_CSC);
418
419         return 0;
420 }
421
422 static int pd6729_set_io_map(struct pcmcia_socket *sock,
423                              struct pccard_io_map *io)
424 {
425         struct pd6729_socket *socket
426                         = container_of(sock, struct pd6729_socket, socket);
427         unsigned char map, ioctl;
428
429         map = io->map;
430
431         /* Check error conditions */
432         if (map > 1) {
433                 dev_dbg(&sock->dev, "pd6729_set_io_map with invalid map\n");
434                 return -EINVAL;
435         }
436
437         /* Turn off the window before changing anything */
438         if (indirect_read(socket, I365_ADDRWIN) & I365_ENA_IO(map))
439                 indirect_resetbit(socket, I365_ADDRWIN, I365_ENA_IO(map));
440
441         /* dev_dbg(&sock->dev, "set_io_map: Setting range to %x - %x\n",
442            io->start, io->stop);*/
443
444         /* write the new values */
445         indirect_write16(socket, I365_IO(map)+I365_W_START, io->start);
446         indirect_write16(socket, I365_IO(map)+I365_W_STOP, io->stop);
447
448         ioctl = indirect_read(socket, I365_IOCTL) & ~I365_IOCTL_MASK(map);
449
450         if (io->flags & MAP_0WS)
451                 ioctl |= I365_IOCTL_0WS(map);
452         if (io->flags & MAP_16BIT)
453                 ioctl |= I365_IOCTL_16BIT(map);
454         if (io->flags & MAP_AUTOSZ)
455                 ioctl |= I365_IOCTL_IOCS16(map);
456
457         indirect_write(socket, I365_IOCTL, ioctl);
458
459         /* Turn the window back on if needed */
460         if (io->flags & MAP_ACTIVE)
461                 indirect_setbit(socket, I365_ADDRWIN, I365_ENA_IO(map));
462
463         return 0;
464 }
465
466 static int pd6729_set_mem_map(struct pcmcia_socket *sock,
467                               struct pccard_mem_map *mem)
468 {
469         struct pd6729_socket *socket
470                          = container_of(sock, struct pd6729_socket, socket);
471         unsigned short base, i;
472         unsigned char map;
473
474         map = mem->map;
475         if (map > 4) {
476                 dev_warn(&sock->dev, "invalid map requested\n");
477                 return -EINVAL;
478         }
479
480         if ((mem->res->start > mem->res->end) || (mem->speed > 1000)) {
481                 dev_warn(&sock->dev, "invalid invalid address / speed\n");
482                 return -EINVAL;
483         }
484
485         /* Turn off the window before changing anything */
486         if (indirect_read(socket, I365_ADDRWIN) & I365_ENA_MEM(map))
487                 indirect_resetbit(socket, I365_ADDRWIN, I365_ENA_MEM(map));
488
489         /* write the start address */
490         base = I365_MEM(map);
491         i = (mem->res->start >> 12) & 0x0fff;
492         if (mem->flags & MAP_16BIT)
493                 i |= I365_MEM_16BIT;
494         if (mem->flags & MAP_0WS)
495                 i |= I365_MEM_0WS;
496         indirect_write16(socket, base + I365_W_START, i);
497
498         /* write the stop address */
499
500         i = (mem->res->end >> 12) & 0x0fff;
501         switch (to_cycles(mem->speed)) {
502         case 0:
503                 break;
504         case 1:
505                 i |= I365_MEM_WS0;
506                 break;
507         case 2:
508                 i |= I365_MEM_WS1;
509                 break;
510         default:
511                 i |= I365_MEM_WS1 | I365_MEM_WS0;
512                 break;
513         }
514
515         indirect_write16(socket, base + I365_W_STOP, i);
516
517         /* Take care of high byte */
518         indirect_write(socket, PD67_EXT_INDEX, PD67_MEM_PAGE(map));
519         indirect_write(socket, PD67_EXT_DATA, mem->res->start >> 24);
520
521         /* card start */
522
523         i = ((mem->card_start - mem->res->start) >> 12) & 0x3fff;
524         if (mem->flags & MAP_WRPROT)
525                 i |= I365_MEM_WRPROT;
526         if (mem->flags & MAP_ATTRIB) {
527                 /* dev_dbg(&sock->dev, "requesting attribute memory for "
528                    "socket %i\n", socket->number);*/
529                 i |= I365_MEM_REG;
530         } else {
531                 /* dev_dbg(&sock->dev, "requesting normal memory for "
532                    "socket %i\n", socket->number);*/
533         }
534         indirect_write16(socket, base + I365_W_OFF, i);
535
536         /* Enable the window if necessary */
537         if (mem->flags & MAP_ACTIVE)
538                 indirect_setbit(socket, I365_ADDRWIN, I365_ENA_MEM(map));
539
540         return 0;
541 }
542
543 static int pd6729_init(struct pcmcia_socket *sock)
544 {
545         int i;
546         struct resource res = { .end = 0x0fff };
547         pccard_io_map io = { 0, 0, 0, 0, 1 };
548         pccard_mem_map mem = { .res = &res, };
549
550         pd6729_set_socket(sock, &dead_socket);
551         for (i = 0; i < 2; i++) {
552                 io.map = i;
553                 pd6729_set_io_map(sock, &io);
554         }
555         for (i = 0; i < 5; i++) {
556                 mem.map = i;
557                 pd6729_set_mem_map(sock, &mem);
558         }
559
560         return 0;
561 }
562
563
564 /* the pccard structure and its functions */
565 static struct pccard_operations pd6729_operations = {
566         .init                   = pd6729_init,
567         .get_status             = pd6729_get_status,
568         .set_socket             = pd6729_set_socket,
569         .set_io_map             = pd6729_set_io_map,
570         .set_mem_map            = pd6729_set_mem_map,
571 };
572
573 static irqreturn_t pd6729_test(int irq, void *dev)
574 {
575         pr_devel("-> hit on irq %d\n", irq);
576         return IRQ_HANDLED;
577 }
578
579 static int pd6729_check_irq(int irq)
580 {
581         int ret;
582
583         ret = request_irq(irq, pd6729_test, IRQF_PROBE_SHARED, "x",
584                           pd6729_test);
585         if (ret)
586                 return -1;
587
588         free_irq(irq, pd6729_test);
589         return 0;
590 }
591
592 static u_int __devinit pd6729_isa_scan(void)
593 {
594         u_int mask0, mask = 0;
595         int i;
596
597         if (irq_mode == 1) {
598                 printk(KERN_INFO "pd6729: PCI card interrupts, "
599                        "PCI status changes\n");
600                 return 0;
601         }
602
603         mask0 = PD67_MASK;
604
605         /* just find interrupts that aren't in use */
606         for (i = 0; i < 16; i++)
607                 if ((mask0 & (1 << i)) && (pd6729_check_irq(i) == 0))
608                         mask |= (1 << i);
609
610         printk(KERN_INFO "pd6729: ISA irqs = ");
611         for (i = 0; i < 16; i++)
612                 if (mask & (1<<i))
613                         printk("%s%d", ((mask & ((1<<i)-1)) ? "," : ""), i);
614
615         if (mask == 0)
616                 printk("none!");
617         else
618                 printk("  polling status changes.\n");
619
620         return mask;
621 }
622
623 static int __devinit pd6729_pci_probe(struct pci_dev *dev,
624                                       const struct pci_device_id *id)
625 {
626         int i, j, ret;
627         u_int mask;
628         char configbyte;
629         struct pd6729_socket *socket;
630
631         socket = kzalloc(sizeof(struct pd6729_socket) * MAX_SOCKETS,
632                          GFP_KERNEL);
633         if (!socket) {
634                 dev_warn(&dev->dev, "failed to kzalloc socket.\n");
635                 return -ENOMEM;
636         }
637
638         ret = pci_enable_device(dev);
639         if (ret) {
640                 dev_warn(&dev->dev, "failed to enable pci_device.\n");
641                 goto err_out_free_mem;
642         }
643
644         if (!pci_resource_start(dev, 0)) {
645                 dev_warn(&dev->dev, "refusing to load the driver as the "
646                         "io_base is NULL.\n");
647                 goto err_out_disable;
648         }
649
650         dev_info(&dev->dev, "Cirrus PD6729 PCI to PCMCIA Bridge at 0x%llx "
651                 "on irq %d\n",
652                 (unsigned long long)pci_resource_start(dev, 0), dev->irq);
653         /*
654          * Since we have no memory BARs some firmware may not
655          * have had PCI_COMMAND_MEMORY enabled, yet the device needs it.
656          */
657         pci_read_config_byte(dev, PCI_COMMAND, &configbyte);
658         if (!(configbyte & PCI_COMMAND_MEMORY)) {
659                 dev_dbg(&dev->dev, "pd6729: Enabling PCI_COMMAND_MEMORY.\n");
660                 configbyte |= PCI_COMMAND_MEMORY;
661                 pci_write_config_byte(dev, PCI_COMMAND, configbyte);
662         }
663
664         ret = pci_request_regions(dev, "pd6729");
665         if (ret) {
666                 dev_warn(&dev->dev, "pci request region failed.\n");
667                 goto err_out_disable;
668         }
669
670         if (dev->irq == NO_IRQ)
671                 irq_mode = 0;   /* fall back to ISA interrupt mode */
672
673         mask = pd6729_isa_scan();
674         if (irq_mode == 0 && mask == 0) {
675                 dev_warn(&dev->dev, "no ISA interrupt is available.\n");
676                 goto err_out_free_res;
677         }
678
679         for (i = 0; i < MAX_SOCKETS; i++) {
680                 socket[i].io_base = pci_resource_start(dev, 0);
681                 socket[i].socket.features |= SS_CAP_PAGE_REGS | SS_CAP_PCCARD;
682                 socket[i].socket.map_size = 0x1000;
683                 socket[i].socket.irq_mask = mask;
684                 socket[i].socket.pci_irq  = dev->irq;
685                 socket[i].socket.cb_dev = dev;
686                 socket[i].socket.owner = THIS_MODULE;
687
688                 socket[i].number = i;
689
690                 socket[i].socket.ops = &pd6729_operations;
691                 socket[i].socket.resource_ops = &pccard_nonstatic_ops;
692                 socket[i].socket.dev.parent = &dev->dev;
693                 socket[i].socket.driver_data = &socket[i];
694         }
695
696         pci_set_drvdata(dev, socket);
697         if (irq_mode == 1) {
698                 /* Register the interrupt handler */
699                 ret = request_irq(dev->irq, pd6729_interrupt, IRQF_SHARED,
700                                   "pd6729", socket);
701                 if (ret) {
702                         dev_err(&dev->dev, "Failed to register irq %d\n",
703                                 dev->irq);
704                         goto err_out_free_res;
705                 }
706         } else {
707                 /* poll Card status change */
708                 init_timer(&socket->poll_timer);
709                 socket->poll_timer.function = pd6729_interrupt_wrapper;
710                 socket->poll_timer.data = (unsigned long)socket;
711                 socket->poll_timer.expires = jiffies + HZ;
712                 add_timer(&socket->poll_timer);
713         }
714
715         for (i = 0; i < MAX_SOCKETS; i++) {
716                 ret = pcmcia_register_socket(&socket[i].socket);
717                 if (ret) {
718                         dev_warn(&dev->dev, "pcmcia_register_socket failed.\n");
719                         for (j = 0; j < i ; j++)
720                                 pcmcia_unregister_socket(&socket[j].socket);
721                         goto err_out_free_res2;
722                 }
723         }
724
725         return 0;
726
727 err_out_free_res2:
728         if (irq_mode == 1)
729                 free_irq(dev->irq, socket);
730         else
731                 del_timer_sync(&socket->poll_timer);
732 err_out_free_res:
733         pci_release_regions(dev);
734 err_out_disable:
735         pci_disable_device(dev);
736
737 err_out_free_mem:
738         kfree(socket);
739         return ret;
740 }
741
742 static void __devexit pd6729_pci_remove(struct pci_dev *dev)
743 {
744         int i;
745         struct pd6729_socket *socket = pci_get_drvdata(dev);
746
747         for (i = 0; i < MAX_SOCKETS; i++) {
748                 /* Turn off all interrupt sources */
749                 indirect_write(&socket[i], I365_CSCINT, 0);
750                 indirect_write(&socket[i], I365_INTCTL, 0);
751
752                 pcmcia_unregister_socket(&socket[i].socket);
753         }
754
755         if (irq_mode == 1)
756                 free_irq(dev->irq, socket);
757         else
758                 del_timer_sync(&socket->poll_timer);
759         pci_release_regions(dev);
760         pci_disable_device(dev);
761
762         kfree(socket);
763 }
764
765 static DEFINE_PCI_DEVICE_TABLE(pd6729_pci_ids) = {
766         { PCI_DEVICE(PCI_VENDOR_ID_CIRRUS, PCI_DEVICE_ID_CIRRUS_6729) },
767         { }
768 };
769 MODULE_DEVICE_TABLE(pci, pd6729_pci_ids);
770
771 static struct pci_driver pd6729_pci_driver = {
772         .name           = "pd6729",
773         .id_table       = pd6729_pci_ids,
774         .probe          = pd6729_pci_probe,
775         .remove         = __devexit_p(pd6729_pci_remove),
776 };
777
778 static int pd6729_module_init(void)
779 {
780         return pci_register_driver(&pd6729_pci_driver);
781 }
782
783 static void pd6729_module_exit(void)
784 {
785         pci_unregister_driver(&pd6729_pci_driver);
786 }
787
788 module_init(pd6729_module_init);
789 module_exit(pd6729_module_exit);