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