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