xref: /linux/drivers/pcmcia/i82365.c (revision c532de5a67a70f8533d495f8f2aaa9a0491c3ad0)
1 /*======================================================================
2 
3     Device driver for Intel 82365 and compatible PC Card controllers.
4 
5     i82365.c 1.265 1999/11/10 18:36:21
6 
7     The contents of this file are subject to the Mozilla Public
8     License Version 1.1 (the "License"); you may not use this file
9     except in compliance with the License. You may obtain a copy of
10     the License at http://www.mozilla.org/MPL/
11 
12     Software distributed under the License is distributed on an "AS
13     IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
14     implied. See the License for the specific language governing
15     rights and limitations under the License.
16 
17     The initial developer of the original code is David A. Hinds
18     <dahinds@users.sourceforge.net>.  Portions created by David A. Hinds
19     are Copyright (C) 1999 David A. Hinds.  All Rights Reserved.
20 
21     Alternatively, the contents of this file may be used under the
22     terms of the GNU General Public License version 2 (the "GPL"), in which
23     case the provisions of the GPL are applicable instead of the
24     above.  If you wish to allow the use of your version of this file
25     only under the terms of the GPL and not to allow others to use
26     your version of this file under the MPL, indicate your decision
27     by deleting the provisions above and replace them with the notice
28     and other provisions required by the GPL.  If you do not delete
29     the provisions above, a recipient may use your version of this
30     file under either the MPL or the GPL.
31 
32 ======================================================================*/
33 
34 #include <linux/module.h>
35 #include <linux/moduleparam.h>
36 #include <linux/init.h>
37 #include <linux/types.h>
38 #include <linux/fcntl.h>
39 #include <linux/string.h>
40 #include <linux/kernel.h>
41 #include <linux/errno.h>
42 #include <linux/timer.h>
43 #include <linux/ioport.h>
44 #include <linux/delay.h>
45 #include <linux/workqueue.h>
46 #include <linux/interrupt.h>
47 #include <linux/platform_device.h>
48 #include <linux/bitops.h>
49 #include <asm/irq.h>
50 #include <asm/io.h>
51 
52 #include <pcmcia/ss.h>
53 
54 #include <linux/isapnp.h>
55 
56 /* ISA-bus controllers */
57 #include "i82365.h"
58 #include "cirrus.h"
59 #include "vg468.h"
60 #include "ricoh.h"
61 
62 
63 static irqreturn_t i365_count_irq(int, void *);
64 static inline int _check_irq(int irq, int flags)
65 {
66     if (request_irq(irq, i365_count_irq, flags, "x", i365_count_irq) != 0)
67 	return -1;
68     free_irq(irq, i365_count_irq);
69     return 0;
70 }
71 
72 /*====================================================================*/
73 
74 /* Parameters that can be set with 'insmod' */
75 
76 /* Default base address for i82365sl and other ISA chips */
77 static unsigned long i365_base = 0x3e0;
78 /* Should we probe at 0x3e2 for an extra ISA controller? */
79 static int extra_sockets = 0;
80 /* Specify a socket number to ignore */
81 static int ignore = -1;
82 /* Bit map or list of interrupts to choose from */
83 static u_int irq_mask = 0xffff;
84 static int irq_list[16];
85 static unsigned int irq_list_count;
86 /* The card status change interrupt -- 0 means autoselect */
87 static int cs_irq = 0;
88 
89 /* Probe for safe interrupts? */
90 static int do_scan = 1;
91 /* Poll status interval -- 0 means default to interrupt */
92 static int poll_interval = 0;
93 /* External clock time, in nanoseconds.  120 ns = 8.33 MHz */
94 static int cycle_time = 120;
95 
96 /* Cirrus options */
97 static int has_dma = -1;
98 static int has_led = -1;
99 static int has_ring = -1;
100 static int dynamic_mode = 0;
101 static int freq_bypass = -1;
102 static int setup_time = -1;
103 static int cmd_time = -1;
104 static int recov_time = -1;
105 
106 /* Vadem options */
107 static int async_clock = -1;
108 static int cable_mode = -1;
109 static int wakeup = 0;
110 
111 module_param_hw(i365_base, ulong, ioport, 0444);
112 module_param(ignore, int, 0444);
113 module_param(extra_sockets, int, 0444);
114 module_param_hw(irq_mask, int, other, 0444);
115 module_param_hw_array(irq_list, int, irq, &irq_list_count, 0444);
116 module_param_hw(cs_irq, int, irq, 0444);
117 module_param(async_clock, int, 0444);
118 module_param(cable_mode, int, 0444);
119 module_param(wakeup, int, 0444);
120 
121 module_param(do_scan, int, 0444);
122 module_param(poll_interval, int, 0444);
123 module_param(cycle_time, int, 0444);
124 module_param(has_dma, int, 0444);
125 module_param(has_led, int, 0444);
126 module_param(has_ring, int, 0444);
127 module_param(dynamic_mode, int, 0444);
128 module_param(freq_bypass, int, 0444);
129 module_param(setup_time, int, 0444);
130 module_param(cmd_time, int, 0444);
131 module_param(recov_time, int, 0444);
132 
133 /*====================================================================*/
134 
135 struct cirrus_state {
136     u_char		misc1, misc2;
137     u_char		timer[6];
138 };
139 
140 struct vg46x_state {
141     u_char		ctl, ema;
142 };
143 
144 struct i82365_socket {
145     u_short		type, flags;
146     struct pcmcia_socket	socket;
147     unsigned int	number;
148     unsigned int	ioaddr;
149     u_short		psock;
150     u_char		cs_irq, intr;
151     union {
152 	struct cirrus_state		cirrus;
153 	struct vg46x_state		vg46x;
154     } state;
155 };
156 
157 /* Where we keep track of our sockets... */
158 static int sockets = 0;
159 static struct i82365_socket socket[8] = {
160     { 0, }, /* ... */
161 };
162 
163 /* Default ISA interrupt mask */
164 #define I365_MASK	0xdeb8	/* irq 15,14,12,11,10,9,7,5,4,3 */
165 
166 static int grab_irq;
167 static DEFINE_SPINLOCK(isa_lock);
168 #define ISA_LOCK(n, f) spin_lock_irqsave(&isa_lock, f)
169 #define ISA_UNLOCK(n, f) spin_unlock_irqrestore(&isa_lock, f)
170 
171 static struct timer_list poll_timer;
172 
173 /*====================================================================*/
174 
175 /* These definitions must match the pcic table! */
176 enum pcic_id {
177     IS_I82365A, IS_I82365B, IS_I82365DF,
178     IS_IBM, IS_RF5Cx96, IS_VLSI, IS_VG468, IS_VG469,
179     IS_PD6710, IS_PD672X, IS_VT83C469,
180 };
181 
182 /* Flags for classifying groups of controllers */
183 #define IS_VADEM	0x0001
184 #define IS_CIRRUS	0x0002
185 #define IS_VIA		0x0010
186 #define IS_UNKNOWN	0x0400
187 #define IS_VG_PWR	0x0800
188 #define IS_DF_PWR	0x1000
189 #define IS_REGISTERED	0x2000
190 #define IS_ALIVE	0x8000
191 
192 struct pcic {
193     char		*name;
194     u_short		flags;
195 };
196 
197 static struct pcic pcic[] = {
198     { "Intel i82365sl A step", 0 },
199     { "Intel i82365sl B step", 0 },
200     { "Intel i82365sl DF", IS_DF_PWR },
201     { "IBM Clone", 0 },
202     { "Ricoh RF5C296/396", 0 },
203     { "VLSI 82C146", 0 },
204     { "Vadem VG-468", IS_VADEM },
205     { "Vadem VG-469", IS_VADEM|IS_VG_PWR },
206     { "Cirrus PD6710", IS_CIRRUS },
207     { "Cirrus PD672x", IS_CIRRUS },
208     { "VIA VT83C469", IS_CIRRUS|IS_VIA },
209 };
210 
211 #define PCIC_COUNT	ARRAY_SIZE(pcic)
212 
213 /*====================================================================*/
214 
215 static DEFINE_SPINLOCK(bus_lock);
216 
217 static u_char i365_get(u_short sock, u_short reg)
218 {
219     unsigned long flags;
220     spin_lock_irqsave(&bus_lock,flags);
221     {
222 	unsigned int port = socket[sock].ioaddr;
223 	u_char val;
224 	reg = I365_REG(socket[sock].psock, reg);
225 	outb(reg, port); val = inb(port+1);
226 	spin_unlock_irqrestore(&bus_lock,flags);
227 	return val;
228     }
229 }
230 
231 static void i365_set(u_short sock, u_short reg, u_char data)
232 {
233     unsigned long flags;
234     spin_lock_irqsave(&bus_lock,flags);
235     {
236 	unsigned int port = socket[sock].ioaddr;
237 	u_char val = I365_REG(socket[sock].psock, reg);
238 	outb(val, port); outb(data, port+1);
239 	spin_unlock_irqrestore(&bus_lock,flags);
240     }
241 }
242 
243 static void i365_bset(u_short sock, u_short reg, u_char mask)
244 {
245     u_char d = i365_get(sock, reg);
246     d |= mask;
247     i365_set(sock, reg, d);
248 }
249 
250 static void i365_bclr(u_short sock, u_short reg, u_char mask)
251 {
252     u_char d = i365_get(sock, reg);
253     d &= ~mask;
254     i365_set(sock, reg, d);
255 }
256 
257 static void i365_bflip(u_short sock, u_short reg, u_char mask, int b)
258 {
259     u_char d = i365_get(sock, reg);
260     if (b)
261 	d |= mask;
262     else
263 	d &= ~mask;
264     i365_set(sock, reg, d);
265 }
266 
267 static u_short i365_get_pair(u_short sock, u_short reg)
268 {
269     u_short a, b;
270     a = i365_get(sock, reg);
271     b = i365_get(sock, reg+1);
272     return (a + (b<<8));
273 }
274 
275 static void i365_set_pair(u_short sock, u_short reg, u_short data)
276 {
277     i365_set(sock, reg, data & 0xff);
278     i365_set(sock, reg+1, data >> 8);
279 }
280 
281 /*======================================================================
282 
283     Code to save and restore global state information for Cirrus
284     PD67xx controllers, and to set and report global configuration
285     options.
286 
287     The VIA controllers also use these routines, as they are mostly
288     Cirrus lookalikes, without the timing registers.
289 
290 ======================================================================*/
291 
292 #define flip(v,b,f) (v = ((f)<0) ? v : ((f) ? ((v)|(b)) : ((v)&(~b))))
293 
294 static void cirrus_get_state(u_short s)
295 {
296     int i;
297     struct cirrus_state *p = &socket[s].state.cirrus;
298     p->misc1 = i365_get(s, PD67_MISC_CTL_1);
299     p->misc1 &= (PD67_MC1_MEDIA_ENA | PD67_MC1_INPACK_ENA);
300     p->misc2 = i365_get(s, PD67_MISC_CTL_2);
301     for (i = 0; i < 6; i++)
302 	p->timer[i] = i365_get(s, PD67_TIME_SETUP(0)+i);
303 }
304 
305 static void cirrus_set_state(u_short s)
306 {
307     int i;
308     u_char misc;
309     struct cirrus_state *p = &socket[s].state.cirrus;
310 
311     misc = i365_get(s, PD67_MISC_CTL_2);
312     i365_set(s, PD67_MISC_CTL_2, p->misc2);
313     if (misc & PD67_MC2_SUSPEND) mdelay(50);
314     misc = i365_get(s, PD67_MISC_CTL_1);
315     misc &= ~(PD67_MC1_MEDIA_ENA | PD67_MC1_INPACK_ENA);
316     i365_set(s, PD67_MISC_CTL_1, misc | p->misc1);
317     for (i = 0; i < 6; i++)
318 	i365_set(s, PD67_TIME_SETUP(0)+i, p->timer[i]);
319 }
320 
321 static u_int __init cirrus_set_opts(u_short s, char *buf)
322 {
323     struct i82365_socket *t = &socket[s];
324     struct cirrus_state *p = &socket[s].state.cirrus;
325     u_int mask = 0xffff;
326 
327     if (has_ring == -1) has_ring = 1;
328     flip(p->misc2, PD67_MC2_IRQ15_RI, has_ring);
329     flip(p->misc2, PD67_MC2_DYNAMIC_MODE, dynamic_mode);
330     flip(p->misc2, PD67_MC2_FREQ_BYPASS, freq_bypass);
331     if (p->misc2 & PD67_MC2_IRQ15_RI)
332 	strcat(buf, " [ring]");
333     if (p->misc2 & PD67_MC2_DYNAMIC_MODE)
334 	strcat(buf, " [dyn mode]");
335     if (p->misc2 & PD67_MC2_FREQ_BYPASS)
336 	strcat(buf, " [freq bypass]");
337     if (p->misc1 & PD67_MC1_INPACK_ENA)
338 	strcat(buf, " [inpack]");
339     if (p->misc2 & PD67_MC2_IRQ15_RI)
340 	mask &= ~0x8000;
341     if (has_led > 0) {
342 	strcat(buf, " [led]");
343 	mask &= ~0x1000;
344     }
345     if (has_dma > 0) {
346 	strcat(buf, " [dma]");
347 	mask &= ~0x0600;
348     }
349     if (!(t->flags & IS_VIA)) {
350 	if (setup_time >= 0)
351 	    p->timer[0] = p->timer[3] = setup_time;
352 	if (cmd_time > 0) {
353 	    p->timer[1] = cmd_time;
354 	    p->timer[4] = cmd_time*2+4;
355 	}
356 	if (p->timer[1] == 0) {
357 	    p->timer[1] = 6; p->timer[4] = 16;
358 	    if (p->timer[0] == 0)
359 		p->timer[0] = p->timer[3] = 1;
360 	}
361 	if (recov_time >= 0)
362 	    p->timer[2] = p->timer[5] = recov_time;
363 	buf += strlen(buf);
364 	sprintf(buf, " [%d/%d/%d] [%d/%d/%d]", p->timer[0], p->timer[1],
365 		p->timer[2], p->timer[3], p->timer[4], p->timer[5]);
366     }
367     return mask;
368 }
369 
370 /*======================================================================
371 
372     Code to save and restore global state information for Vadem VG468
373     and VG469 controllers, and to set and report global configuration
374     options.
375 
376 ======================================================================*/
377 
378 static void vg46x_get_state(u_short s)
379 {
380     struct vg46x_state *p = &socket[s].state.vg46x;
381     p->ctl = i365_get(s, VG468_CTL);
382     if (socket[s].type == IS_VG469)
383 	p->ema = i365_get(s, VG469_EXT_MODE);
384 }
385 
386 static void vg46x_set_state(u_short s)
387 {
388     struct vg46x_state *p = &socket[s].state.vg46x;
389     i365_set(s, VG468_CTL, p->ctl);
390     if (socket[s].type == IS_VG469)
391 	i365_set(s, VG469_EXT_MODE, p->ema);
392 }
393 
394 static u_int __init vg46x_set_opts(u_short s, char *buf)
395 {
396     struct vg46x_state *p = &socket[s].state.vg46x;
397 
398     flip(p->ctl, VG468_CTL_ASYNC, async_clock);
399     flip(p->ema, VG469_MODE_CABLE, cable_mode);
400     if (p->ctl & VG468_CTL_ASYNC)
401 	strcat(buf, " [async]");
402     if (p->ctl & VG468_CTL_INPACK)
403 	strcat(buf, " [inpack]");
404     if (socket[s].type == IS_VG469) {
405 	u_char vsel = i365_get(s, VG469_VSELECT);
406 	if (vsel & VG469_VSEL_EXT_STAT) {
407 	    strcat(buf, " [ext mode]");
408 	    if (vsel & VG469_VSEL_EXT_BUS)
409 		strcat(buf, " [isa buf]");
410 	}
411 	if (p->ema & VG469_MODE_CABLE)
412 	    strcat(buf, " [cable]");
413 	if (p->ema & VG469_MODE_COMPAT)
414 	    strcat(buf, " [c step]");
415     }
416     return 0xffff;
417 }
418 
419 /*======================================================================
420 
421     Generic routines to get and set controller options
422 
423 ======================================================================*/
424 
425 static void get_bridge_state(u_short s)
426 {
427     struct i82365_socket *t = &socket[s];
428     if (t->flags & IS_CIRRUS)
429 	cirrus_get_state(s);
430     else if (t->flags & IS_VADEM)
431 	vg46x_get_state(s);
432 }
433 
434 static void set_bridge_state(u_short s)
435 {
436     struct i82365_socket *t = &socket[s];
437     if (t->flags & IS_CIRRUS)
438 	cirrus_set_state(s);
439     else {
440 	i365_set(s, I365_GBLCTL, 0x00);
441 	i365_set(s, I365_GENCTL, 0x00);
442     }
443     i365_bflip(s, I365_INTCTL, I365_INTR_ENA, t->intr);
444     if (t->flags & IS_VADEM)
445 	vg46x_set_state(s);
446 }
447 
448 static u_int __init set_bridge_opts(u_short s, u_short ns)
449 {
450     u_short i;
451     u_int m = 0xffff;
452     char buf[128];
453 
454     for (i = s; i < s+ns; i++) {
455 	if (socket[i].flags & IS_ALIVE) {
456 	    printk(KERN_INFO "    host opts [%d]: already alive!\n", i);
457 	    continue;
458 	}
459 	buf[0] = '\0';
460 	get_bridge_state(i);
461 	if (socket[i].flags & IS_CIRRUS)
462 	    m = cirrus_set_opts(i, buf);
463 	else if (socket[i].flags & IS_VADEM)
464 	    m = vg46x_set_opts(i, buf);
465 	set_bridge_state(i);
466 	printk(KERN_INFO "    host opts [%d]:%s\n", i,
467 	       (*buf) ? buf : " none");
468     }
469     return m;
470 }
471 
472 /*======================================================================
473 
474     Interrupt testing code, for ISA and PCI interrupts
475 
476 ======================================================================*/
477 
478 static volatile u_int irq_hits;
479 static u_short irq_sock;
480 
481 static irqreturn_t i365_count_irq(int irq, void *dev)
482 {
483     i365_get(irq_sock, I365_CSC);
484     irq_hits++;
485     pr_debug("i82365: -> hit on irq %d\n", irq);
486     return IRQ_HANDLED;
487 }
488 
489 static u_int __init test_irq(u_short sock, int irq)
490 {
491     pr_debug("i82365:  testing ISA irq %d\n", irq);
492     if (request_irq(irq, i365_count_irq, IRQF_PROBE_SHARED, "scan",
493 			i365_count_irq) != 0)
494 	return 1;
495     irq_hits = 0; irq_sock = sock;
496     msleep(10);
497     if (irq_hits) {
498 	free_irq(irq, i365_count_irq);
499 	pr_debug("i82365:    spurious hit!\n");
500 	return 1;
501     }
502 
503     /* Generate one interrupt */
504     i365_set(sock, I365_CSCINT, I365_CSC_DETECT | (irq << 4));
505     i365_bset(sock, I365_GENCTL, I365_CTL_SW_IRQ);
506     udelay(1000);
507 
508     free_irq(irq, i365_count_irq);
509 
510     /* mask all interrupts */
511     i365_set(sock, I365_CSCINT, 0);
512     pr_debug("i82365:    hits = %d\n", irq_hits);
513 
514     return (irq_hits != 1);
515 }
516 
517 static u_int __init isa_scan(u_short sock, u_int mask0)
518 {
519     u_int mask1 = 0;
520     int i;
521 
522 #ifdef __alpha__
523 #define PIC 0x4d0
524     /* Don't probe level-triggered interrupts -- reserved for PCI */
525     mask0 &= ~(inb(PIC) | (inb(PIC+1) << 8));
526 #endif
527 
528     if (do_scan) {
529 	set_bridge_state(sock);
530 	i365_set(sock, I365_CSCINT, 0);
531 	for (i = 0; i < 16; i++)
532 	    if ((mask0 & (1 << i)) && (test_irq(sock, i) == 0))
533 		mask1 |= (1 << i);
534 	for (i = 0; i < 16; i++)
535 	    if ((mask1 & (1 << i)) && (test_irq(sock, i) != 0))
536 		mask1 ^= (1 << i);
537     }
538 
539     printk(KERN_INFO "    ISA irqs (");
540     if (mask1) {
541 	printk("scanned");
542     } else {
543 	/* Fallback: just find interrupts that aren't in use */
544 	for (i = 0; i < 16; i++)
545 	    if ((mask0 & (1 << i)) && (_check_irq(i, IRQF_PROBE_SHARED) == 0))
546 		mask1 |= (1 << i);
547 	printk("default");
548 	/* If scan failed, default to polled status */
549 	if (!cs_irq && (poll_interval == 0)) poll_interval = HZ;
550     }
551     printk(") = ");
552 
553     for (i = 0; i < 16; i++)
554 	if (mask1 & (1<<i))
555 	    printk("%s%d", ((mask1 & ((1<<i)-1)) ? "," : ""), i);
556     if (mask1 == 0) printk("none!");
557 
558     return mask1;
559 }
560 
561 /*====================================================================*/
562 
563 /* Time conversion functions */
564 
565 static int to_cycles(int ns)
566 {
567     return ns/cycle_time;
568 }
569 
570 /*====================================================================*/
571 
572 static int __init identify(unsigned int port, u_short sock)
573 {
574     u_char val;
575     int type = -1;
576 
577     /* Use the next free entry in the socket table */
578     socket[sockets].ioaddr = port;
579     socket[sockets].psock = sock;
580 
581     /* Wake up a sleepy Cirrus controller */
582     if (wakeup) {
583 	i365_bclr(sockets, PD67_MISC_CTL_2, PD67_MC2_SUSPEND);
584 	/* Pause at least 50 ms */
585 	mdelay(50);
586     }
587 
588     if ((val = i365_get(sockets, I365_IDENT)) & 0x70)
589 	return -1;
590     switch (val) {
591     case 0x82:
592 	type = IS_I82365A; break;
593     case 0x83:
594 	type = IS_I82365B; break;
595     case 0x84:
596 	type = IS_I82365DF; break;
597     case 0x88: case 0x89: case 0x8a:
598 	type = IS_IBM; break;
599     }
600 
601     /* Check for Vadem VG-468 chips */
602     outb(0x0e, port);
603     outb(0x37, port);
604     i365_bset(sockets, VG468_MISC, VG468_MISC_VADEMREV);
605     val = i365_get(sockets, I365_IDENT);
606     if (val & I365_IDENT_VADEM) {
607 	i365_bclr(sockets, VG468_MISC, VG468_MISC_VADEMREV);
608 	type = ((val & 7) >= 4) ? IS_VG469 : IS_VG468;
609     }
610 
611     /* Check for Ricoh chips */
612     val = i365_get(sockets, RF5C_CHIP_ID);
613     if ((val == RF5C_CHIP_RF5C296) || (val == RF5C_CHIP_RF5C396))
614 	type = IS_RF5Cx96;
615 
616     /* Check for Cirrus CL-PD67xx chips */
617     i365_set(sockets, PD67_CHIP_INFO, 0);
618     val = i365_get(sockets, PD67_CHIP_INFO);
619     if ((val & PD67_INFO_CHIP_ID) == PD67_INFO_CHIP_ID) {
620 	val = i365_get(sockets, PD67_CHIP_INFO);
621 	if ((val & PD67_INFO_CHIP_ID) == 0) {
622 	    type = (val & PD67_INFO_SLOTS) ? IS_PD672X : IS_PD6710;
623 	    i365_set(sockets, PD67_EXT_INDEX, 0xe5);
624 	    if (i365_get(sockets, PD67_EXT_INDEX) != 0xe5)
625 		type = IS_VT83C469;
626 	}
627     }
628     return type;
629 } /* identify */
630 
631 /*======================================================================
632 
633     See if a card is present, powered up, in IO mode, and already
634     bound to a (non PC Card) Linux driver.  We leave these alone.
635 
636     We make an exception for cards that seem to be serial devices.
637 
638 ======================================================================*/
639 
640 static int __init is_alive(u_short sock)
641 {
642     u_char stat;
643     unsigned int start, stop;
644 
645     stat = i365_get(sock, I365_STATUS);
646     start = i365_get_pair(sock, I365_IO(0)+I365_W_START);
647     stop = i365_get_pair(sock, I365_IO(0)+I365_W_STOP);
648     if ((stat & I365_CS_DETECT) && (stat & I365_CS_POWERON) &&
649 	(i365_get(sock, I365_INTCTL) & I365_PC_IOCARD) &&
650 	(i365_get(sock, I365_ADDRWIN) & I365_ENA_IO(0)) &&
651 	((start & 0xfeef) != 0x02e8)) {
652 	if (!request_region(start, stop-start+1, "i82365"))
653 	    return 1;
654 	release_region(start, stop-start+1);
655     }
656 
657     return 0;
658 }
659 
660 /*====================================================================*/
661 
662 static void __init add_socket(unsigned int port, int psock, int type)
663 {
664     socket[sockets].ioaddr = port;
665     socket[sockets].psock = psock;
666     socket[sockets].type = type;
667     socket[sockets].flags = pcic[type].flags;
668     if (is_alive(sockets))
669 	socket[sockets].flags |= IS_ALIVE;
670     sockets++;
671 }
672 
673 static void __init add_pcic(int ns, int type)
674 {
675     u_int mask = 0, i, base;
676     int isa_irq = 0;
677     struct i82365_socket *t = &socket[sockets-ns];
678 
679     base = sockets-ns;
680     if (base == 0) printk("\n");
681     printk(KERN_INFO "  %s", pcic[type].name);
682     printk(" ISA-to-PCMCIA at port %#x ofs 0x%02x",
683 	       t->ioaddr, t->psock*0x40);
684     printk(", %d socket%s\n", ns, ((ns > 1) ? "s" : ""));
685 
686     /* Set host options, build basic interrupt mask */
687     if (irq_list_count == 0)
688 	mask = irq_mask;
689     else
690 	for (i = mask = 0; i < irq_list_count; i++)
691 	    mask |= (1<<irq_list[i]);
692     mask &= I365_MASK & set_bridge_opts(base, ns);
693     /* Scan for ISA interrupts */
694     mask = isa_scan(base, mask);
695 
696     /* Poll if only two interrupts available */
697     if (!poll_interval) {
698 	u_int tmp = (mask & 0xff20);
699 	tmp = tmp & (tmp-1);
700 	if ((tmp & (tmp-1)) == 0)
701 	    poll_interval = HZ;
702     }
703     /* Only try an ISA cs_irq if this is the first controller */
704     if (!grab_irq && (cs_irq || !poll_interval)) {
705 	/* Avoid irq 12 unless it is explicitly requested */
706 	u_int cs_mask = mask & ((cs_irq) ? (1<<cs_irq) : ~(1<<12));
707 	for (cs_irq = 15; cs_irq > 0; cs_irq--)
708 	    if ((cs_mask & (1 << cs_irq)) &&
709 		(_check_irq(cs_irq, IRQF_PROBE_SHARED) == 0))
710 		break;
711 	if (cs_irq) {
712 	    grab_irq = 1;
713 	    isa_irq = cs_irq;
714 	    printk(" status change on irq %d\n", cs_irq);
715 	}
716     }
717 
718     if (!isa_irq) {
719 	if (poll_interval == 0)
720 	    poll_interval = HZ;
721 	printk(" polling interval = %d ms\n",
722 	       poll_interval * 1000 / HZ);
723 
724     }
725 
726     /* Update socket interrupt information, capabilities */
727     for (i = 0; i < ns; i++) {
728 	t[i].socket.features |= SS_CAP_PCCARD;
729 	t[i].socket.map_size = 0x1000;
730 	t[i].socket.irq_mask = mask;
731 	t[i].cs_irq = isa_irq;
732     }
733 
734 } /* add_pcic */
735 
736 /*====================================================================*/
737 
738 #ifdef CONFIG_PNP
739 static struct isapnp_device_id id_table[] __initdata = {
740 	{ 	ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('P', 'N', 'P'),
741 		ISAPNP_FUNCTION(0x0e00), (unsigned long) "Intel 82365-Compatible" },
742 	{ 	ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('P', 'N', 'P'),
743 		ISAPNP_FUNCTION(0x0e01), (unsigned long) "Cirrus Logic CL-PD6720" },
744 	{ 	ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('P', 'N', 'P'),
745 		ISAPNP_FUNCTION(0x0e02), (unsigned long) "VLSI VL82C146" },
746 	{	0 }
747 };
748 MODULE_DEVICE_TABLE(isapnp, id_table);
749 
750 static struct pnp_dev *i82365_pnpdev;
751 #endif
752 
753 static void __init isa_probe(void)
754 {
755     int i, j, sock, k, ns, id;
756     unsigned int port;
757 #ifdef CONFIG_PNP
758     struct isapnp_device_id *devid;
759     struct pnp_dev *dev;
760 
761     for (devid = id_table; devid->vendor; devid++) {
762 	if ((dev = pnp_find_dev(NULL, devid->vendor, devid->function, NULL))) {
763 
764 	    if (pnp_device_attach(dev) < 0)
765 	    	continue;
766 
767 	    if (pnp_activate_dev(dev) < 0) {
768 		printk("activate failed\n");
769 		pnp_device_detach(dev);
770 		break;
771 	    }
772 
773 	    if (!pnp_port_valid(dev, 0)) {
774 		printk("invalid resources ?\n");
775 		pnp_device_detach(dev);
776 		break;
777 	    }
778 	    i365_base = pnp_port_start(dev, 0);
779 	    i82365_pnpdev = dev;
780 	    break;
781 	}
782     }
783 #endif
784 
785     if (!request_region(i365_base, 2, "i82365")) {
786 	if (sockets == 0)
787 	    printk("port conflict at %#lx\n", i365_base);
788 	return;
789     }
790 
791     id = identify(i365_base, 0);
792     if ((id == IS_I82365DF) && (identify(i365_base, 1) != id)) {
793 	for (i = 0; i < 4; i++) {
794 	    if (i == ignore) continue;
795 	    port = i365_base + ((i & 1) << 2) + ((i & 2) << 1);
796 	    sock = (i & 1) << 1;
797 	    if (identify(port, sock) == IS_I82365DF) {
798 		add_socket(port, sock, IS_VLSI);
799 		add_pcic(1, IS_VLSI);
800 	    }
801 	}
802     } else {
803 	for (i = 0; i < 8; i += 2) {
804 	    if (sockets && !extra_sockets && (i == 4))
805 		break;
806 	    port = i365_base + 2*(i>>2);
807 	    sock = (i & 3);
808 	    id = identify(port, sock);
809 	    if (id < 0) continue;
810 
811 	    for (j = ns = 0; j < 2; j++) {
812 		/* Does the socket exist? */
813 		if ((ignore == i+j) || (identify(port, sock+j) < 0))
814 		    continue;
815 		/* Check for bad socket decode */
816 		for (k = 0; k <= sockets; k++)
817 		    i365_set(k, I365_MEM(0)+I365_W_OFF, k);
818 		for (k = 0; k <= sockets; k++)
819 		    if (i365_get(k, I365_MEM(0)+I365_W_OFF) != k)
820 			break;
821 		if (k <= sockets) break;
822 		add_socket(port, sock+j, id); ns++;
823 	    }
824 	    if (ns != 0) add_pcic(ns, id);
825 	}
826     }
827 }
828 
829 /*====================================================================*/
830 
831 static irqreturn_t pcic_interrupt(int irq, void *dev)
832 {
833     int i, j, csc;
834     u_int events, active;
835     u_long flags = 0;
836     int handled = 0;
837 
838     pr_debug("pcic_interrupt(%d)\n", irq);
839 
840     for (j = 0; j < 20; j++) {
841 	active = 0;
842 	for (i = 0; i < sockets; i++) {
843 	    if (socket[i].cs_irq != irq)
844 		continue;
845 	    handled = 1;
846 	    ISA_LOCK(i, flags);
847 	    csc = i365_get(i, I365_CSC);
848 	    if ((csc == 0) || (i365_get(i, I365_IDENT) & 0x70)) {
849 		ISA_UNLOCK(i, flags);
850 		continue;
851 	    }
852 	    events = (csc & I365_CSC_DETECT) ? SS_DETECT : 0;
853 
854 	    if (i365_get(i, I365_INTCTL) & I365_PC_IOCARD)
855 		events |= (csc & I365_CSC_STSCHG) ? SS_STSCHG : 0;
856 	    else {
857 		events |= (csc & I365_CSC_BVD1) ? SS_BATDEAD : 0;
858 		events |= (csc & I365_CSC_BVD2) ? SS_BATWARN : 0;
859 		events |= (csc & I365_CSC_READY) ? SS_READY : 0;
860 	    }
861 	    ISA_UNLOCK(i, flags);
862 	    pr_debug("socket %d event 0x%02x\n", i, events);
863 
864 	    if (events)
865 		pcmcia_parse_events(&socket[i].socket, events);
866 
867 	    active |= events;
868 	}
869 	if (!active) break;
870     }
871     if (j == 20)
872 	printk(KERN_NOTICE "i82365: infinite loop in interrupt handler\n");
873 
874     pr_debug("pcic_interrupt done\n");
875     return IRQ_RETVAL(handled);
876 } /* pcic_interrupt */
877 
878 static void pcic_interrupt_wrapper(struct timer_list *unused)
879 {
880     pcic_interrupt(0, NULL);
881     poll_timer.expires = jiffies + poll_interval;
882     add_timer(&poll_timer);
883 }
884 
885 /*====================================================================*/
886 
887 static int i365_get_status(u_short sock, u_int *value)
888 {
889     u_int status;
890 
891     status = i365_get(sock, I365_STATUS);
892     *value = ((status & I365_CS_DETECT) == I365_CS_DETECT)
893 	? SS_DETECT : 0;
894 
895     if (i365_get(sock, I365_INTCTL) & I365_PC_IOCARD)
896 	*value |= (status & I365_CS_STSCHG) ? 0 : SS_STSCHG;
897     else {
898 	*value |= (status & I365_CS_BVD1) ? 0 : SS_BATDEAD;
899 	*value |= (status & I365_CS_BVD2) ? 0 : SS_BATWARN;
900     }
901     *value |= (status & I365_CS_WRPROT) ? SS_WRPROT : 0;
902     *value |= (status & I365_CS_READY) ? SS_READY : 0;
903     *value |= (status & I365_CS_POWERON) ? SS_POWERON : 0;
904 
905     if (socket[sock].type == IS_VG469) {
906 	status = i365_get(sock, VG469_VSENSE);
907 	if (socket[sock].psock & 1) {
908 	    *value |= (status & VG469_VSENSE_B_VS1) ? 0 : SS_3VCARD;
909 	    *value |= (status & VG469_VSENSE_B_VS2) ? 0 : SS_XVCARD;
910 	} else {
911 	    *value |= (status & VG469_VSENSE_A_VS1) ? 0 : SS_3VCARD;
912 	    *value |= (status & VG469_VSENSE_A_VS2) ? 0 : SS_XVCARD;
913 	}
914     }
915 
916     pr_debug("GetStatus(%d) = %#4.4x\n", sock, *value);
917     return 0;
918 } /* i365_get_status */
919 
920 /*====================================================================*/
921 
922 static int i365_set_socket(u_short sock, socket_state_t *state)
923 {
924     struct i82365_socket *t = &socket[sock];
925     u_char reg;
926 
927     pr_debug("SetSocket(%d, flags %#3.3x, Vcc %d, Vpp %d, "
928 	  "io_irq %d, csc_mask %#2.2x)\n", sock, state->flags,
929 	  state->Vcc, state->Vpp, state->io_irq, state->csc_mask);
930 
931     /* First set global controller options */
932     set_bridge_state(sock);
933 
934     /* IO card, RESET flag, IO interrupt */
935     reg = t->intr;
936     reg |= state->io_irq;
937     reg |= (state->flags & SS_RESET) ? 0 : I365_PC_RESET;
938     reg |= (state->flags & SS_IOCARD) ? I365_PC_IOCARD : 0;
939     i365_set(sock, I365_INTCTL, reg);
940 
941     reg = I365_PWR_NORESET;
942     if (state->flags & SS_PWR_AUTO) reg |= I365_PWR_AUTO;
943     if (state->flags & SS_OUTPUT_ENA) reg |= I365_PWR_OUT;
944 
945     if (t->flags & IS_CIRRUS) {
946 	if (state->Vpp != 0) {
947 	    if (state->Vpp == 120)
948 		reg |= I365_VPP1_12V;
949 	    else if (state->Vpp == state->Vcc)
950 		reg |= I365_VPP1_5V;
951 	    else return -EINVAL;
952 	}
953 	if (state->Vcc != 0) {
954 	    reg |= I365_VCC_5V;
955 	    if (state->Vcc == 33)
956 		i365_bset(sock, PD67_MISC_CTL_1, PD67_MC1_VCC_3V);
957 	    else if (state->Vcc == 50)
958 		i365_bclr(sock, PD67_MISC_CTL_1, PD67_MC1_VCC_3V);
959 	    else return -EINVAL;
960 	}
961     } else if (t->flags & IS_VG_PWR) {
962 	if (state->Vpp != 0) {
963 	    if (state->Vpp == 120)
964 		reg |= I365_VPP1_12V;
965 	    else if (state->Vpp == state->Vcc)
966 		reg |= I365_VPP1_5V;
967 	    else return -EINVAL;
968 	}
969 	if (state->Vcc != 0) {
970 	    reg |= I365_VCC_5V;
971 	    if (state->Vcc == 33)
972 		i365_bset(sock, VG469_VSELECT, VG469_VSEL_VCC);
973 	    else if (state->Vcc == 50)
974 		i365_bclr(sock, VG469_VSELECT, VG469_VSEL_VCC);
975 	    else return -EINVAL;
976 	}
977     } else if (t->flags & IS_DF_PWR) {
978 	switch (state->Vcc) {
979 	case 0:		break;
980 	case 33:   	reg |= I365_VCC_3V; break;
981 	case 50:	reg |= I365_VCC_5V; break;
982 	default:	return -EINVAL;
983 	}
984 	switch (state->Vpp) {
985 	case 0:		break;
986 	case 50:   	reg |= I365_VPP1_5V; break;
987 	case 120:	reg |= I365_VPP1_12V; break;
988 	default:	return -EINVAL;
989 	}
990     } else {
991 	switch (state->Vcc) {
992 	case 0:		break;
993 	case 50:	reg |= I365_VCC_5V; break;
994 	default:	return -EINVAL;
995 	}
996 	switch (state->Vpp) {
997 	case 0:		break;
998 	case 50:	reg |= I365_VPP1_5V | I365_VPP2_5V; break;
999 	case 120:	reg |= I365_VPP1_12V | I365_VPP2_12V; break;
1000 	default:	return -EINVAL;
1001 	}
1002     }
1003 
1004     if (reg != i365_get(sock, I365_POWER))
1005 	i365_set(sock, I365_POWER, reg);
1006 
1007     /* Chipset-specific functions */
1008     if (t->flags & IS_CIRRUS) {
1009 	/* Speaker control */
1010 	i365_bflip(sock, PD67_MISC_CTL_1, PD67_MC1_SPKR_ENA,
1011 		   state->flags & SS_SPKR_ENA);
1012     }
1013 
1014     /* Card status change interrupt mask */
1015     reg = t->cs_irq << 4;
1016     if (state->csc_mask & SS_DETECT) reg |= I365_CSC_DETECT;
1017     if (state->flags & SS_IOCARD) {
1018 	if (state->csc_mask & SS_STSCHG) reg |= I365_CSC_STSCHG;
1019     } else {
1020 	if (state->csc_mask & SS_BATDEAD) reg |= I365_CSC_BVD1;
1021 	if (state->csc_mask & SS_BATWARN) reg |= I365_CSC_BVD2;
1022 	if (state->csc_mask & SS_READY) reg |= I365_CSC_READY;
1023     }
1024     i365_set(sock, I365_CSCINT, reg);
1025     i365_get(sock, I365_CSC);
1026 
1027     return 0;
1028 } /* i365_set_socket */
1029 
1030 /*====================================================================*/
1031 
1032 static int i365_set_io_map(u_short sock, struct pccard_io_map *io)
1033 {
1034     u_char map, ioctl;
1035 
1036     pr_debug("SetIOMap(%d, %d, %#2.2x, %d ns, "
1037 	  "%#llx-%#llx)\n", sock, io->map, io->flags, io->speed,
1038 	  (unsigned long long)io->start, (unsigned long long)io->stop);
1039     map = io->map;
1040     if ((map > 1) || (io->start > 0xffff) || (io->stop > 0xffff) ||
1041 	(io->stop < io->start)) return -EINVAL;
1042     /* Turn off the window before changing anything */
1043     if (i365_get(sock, I365_ADDRWIN) & I365_ENA_IO(map))
1044 	i365_bclr(sock, I365_ADDRWIN, I365_ENA_IO(map));
1045     i365_set_pair(sock, I365_IO(map)+I365_W_START, io->start);
1046     i365_set_pair(sock, I365_IO(map)+I365_W_STOP, io->stop);
1047     ioctl = i365_get(sock, I365_IOCTL) & ~I365_IOCTL_MASK(map);
1048     if (io->speed) ioctl |= I365_IOCTL_WAIT(map);
1049     if (io->flags & MAP_0WS) ioctl |= I365_IOCTL_0WS(map);
1050     if (io->flags & MAP_16BIT) ioctl |= I365_IOCTL_16BIT(map);
1051     if (io->flags & MAP_AUTOSZ) ioctl |= I365_IOCTL_IOCS16(map);
1052     i365_set(sock, I365_IOCTL, ioctl);
1053     /* Turn on the window if necessary */
1054     if (io->flags & MAP_ACTIVE)
1055 	i365_bset(sock, I365_ADDRWIN, I365_ENA_IO(map));
1056     return 0;
1057 } /* i365_set_io_map */
1058 
1059 /*====================================================================*/
1060 
1061 static int i365_set_mem_map(u_short sock, struct pccard_mem_map *mem)
1062 {
1063     u_short base, i;
1064     u_char map;
1065 
1066     pr_debug("SetMemMap(%d, %d, %#2.2x, %d ns, %#llx-%#llx, "
1067 	  "%#x)\n", sock, mem->map, mem->flags, mem->speed,
1068 	  (unsigned long long)mem->res->start,
1069 	  (unsigned long long)mem->res->end, mem->card_start);
1070 
1071     map = mem->map;
1072     if ((map > 4) || (mem->card_start > 0x3ffffff) ||
1073 	(mem->res->start > mem->res->end) || (mem->speed > 1000))
1074 	return -EINVAL;
1075     if ((mem->res->start > 0xffffff) || (mem->res->end > 0xffffff))
1076 	return -EINVAL;
1077 
1078     /* Turn off the window before changing anything */
1079     if (i365_get(sock, I365_ADDRWIN) & I365_ENA_MEM(map))
1080 	i365_bclr(sock, I365_ADDRWIN, I365_ENA_MEM(map));
1081 
1082     base = I365_MEM(map);
1083     i = (mem->res->start >> 12) & 0x0fff;
1084     if (mem->flags & MAP_16BIT) i |= I365_MEM_16BIT;
1085     if (mem->flags & MAP_0WS) i |= I365_MEM_0WS;
1086     i365_set_pair(sock, base+I365_W_START, i);
1087 
1088     i = (mem->res->end >> 12) & 0x0fff;
1089     switch (to_cycles(mem->speed)) {
1090     case 0:	break;
1091     case 1:	i |= I365_MEM_WS0; break;
1092     case 2:	i |= I365_MEM_WS1; break;
1093     default:	i |= I365_MEM_WS1 | I365_MEM_WS0; break;
1094     }
1095     i365_set_pair(sock, base+I365_W_STOP, i);
1096 
1097     i = ((mem->card_start - mem->res->start) >> 12) & 0x3fff;
1098     if (mem->flags & MAP_WRPROT) i |= I365_MEM_WRPROT;
1099     if (mem->flags & MAP_ATTRIB) i |= I365_MEM_REG;
1100     i365_set_pair(sock, base+I365_W_OFF, i);
1101 
1102     /* Turn on the window if necessary */
1103     if (mem->flags & MAP_ACTIVE)
1104 	i365_bset(sock, I365_ADDRWIN, I365_ENA_MEM(map));
1105     return 0;
1106 } /* i365_set_mem_map */
1107 
1108 #if 0 /* driver model ordering issue */
1109 /*======================================================================
1110 
1111     Routines for accessing socket information and register dumps via
1112     /sys/class/pcmcia_socket/...
1113 
1114 ======================================================================*/
1115 
1116 static ssize_t show_info(struct class_device *class_dev, char *buf)
1117 {
1118 	struct i82365_socket *s = container_of(class_dev, struct i82365_socket, socket.dev);
1119 	return sprintf(buf, "type:     %s\npsock:    %d\n",
1120 		       pcic[s->type].name, s->psock);
1121 }
1122 
1123 static ssize_t show_exca(struct class_device *class_dev, char *buf)
1124 {
1125 	struct i82365_socket *s = container_of(class_dev, struct i82365_socket, socket.dev);
1126 	unsigned short sock;
1127 	int i;
1128 	ssize_t ret = 0;
1129 	unsigned long flags = 0;
1130 
1131 	sock = s->number;
1132 
1133 	ISA_LOCK(sock, flags);
1134 	for (i = 0; i < 0x40; i += 4) {
1135 		ret += sprintf(buf, "%02x %02x %02x %02x%s",
1136 			       i365_get(sock,i), i365_get(sock,i+1),
1137 			       i365_get(sock,i+2), i365_get(sock,i+3),
1138 			       ((i % 16) == 12) ? "\n" : " ");
1139 		buf += ret;
1140 	}
1141 	ISA_UNLOCK(sock, flags);
1142 
1143 	return ret;
1144 }
1145 
1146 static CLASS_DEVICE_ATTR(exca, S_IRUGO, show_exca, NULL);
1147 static CLASS_DEVICE_ATTR(info, S_IRUGO, show_info, NULL);
1148 #endif
1149 
1150 /*====================================================================*/
1151 
1152 /* this is horribly ugly... proper locking needs to be done here at
1153  * some time... */
1154 #define LOCKED(x) do { \
1155 	int retval; \
1156 	unsigned long flags; \
1157 	spin_lock_irqsave(&isa_lock, flags); \
1158 	retval = x; \
1159 	spin_unlock_irqrestore(&isa_lock, flags); \
1160 	return retval; \
1161 } while (0)
1162 
1163 
1164 static int pcic_get_status(struct pcmcia_socket *s, u_int *value)
1165 {
1166 	unsigned int sock = container_of(s, struct i82365_socket, socket)->number;
1167 
1168 	if (socket[sock].flags & IS_ALIVE) {
1169 		*value = 0;
1170 		return -EINVAL;
1171 	}
1172 
1173 	LOCKED(i365_get_status(sock, value));
1174 }
1175 
1176 static int pcic_set_socket(struct pcmcia_socket *s, socket_state_t *state)
1177 {
1178 	unsigned int sock = container_of(s, struct i82365_socket, socket)->number;
1179 
1180 	if (socket[sock].flags & IS_ALIVE)
1181 		return -EINVAL;
1182 
1183 	LOCKED(i365_set_socket(sock, state));
1184 }
1185 
1186 static int pcic_set_io_map(struct pcmcia_socket *s, struct pccard_io_map *io)
1187 {
1188 	unsigned int sock = container_of(s, struct i82365_socket, socket)->number;
1189 	if (socket[sock].flags & IS_ALIVE)
1190 		return -EINVAL;
1191 
1192 	LOCKED(i365_set_io_map(sock, io));
1193 }
1194 
1195 static int pcic_set_mem_map(struct pcmcia_socket *s, struct pccard_mem_map *mem)
1196 {
1197 	unsigned int sock = container_of(s, struct i82365_socket, socket)->number;
1198 	if (socket[sock].flags & IS_ALIVE)
1199 		return -EINVAL;
1200 
1201 	LOCKED(i365_set_mem_map(sock, mem));
1202 }
1203 
1204 static int pcic_init(struct pcmcia_socket *s)
1205 {
1206 	int i;
1207 	struct resource res = { .start = 0, .end = 0x1000 };
1208 	pccard_io_map io = { 0, 0, 0, 0, 1 };
1209 	pccard_mem_map mem = { .res = &res, };
1210 
1211 	for (i = 0; i < 2; i++) {
1212 		io.map = i;
1213 		pcic_set_io_map(s, &io);
1214 	}
1215 	for (i = 0; i < 5; i++) {
1216 		mem.map = i;
1217 		pcic_set_mem_map(s, &mem);
1218 	}
1219 	return 0;
1220 }
1221 
1222 
1223 static struct pccard_operations pcic_operations = {
1224 	.init			= pcic_init,
1225 	.get_status		= pcic_get_status,
1226 	.set_socket		= pcic_set_socket,
1227 	.set_io_map		= pcic_set_io_map,
1228 	.set_mem_map		= pcic_set_mem_map,
1229 };
1230 
1231 /*====================================================================*/
1232 
1233 static struct platform_driver i82365_driver = {
1234 	.driver = {
1235 		.name = "i82365",
1236 	},
1237 };
1238 
1239 static struct platform_device *i82365_device;
1240 
1241 static int __init init_i82365(void)
1242 {
1243     int i, ret;
1244 
1245     ret = platform_driver_register(&i82365_driver);
1246     if (ret)
1247 	goto err_out;
1248 
1249     i82365_device = platform_device_alloc("i82365", 0);
1250     if (i82365_device) {
1251 	    ret = platform_device_add(i82365_device);
1252 	    if (ret)
1253 		    platform_device_put(i82365_device);
1254     } else
1255 	    ret = -ENOMEM;
1256 
1257     if (ret)
1258 	goto err_driver_unregister;
1259 
1260     printk(KERN_INFO "Intel ISA PCIC probe: ");
1261     sockets = 0;
1262 
1263     isa_probe();
1264 
1265     if (sockets == 0) {
1266 	printk("not found.\n");
1267 	ret = -ENODEV;
1268 	goto err_dev_unregister;
1269     }
1270 
1271     /* Set up interrupt handler(s) */
1272     if (grab_irq != 0)
1273 	ret = request_irq(cs_irq, pcic_interrupt, 0, "i82365", pcic_interrupt);
1274 
1275     if (ret)
1276 	goto err_socket_release;
1277 
1278     /* register sockets with the pcmcia core */
1279     for (i = 0; i < sockets; i++) {
1280 	    socket[i].socket.dev.parent = &i82365_device->dev;
1281 	    socket[i].socket.ops = &pcic_operations;
1282 	    socket[i].socket.resource_ops = &pccard_nonstatic_ops;
1283 	    socket[i].socket.owner = THIS_MODULE;
1284 	    socket[i].number = i;
1285 	    ret = pcmcia_register_socket(&socket[i].socket);
1286 	    if (!ret)
1287 		    socket[i].flags |= IS_REGISTERED;
1288     }
1289 
1290     /* Finally, schedule a polling interrupt */
1291     if (poll_interval != 0) {
1292 	timer_setup(&poll_timer, pcic_interrupt_wrapper, 0);
1293     	poll_timer.expires = jiffies + poll_interval;
1294 	add_timer(&poll_timer);
1295     }
1296 
1297     return 0;
1298 err_socket_release:
1299     for (i = 0; i < sockets; i++) {
1300 	/* Turn off all interrupt sources! */
1301 	i365_set(i, I365_CSCINT, 0);
1302 	release_region(socket[i].ioaddr, 2);
1303     }
1304 err_dev_unregister:
1305     platform_device_unregister(i82365_device);
1306     release_region(i365_base, 2);
1307 #ifdef CONFIG_PNP
1308     if (i82365_pnpdev)
1309 	pnp_disable_dev(i82365_pnpdev);
1310 #endif
1311 err_driver_unregister:
1312     platform_driver_unregister(&i82365_driver);
1313 err_out:
1314     return ret;
1315 } /* init_i82365 */
1316 
1317 static void __exit exit_i82365(void)
1318 {
1319     int i;
1320 
1321     for (i = 0; i < sockets; i++) {
1322 	    if (socket[i].flags & IS_REGISTERED)
1323 		    pcmcia_unregister_socket(&socket[i].socket);
1324     }
1325     platform_device_unregister(i82365_device);
1326     if (poll_interval != 0)
1327 	del_timer_sync(&poll_timer);
1328     if (grab_irq != 0)
1329 	free_irq(cs_irq, pcic_interrupt);
1330     for (i = 0; i < sockets; i++) {
1331 	/* Turn off all interrupt sources! */
1332 	i365_set(i, I365_CSCINT, 0);
1333 	release_region(socket[i].ioaddr, 2);
1334     }
1335     release_region(i365_base, 2);
1336 #ifdef CONFIG_PNP
1337     if (i82365_pnpdev)
1338     		pnp_disable_dev(i82365_pnpdev);
1339 #endif
1340     platform_driver_unregister(&i82365_driver);
1341 } /* exit_i82365 */
1342 
1343 module_init(init_i82365);
1344 module_exit(exit_i82365);
1345 MODULE_DESCRIPTION("Driver for Intel 82365 and compatible PC Card controllers");
1346 MODULE_LICENSE("Dual MPL/GPL");
1347 /*====================================================================*/
1348