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