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