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
 27MODULE_LICENSE("GPL");
 28MODULE_DESCRIPTION("Driver for the Cirrus PD6729 PCI-PCMCIA bridge");
 29MODULE_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
 51static int irq_mode = 1; /* 0 = ISA interrupt, 1 = PCI interrupt */
 52
 53module_param(irq_mode, int, 0444);
 54MODULE_PARM_DESC(irq_mode,
 55		"interrupt delivery mode. 0 = ISA, 1 = PCI. default is 1");
 56
 57static DEFINE_SPINLOCK(port_lock);
 58
 59/* basic value read/write functions */
 60
 61static 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
 78static 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
 98static 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
112static 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
130static 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
148static 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
173static 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
237static 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
246static 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
295static 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
423static 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
467static 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
544static 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 */
566static 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
574static irqreturn_t pd6729_test(int irq, void *dev)
575{
576	pr_devel("-> hit on irq %d\n", irq);
577	return IRQ_HANDLED;
578}
579
580static 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
593static 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
624static 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
727err_out_free_res2:
728	if (irq_mode == 1)
729		free_irq(dev->irq, socket);
730	else
731		timer_shutdown_sync(&socket->poll_timer);
732err_out_free_res:
733	pci_release_regions(dev);
734err_out_disable:
735	pci_disable_device(dev);
736
737err_out_free_mem:
738	kfree(socket);
739	return ret;
740}
741
742static 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
765static const struct pci_device_id pd6729_pci_ids[] = {
766	{ PCI_DEVICE(PCI_VENDOR_ID_CIRRUS, PCI_DEVICE_ID_CIRRUS_6729) },
767	{ }
768};
769MODULE_DEVICE_TABLE(pci, pd6729_pci_ids);
770
771static 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
778module_pci_driver(pd6729_pci_driver);