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
indirect_read(struct pd6729_socket * socket,unsigned short reg)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
indirect_read16(struct pd6729_socket * socket,unsigned short reg)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
indirect_write(struct pd6729_socket * socket,unsigned short reg,unsigned char value)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
indirect_setbit(struct pd6729_socket * socket,unsigned short reg,unsigned char mask)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
indirect_resetbit(struct pd6729_socket * socket,unsigned short reg,unsigned char mask)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
indirect_write16(struct pd6729_socket * socket,unsigned short reg,unsigned short value)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
pd6729_interrupt(int irq,void * dev)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
pd6729_interrupt_wrapper(struct timer_list * t)237 static void pd6729_interrupt_wrapper(struct timer_list *t)
238 {
239 struct pd6729_socket *socket = timer_container_of(socket, t,
240 poll_timer);
241
242 pd6729_interrupt(0, (void *)socket);
243 mod_timer(&socket->poll_timer, jiffies + HZ);
244 }
245
pd6729_get_status(struct pcmcia_socket * sock,u_int * value)246 static int pd6729_get_status(struct pcmcia_socket *sock, u_int *value)
247 {
248 struct pd6729_socket *socket
249 = container_of(sock, struct pd6729_socket, socket);
250 unsigned int status;
251 unsigned int data;
252 struct pd6729_socket *t;
253
254 /* Interface Status Register */
255 status = indirect_read(socket, I365_STATUS);
256 *value = 0;
257
258 if ((status & I365_CS_DETECT) == I365_CS_DETECT)
259 *value |= SS_DETECT;
260
261 /*
262 * IO cards have a different meaning of bits 0,1
263 * Also notice the inverse-logic on the bits
264 */
265 if (indirect_read(socket, I365_INTCTL) & I365_PC_IOCARD) {
266 /* IO card */
267 if (!(status & I365_CS_STSCHG))
268 *value |= SS_STSCHG;
269 } else {
270 /* non I/O card */
271 if (!(status & I365_CS_BVD1))
272 *value |= SS_BATDEAD;
273 if (!(status & I365_CS_BVD2))
274 *value |= SS_BATWARN;
275 }
276
277 if (status & I365_CS_WRPROT)
278 *value |= SS_WRPROT; /* card is write protected */
279
280 if (status & I365_CS_READY)
281 *value |= SS_READY; /* card is not busy */
282
283 if (status & I365_CS_POWERON)
284 *value |= SS_POWERON; /* power is applied to the card */
285
286 t = (socket->number) ? socket : socket + 1;
287 indirect_write(t, PD67_EXT_INDEX, PD67_EXTERN_DATA);
288 data = indirect_read16(t, PD67_EXT_DATA);
289 *value |= (data & PD67_EXD_VS1(socket->number)) ? 0 : SS_3VCARD;
290
291 return 0;
292 }
293
294
pd6729_set_socket(struct pcmcia_socket * sock,socket_state_t * state)295 static int pd6729_set_socket(struct pcmcia_socket *sock, socket_state_t *state)
296 {
297 struct pd6729_socket *socket
298 = container_of(sock, struct pd6729_socket, socket);
299 unsigned char reg, data;
300
301 /* First, set the global controller options */
302 indirect_write(socket, I365_GBLCTL, 0x00);
303 indirect_write(socket, I365_GENCTL, 0x00);
304
305 /* Values for the IGENC register */
306 socket->card_irq = state->io_irq;
307
308 reg = 0;
309 /* The reset bit has "inverse" logic */
310 if (!(state->flags & SS_RESET))
311 reg |= I365_PC_RESET;
312 if (state->flags & SS_IOCARD)
313 reg |= I365_PC_IOCARD;
314
315 /* IGENC, Interrupt and General Control Register */
316 indirect_write(socket, I365_INTCTL, reg);
317
318 /* Power registers */
319
320 reg = I365_PWR_NORESET; /* default: disable resetdrv on resume */
321
322 if (state->flags & SS_PWR_AUTO) {
323 dev_dbg(&sock->dev, "Auto power\n");
324 reg |= I365_PWR_AUTO; /* automatic power mngmnt */
325 }
326 if (state->flags & SS_OUTPUT_ENA) {
327 dev_dbg(&sock->dev, "Power Enabled\n");
328 reg |= I365_PWR_OUT; /* enable power */
329 }
330
331 switch (state->Vcc) {
332 case 0:
333 break;
334 case 33:
335 dev_dbg(&sock->dev,
336 "setting voltage to Vcc to 3.3V on socket %i\n",
337 socket->number);
338 reg |= I365_VCC_5V;
339 indirect_setbit(socket, PD67_MISC_CTL_1, PD67_MC1_VCC_3V);
340 break;
341 case 50:
342 dev_dbg(&sock->dev,
343 "setting voltage to Vcc to 5V on socket %i\n",
344 socket->number);
345 reg |= I365_VCC_5V;
346 indirect_resetbit(socket, PD67_MISC_CTL_1, PD67_MC1_VCC_3V);
347 break;
348 default:
349 dev_dbg(&sock->dev,
350 "pd6729_set_socket called with invalid VCC power "
351 "value: %i\n", state->Vcc);
352 return -EINVAL;
353 }
354
355 switch (state->Vpp) {
356 case 0:
357 dev_dbg(&sock->dev, "not setting Vpp on socket %i\n",
358 socket->number);
359 break;
360 case 33:
361 case 50:
362 dev_dbg(&sock->dev, "setting Vpp to Vcc for socket %i\n",
363 socket->number);
364 reg |= I365_VPP1_5V;
365 break;
366 case 120:
367 dev_dbg(&sock->dev, "setting Vpp to 12.0\n");
368 reg |= I365_VPP1_12V;
369 break;
370 default:
371 dev_dbg(&sock->dev, "pd6729: pd6729_set_socket called with "
372 "invalid VPP power value: %i\n", state->Vpp);
373 return -EINVAL;
374 }
375
376 /* only write if changed */
377 if (reg != indirect_read(socket, I365_POWER))
378 indirect_write(socket, I365_POWER, reg);
379
380 if (irq_mode == 1) {
381 /* all interrupts are to be done as PCI interrupts */
382 data = PD67_EC1_INV_MGMT_IRQ | PD67_EC1_INV_CARD_IRQ;
383 } else
384 data = 0;
385
386 indirect_write(socket, PD67_EXT_INDEX, PD67_EXT_CTL_1);
387 indirect_write(socket, PD67_EXT_DATA, data);
388
389 /* Enable specific interrupt events */
390
391 reg = 0x00;
392 if (state->csc_mask & SS_DETECT)
393 reg |= I365_CSC_DETECT;
394
395 if (state->flags & SS_IOCARD) {
396 if (state->csc_mask & SS_STSCHG)
397 reg |= I365_CSC_STSCHG;
398 } else {
399 if (state->csc_mask & SS_BATDEAD)
400 reg |= I365_CSC_BVD1;
401 if (state->csc_mask & SS_BATWARN)
402 reg |= I365_CSC_BVD2;
403 if (state->csc_mask & SS_READY)
404 reg |= I365_CSC_READY;
405 }
406 if (irq_mode == 1)
407 reg |= 0x30; /* management IRQ: PCI INTA# = "irq 3" */
408 indirect_write(socket, I365_CSCINT, reg);
409
410 reg = indirect_read(socket, I365_INTCTL);
411 if (irq_mode == 1)
412 reg |= 0x03; /* card IRQ: PCI INTA# = "irq 3" */
413 else
414 reg |= socket->card_irq;
415 indirect_write(socket, I365_INTCTL, reg);
416
417 /* now clear the (probably bogus) pending stuff by doing a dummy read */
418 (void)indirect_read(socket, I365_CSC);
419
420 return 0;
421 }
422
pd6729_set_io_map(struct pcmcia_socket * sock,struct pccard_io_map * io)423 static int pd6729_set_io_map(struct pcmcia_socket *sock,
424 struct pccard_io_map *io)
425 {
426 struct pd6729_socket *socket
427 = container_of(sock, struct pd6729_socket, socket);
428 unsigned char map, ioctl;
429
430 map = io->map;
431
432 /* Check error conditions */
433 if (map > 1) {
434 dev_dbg(&sock->dev, "pd6729_set_io_map with invalid map\n");
435 return -EINVAL;
436 }
437
438 /* Turn off the window before changing anything */
439 if (indirect_read(socket, I365_ADDRWIN) & I365_ENA_IO(map))
440 indirect_resetbit(socket, I365_ADDRWIN, I365_ENA_IO(map));
441
442 /* dev_dbg(&sock->dev, "set_io_map: Setting range to %x - %x\n",
443 io->start, io->stop);*/
444
445 /* write the new values */
446 indirect_write16(socket, I365_IO(map)+I365_W_START, io->start);
447 indirect_write16(socket, I365_IO(map)+I365_W_STOP, io->stop);
448
449 ioctl = indirect_read(socket, I365_IOCTL) & ~I365_IOCTL_MASK(map);
450
451 if (io->flags & MAP_0WS)
452 ioctl |= I365_IOCTL_0WS(map);
453 if (io->flags & MAP_16BIT)
454 ioctl |= I365_IOCTL_16BIT(map);
455 if (io->flags & MAP_AUTOSZ)
456 ioctl |= I365_IOCTL_IOCS16(map);
457
458 indirect_write(socket, I365_IOCTL, ioctl);
459
460 /* Turn the window back on if needed */
461 if (io->flags & MAP_ACTIVE)
462 indirect_setbit(socket, I365_ADDRWIN, I365_ENA_IO(map));
463
464 return 0;
465 }
466
pd6729_set_mem_map(struct pcmcia_socket * sock,struct pccard_mem_map * mem)467 static int pd6729_set_mem_map(struct pcmcia_socket *sock,
468 struct pccard_mem_map *mem)
469 {
470 struct pd6729_socket *socket
471 = container_of(sock, struct pd6729_socket, socket);
472 unsigned short base, i;
473 unsigned char map;
474
475 map = mem->map;
476 if (map > 4) {
477 dev_warn(&sock->dev, "invalid map requested\n");
478 return -EINVAL;
479 }
480
481 if ((mem->res->start > mem->res->end) || (mem->speed > 1000)) {
482 dev_warn(&sock->dev, "invalid invalid address / speed\n");
483 return -EINVAL;
484 }
485
486 /* Turn off the window before changing anything */
487 if (indirect_read(socket, I365_ADDRWIN) & I365_ENA_MEM(map))
488 indirect_resetbit(socket, I365_ADDRWIN, I365_ENA_MEM(map));
489
490 /* write the start address */
491 base = I365_MEM(map);
492 i = (mem->res->start >> 12) & 0x0fff;
493 if (mem->flags & MAP_16BIT)
494 i |= I365_MEM_16BIT;
495 if (mem->flags & MAP_0WS)
496 i |= I365_MEM_0WS;
497 indirect_write16(socket, base + I365_W_START, i);
498
499 /* write the stop address */
500
501 i = (mem->res->end >> 12) & 0x0fff;
502 switch (to_cycles(mem->speed)) {
503 case 0:
504 break;
505 case 1:
506 i |= I365_MEM_WS0;
507 break;
508 case 2:
509 i |= I365_MEM_WS1;
510 break;
511 default:
512 i |= I365_MEM_WS1 | I365_MEM_WS0;
513 break;
514 }
515
516 indirect_write16(socket, base + I365_W_STOP, i);
517
518 /* Take care of high byte */
519 indirect_write(socket, PD67_EXT_INDEX, PD67_MEM_PAGE(map));
520 indirect_write(socket, PD67_EXT_DATA, mem->res->start >> 24);
521
522 /* card start */
523
524 i = ((mem->card_start - mem->res->start) >> 12) & 0x3fff;
525 if (mem->flags & MAP_WRPROT)
526 i |= I365_MEM_WRPROT;
527 if (mem->flags & MAP_ATTRIB) {
528 /* dev_dbg(&sock->dev, "requesting attribute memory for "
529 "socket %i\n", socket->number);*/
530 i |= I365_MEM_REG;
531 } else {
532 /* dev_dbg(&sock->dev, "requesting normal memory for "
533 "socket %i\n", socket->number);*/
534 }
535 indirect_write16(socket, base + I365_W_OFF, i);
536
537 /* Enable the window if necessary */
538 if (mem->flags & MAP_ACTIVE)
539 indirect_setbit(socket, I365_ADDRWIN, I365_ENA_MEM(map));
540
541 return 0;
542 }
543
pd6729_init(struct pcmcia_socket * sock)544 static int pd6729_init(struct pcmcia_socket *sock)
545 {
546 int i;
547 struct resource res = { .end = 0x0fff };
548 pccard_io_map io = { 0, 0, 0, 0, 1 };
549 pccard_mem_map mem = { .res = &res, };
550
551 pd6729_set_socket(sock, &dead_socket);
552 for (i = 0; i < 2; i++) {
553 io.map = i;
554 pd6729_set_io_map(sock, &io);
555 }
556 for (i = 0; i < 5; i++) {
557 mem.map = i;
558 pd6729_set_mem_map(sock, &mem);
559 }
560
561 return 0;
562 }
563
564
565 /* the pccard structure and its functions */
566 static struct pccard_operations pd6729_operations = {
567 .init = pd6729_init,
568 .get_status = pd6729_get_status,
569 .set_socket = pd6729_set_socket,
570 .set_io_map = pd6729_set_io_map,
571 .set_mem_map = pd6729_set_mem_map,
572 };
573
pd6729_test(int irq,void * dev)574 static irqreturn_t pd6729_test(int irq, void *dev)
575 {
576 pr_devel("-> hit on irq %d\n", irq);
577 return IRQ_HANDLED;
578 }
579
pd6729_check_irq(int irq)580 static int pd6729_check_irq(int irq)
581 {
582 int ret;
583
584 ret = request_irq(irq, pd6729_test, IRQF_PROBE_SHARED, "x",
585 pd6729_test);
586 if (ret)
587 return -1;
588
589 free_irq(irq, pd6729_test);
590 return 0;
591 }
592
pd6729_isa_scan(void)593 static u_int 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 mask0 = PD67_MASK;
605
606 /* just find interrupts that aren't in use */
607 for (i = 0; i < 16; i++)
608 if ((mask0 & (1 << i)) && (pd6729_check_irq(i) == 0))
609 mask |= (1 << i);
610
611 printk(KERN_INFO "pd6729: ISA irqs = ");
612 for (i = 0; i < 16; i++)
613 if (mask & (1<<i))
614 printk("%s%d", ((mask & ((1<<i)-1)) ? "," : ""), i);
615
616 if (mask == 0)
617 printk("none!");
618 else
619 printk(" polling status changes.\n");
620
621 return mask;
622 }
623
pd6729_pci_probe(struct pci_dev * dev,const struct pci_device_id * id)624 static int pd6729_pci_probe(struct pci_dev *dev,
625 const struct pci_device_id *id)
626 {
627 int i, j, ret;
628 u_int mask;
629 char configbyte;
630 struct pd6729_socket *socket;
631
632 socket = kcalloc(MAX_SOCKETS, sizeof(struct pd6729_socket),
633 GFP_KERNEL);
634 if (!socket) {
635 dev_warn(&dev->dev, "failed to kzalloc socket.\n");
636 return -ENOMEM;
637 }
638
639 ret = pci_enable_device(dev);
640 if (ret) {
641 dev_warn(&dev->dev, "failed to enable pci_device.\n");
642 goto err_out_free_mem;
643 }
644
645 if (!pci_resource_start(dev, 0)) {
646 dev_warn(&dev->dev, "refusing to load the driver as the "
647 "io_base is NULL.\n");
648 ret = -ENOMEM;
649 goto err_out_disable;
650 }
651
652 dev_info(&dev->dev, "Cirrus PD6729 PCI to PCMCIA Bridge at 0x%llx "
653 "on irq %d\n",
654 (unsigned long long)pci_resource_start(dev, 0), dev->irq);
655 /*
656 * Since we have no memory BARs some firmware may not
657 * have had PCI_COMMAND_MEMORY enabled, yet the device needs it.
658 */
659 pci_read_config_byte(dev, PCI_COMMAND, &configbyte);
660 if (!(configbyte & PCI_COMMAND_MEMORY)) {
661 dev_dbg(&dev->dev, "pd6729: Enabling PCI_COMMAND_MEMORY.\n");
662 configbyte |= PCI_COMMAND_MEMORY;
663 pci_write_config_byte(dev, PCI_COMMAND, configbyte);
664 }
665
666 ret = pci_request_regions(dev, "pd6729");
667 if (ret) {
668 dev_warn(&dev->dev, "pci request region failed.\n");
669 goto err_out_disable;
670 }
671
672 if (dev->irq == NO_IRQ)
673 irq_mode = 0; /* fall back to ISA interrupt mode */
674
675 mask = pd6729_isa_scan();
676 if (irq_mode == 0 && mask == 0) {
677 dev_warn(&dev->dev, "no ISA interrupt is available.\n");
678 ret = -ENODEV;
679 goto err_out_free_res;
680 }
681
682 for (i = 0; i < MAX_SOCKETS; i++) {
683 socket[i].io_base = pci_resource_start(dev, 0);
684 socket[i].socket.features |= SS_CAP_PAGE_REGS | SS_CAP_PCCARD;
685 socket[i].socket.map_size = 0x1000;
686 socket[i].socket.irq_mask = mask;
687 socket[i].socket.pci_irq = dev->irq;
688 socket[i].socket.cb_dev = dev;
689 socket[i].socket.owner = THIS_MODULE;
690
691 socket[i].number = i;
692
693 socket[i].socket.ops = &pd6729_operations;
694 socket[i].socket.resource_ops = &pccard_nonstatic_ops;
695 socket[i].socket.dev.parent = &dev->dev;
696 socket[i].socket.driver_data = &socket[i];
697 }
698
699 pci_set_drvdata(dev, socket);
700 if (irq_mode == 1) {
701 /* Register the interrupt handler */
702 ret = request_irq(dev->irq, pd6729_interrupt, IRQF_SHARED,
703 "pd6729", socket);
704 if (ret) {
705 dev_err(&dev->dev, "Failed to register irq %d\n",
706 dev->irq);
707 goto err_out_free_res;
708 }
709 } else {
710 /* poll Card status change */
711 timer_setup(&socket->poll_timer, pd6729_interrupt_wrapper, 0);
712 mod_timer(&socket->poll_timer, jiffies + HZ);
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 timer_shutdown_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
pd6729_pci_remove(struct pci_dev * dev)742 static void 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 timer_shutdown_sync(&socket->poll_timer);
759 pci_release_regions(dev);
760 pci_disable_device(dev);
761
762 kfree(socket);
763 }
764
765 static const struct pci_device_id 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 = pd6729_pci_remove,
776 };
777
778 module_pci_driver(pd6729_pci_driver);
779