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