1 /* 2 * Driver for the Cirrus PD6729 PCI-PCMCIA bridge. 3 * 4 * Based on the i82092.c driver. 5 * 6 * This software may be used and distributed according to the terms of 7 * the GNU General Public License, incorporated herein by reference. 8 */ 9 10 #include <linux/kernel.h> 11 #include <linux/config.h> 12 #include <linux/module.h> 13 #include <linux/pci.h> 14 #include <linux/init.h> 15 #include <linux/workqueue.h> 16 #include <linux/interrupt.h> 17 #include <linux/device.h> 18 19 #include <pcmcia/cs_types.h> 20 #include <pcmcia/ss.h> 21 #include <pcmcia/cs.h> 22 23 #include <asm/system.h> 24 #include <asm/io.h> 25 26 #include "pd6729.h" 27 #include "i82365.h" 28 #include "cirrus.h" 29 30 MODULE_LICENSE("GPL"); 31 MODULE_DESCRIPTION("Driver for the Cirrus PD6729 PCI-PCMCIA bridge"); 32 MODULE_AUTHOR("Jun Komuro <komurojun-mbn@nifty.com>"); 33 34 #define MAX_SOCKETS 2 35 36 /* 37 * simple helper functions 38 * External clock time, in nanoseconds. 120 ns = 8.33 MHz 39 */ 40 #define to_cycles(ns) ((ns)/120) 41 42 #ifndef NO_IRQ 43 #define NO_IRQ ((unsigned int)(0)) 44 #endif 45 46 /* 47 * PARAMETERS 48 * irq_mode=n 49 * Specifies the interrupt delivery mode. The default (1) is to use PCI 50 * interrupts; a value of 0 selects ISA interrupts. This must be set for 51 * correct operation of PCI card readers. 52 * 53 * irq_list=i,j,... 54 * This list limits the set of interrupts that can be used by PCMCIA 55 * cards. 56 * The default list is 3,4,5,7,9,10,11. 57 * (irq_list parameter is not used, if irq_mode = 1) 58 */ 59 60 static int irq_mode = 1; /* 0 = ISA interrupt, 1 = PCI interrupt */ 61 static int irq_list[16]; 62 static int irq_list_count = 0; 63 64 module_param(irq_mode, int, 0444); 65 module_param_array(irq_list, int, &irq_list_count, 0444); 66 MODULE_PARM_DESC(irq_mode, 67 "interrupt delivery mode. 0 = ISA, 1 = PCI. default is 1"); 68 MODULE_PARM_DESC(irq_list, "interrupts that can be used by PCMCIA cards"); 69 70 static DEFINE_SPINLOCK(port_lock); 71 72 /* basic value read/write functions */ 73 74 static unsigned char indirect_read(struct pd6729_socket *socket, 75 unsigned short reg) 76 { 77 unsigned long port; 78 unsigned char val; 79 unsigned long flags; 80 81 spin_lock_irqsave(&port_lock, flags); 82 reg += socket->number * 0x40; 83 port = socket->io_base; 84 outb(reg, port); 85 val = inb(port + 1); 86 spin_unlock_irqrestore(&port_lock, flags); 87 88 return val; 89 } 90 91 static unsigned short indirect_read16(struct pd6729_socket *socket, 92 unsigned short reg) 93 { 94 unsigned long port; 95 unsigned short tmp; 96 unsigned long flags; 97 98 spin_lock_irqsave(&port_lock, flags); 99 reg = reg + socket->number * 0x40; 100 port = socket->io_base; 101 outb(reg, port); 102 tmp = inb(port + 1); 103 reg++; 104 outb(reg, port); 105 tmp = tmp | (inb(port + 1) << 8); 106 spin_unlock_irqrestore(&port_lock, flags); 107 108 return tmp; 109 } 110 111 static void indirect_write(struct pd6729_socket *socket, unsigned short reg, 112 unsigned char value) 113 { 114 unsigned long port; 115 unsigned long flags; 116 117 spin_lock_irqsave(&port_lock, flags); 118 reg = reg + socket->number * 0x40; 119 port = socket->io_base; 120 outb(reg, port); 121 outb(value, port + 1); 122 spin_unlock_irqrestore(&port_lock, flags); 123 } 124 125 static void indirect_setbit(struct pd6729_socket *socket, unsigned short reg, 126 unsigned char mask) 127 { 128 unsigned long port; 129 unsigned char val; 130 unsigned long flags; 131 132 spin_lock_irqsave(&port_lock, flags); 133 reg = reg + socket->number * 0x40; 134 port = socket->io_base; 135 outb(reg, port); 136 val = inb(port + 1); 137 val |= mask; 138 outb(reg, port); 139 outb(val, port + 1); 140 spin_unlock_irqrestore(&port_lock, flags); 141 } 142 143 static void indirect_resetbit(struct pd6729_socket *socket, unsigned short reg, 144 unsigned char mask) 145 { 146 unsigned long port; 147 unsigned char val; 148 unsigned long flags; 149 150 spin_lock_irqsave(&port_lock, flags); 151 reg = reg + socket->number * 0x40; 152 port = socket->io_base; 153 outb(reg, port); 154 val = inb(port + 1); 155 val &= ~mask; 156 outb(reg, port); 157 outb(val, port + 1); 158 spin_unlock_irqrestore(&port_lock, flags); 159 } 160 161 static void indirect_write16(struct pd6729_socket *socket, unsigned short reg, 162 unsigned short value) 163 { 164 unsigned long port; 165 unsigned char val; 166 unsigned long flags; 167 168 spin_lock_irqsave(&port_lock, flags); 169 reg = reg + socket->number * 0x40; 170 port = socket->io_base; 171 172 outb(reg, port); 173 val = value & 255; 174 outb(val, port + 1); 175 176 reg++; 177 178 outb(reg, port); 179 val = value >> 8; 180 outb(val, port + 1); 181 spin_unlock_irqrestore(&port_lock, flags); 182 } 183 184 /* Interrupt handler functionality */ 185 186 static irqreturn_t pd6729_interrupt(int irq, void *dev, struct pt_regs *regs) 187 { 188 struct pd6729_socket *socket = (struct pd6729_socket *)dev; 189 int i; 190 int loopcount = 0; 191 int handled = 0; 192 unsigned int events, active = 0; 193 194 while (1) { 195 loopcount++; 196 if (loopcount > 20) { 197 printk(KERN_ERR "pd6729: infinite eventloop " 198 "in interrupt\n"); 199 break; 200 } 201 202 active = 0; 203 204 for (i = 0; i < MAX_SOCKETS; i++) { 205 unsigned int csc; 206 207 /* card status change register */ 208 csc = indirect_read(&socket[i], I365_CSC); 209 if (csc == 0) /* no events on this socket */ 210 continue; 211 212 handled = 1; 213 events = 0; 214 215 if (csc & I365_CSC_DETECT) { 216 events |= SS_DETECT; 217 dprintk("Card detected in socket %i!\n", i); 218 } 219 220 if (indirect_read(&socket[i], I365_INTCTL) 221 & I365_PC_IOCARD) { 222 /* For IO/CARDS, bit 0 means "read the card" */ 223 events |= (csc & I365_CSC_STSCHG) 224 ? SS_STSCHG : 0; 225 } else { 226 /* Check for battery/ready events */ 227 events |= (csc & I365_CSC_BVD1) 228 ? SS_BATDEAD : 0; 229 events |= (csc & I365_CSC_BVD2) 230 ? SS_BATWARN : 0; 231 events |= (csc & I365_CSC_READY) 232 ? SS_READY : 0; 233 } 234 235 if (events) { 236 pcmcia_parse_events(&socket[i].socket, events); 237 } 238 active |= events; 239 } 240 241 if (active == 0) /* no more events to handle */ 242 break; 243 } 244 return IRQ_RETVAL(handled); 245 } 246 247 /* socket functions */ 248 249 static void pd6729_interrupt_wrapper(unsigned long data) 250 { 251 struct pd6729_socket *socket = (struct pd6729_socket *) data; 252 253 pd6729_interrupt(0, (void *)socket, NULL); 254 mod_timer(&socket->poll_timer, jiffies + HZ); 255 } 256 257 static int pd6729_get_status(struct pcmcia_socket *sock, u_int *value) 258 { 259 struct pd6729_socket *socket 260 = container_of(sock, struct pd6729_socket, socket); 261 unsigned int status; 262 unsigned int data; 263 struct pd6729_socket *t; 264 265 /* Interface Status Register */ 266 status = indirect_read(socket, I365_STATUS); 267 *value = 0; 268 269 if ((status & I365_CS_DETECT) == I365_CS_DETECT) { 270 *value |= SS_DETECT; 271 } 272 273 /* 274 * IO cards have a different meaning of bits 0,1 275 * Also notice the inverse-logic on the bits 276 */ 277 if (indirect_read(socket, I365_INTCTL) & I365_PC_IOCARD) { 278 /* IO card */ 279 if (!(status & I365_CS_STSCHG)) 280 *value |= SS_STSCHG; 281 } else { 282 /* non I/O card */ 283 if (!(status & I365_CS_BVD1)) 284 *value |= SS_BATDEAD; 285 if (!(status & I365_CS_BVD2)) 286 *value |= SS_BATWARN; 287 } 288 289 if (status & I365_CS_WRPROT) 290 *value |= SS_WRPROT; /* card is write protected */ 291 292 if (status & I365_CS_READY) 293 *value |= SS_READY; /* card is not busy */ 294 295 if (status & I365_CS_POWERON) 296 *value |= SS_POWERON; /* power is applied to the card */ 297 298 t = (socket->number) ? socket : socket + 1; 299 indirect_write(t, PD67_EXT_INDEX, PD67_EXTERN_DATA); 300 data = indirect_read16(t, PD67_EXT_DATA); 301 *value |= (data & PD67_EXD_VS1(socket->number)) ? 0 : SS_3VCARD; 302 303 return 0; 304 } 305 306 307 static int pd6729_set_socket(struct pcmcia_socket *sock, socket_state_t *state) 308 { 309 struct pd6729_socket *socket 310 = container_of(sock, struct pd6729_socket, socket); 311 unsigned char reg, data; 312 313 /* First, set the global controller options */ 314 indirect_write(socket, I365_GBLCTL, 0x00); 315 indirect_write(socket, I365_GENCTL, 0x00); 316 317 /* Values for the IGENC register */ 318 socket->card_irq = state->io_irq; 319 320 reg = 0; 321 /* The reset bit has "inverse" logic */ 322 if (!(state->flags & SS_RESET)) 323 reg |= I365_PC_RESET; 324 if (state->flags & SS_IOCARD) 325 reg |= I365_PC_IOCARD; 326 327 /* IGENC, Interrupt and General Control Register */ 328 indirect_write(socket, I365_INTCTL, reg); 329 330 /* Power registers */ 331 332 reg = I365_PWR_NORESET; /* default: disable resetdrv on resume */ 333 334 if (state->flags & SS_PWR_AUTO) { 335 dprintk("Auto power\n"); 336 reg |= I365_PWR_AUTO; /* automatic power mngmnt */ 337 } 338 if (state->flags & SS_OUTPUT_ENA) { 339 dprintk("Power Enabled\n"); 340 reg |= I365_PWR_OUT; /* enable power */ 341 } 342 343 switch (state->Vcc) { 344 case 0: 345 break; 346 case 33: 347 dprintk("setting voltage to Vcc to 3.3V on socket %i\n", 348 socket->number); 349 reg |= I365_VCC_5V; 350 indirect_setbit(socket, PD67_MISC_CTL_1, PD67_MC1_VCC_3V); 351 break; 352 case 50: 353 dprintk("setting voltage to Vcc to 5V on socket %i\n", 354 socket->number); 355 reg |= I365_VCC_5V; 356 indirect_resetbit(socket, PD67_MISC_CTL_1, PD67_MC1_VCC_3V); 357 break; 358 default: 359 dprintk("pd6729: pd6729_set_socket called with " 360 "invalid VCC power value: %i\n", 361 state->Vcc); 362 return -EINVAL; 363 } 364 365 switch (state->Vpp) { 366 case 0: 367 dprintk("not setting Vpp on socket %i\n", socket->number); 368 break; 369 case 33: 370 case 50: 371 dprintk("setting Vpp to Vcc for socket %i\n", socket->number); 372 reg |= I365_VPP1_5V; 373 break; 374 case 120: 375 dprintk("setting Vpp to 12.0\n"); 376 reg |= I365_VPP1_12V; 377 break; 378 default: 379 dprintk("pd6729: pd6729_set_socket called with invalid VPP power value: %i\n", 380 state->Vpp); 381 return -EINVAL; 382 } 383 384 /* only write if changed */ 385 if (reg != indirect_read(socket, I365_POWER)) 386 indirect_write(socket, I365_POWER, reg); 387 388 if (irq_mode == 1) { 389 /* all interrupts are to be done as PCI interrupts */ 390 data = PD67_EC1_INV_MGMT_IRQ | PD67_EC1_INV_CARD_IRQ; 391 } else 392 data = 0; 393 394 indirect_write(socket, PD67_EXT_INDEX, PD67_EXT_CTL_1); 395 indirect_write(socket, PD67_EXT_DATA, data); 396 397 /* Enable specific interrupt events */ 398 399 reg = 0x00; 400 if (state->csc_mask & SS_DETECT) { 401 reg |= I365_CSC_DETECT; 402 } 403 if (state->flags & SS_IOCARD) { 404 if (state->csc_mask & SS_STSCHG) 405 reg |= I365_CSC_STSCHG; 406 } else { 407 if (state->csc_mask & SS_BATDEAD) 408 reg |= I365_CSC_BVD1; 409 if (state->csc_mask & SS_BATWARN) 410 reg |= I365_CSC_BVD2; 411 if (state->csc_mask & SS_READY) 412 reg |= I365_CSC_READY; 413 } 414 if (irq_mode == 1) 415 reg |= 0x30; /* management IRQ: PCI INTA# = "irq 3" */ 416 indirect_write(socket, I365_CSCINT, reg); 417 418 reg = indirect_read(socket, I365_INTCTL); 419 if (irq_mode == 1) 420 reg |= 0x03; /* card IRQ: PCI INTA# = "irq 3" */ 421 else 422 reg |= socket->card_irq; 423 indirect_write(socket, I365_INTCTL, reg); 424 425 /* now clear the (probably bogus) pending stuff by doing a dummy read */ 426 (void)indirect_read(socket, I365_CSC); 427 428 return 0; 429 } 430 431 static int pd6729_set_io_map(struct pcmcia_socket *sock, 432 struct pccard_io_map *io) 433 { 434 struct pd6729_socket *socket 435 = container_of(sock, struct pd6729_socket, socket); 436 unsigned char map, ioctl; 437 438 map = io->map; 439 440 /* Check error conditions */ 441 if (map > 1) { 442 dprintk("pd6729_set_io_map with invalid map"); 443 return -EINVAL; 444 } 445 446 /* Turn off the window before changing anything */ 447 if (indirect_read(socket, I365_ADDRWIN) & I365_ENA_IO(map)) 448 indirect_resetbit(socket, I365_ADDRWIN, I365_ENA_IO(map)); 449 450 /* dprintk("set_io_map: Setting range to %x - %x\n", 451 io->start, io->stop);*/ 452 453 /* write the new values */ 454 indirect_write16(socket, I365_IO(map)+I365_W_START, io->start); 455 indirect_write16(socket, I365_IO(map)+I365_W_STOP, io->stop); 456 457 ioctl = indirect_read(socket, I365_IOCTL) & ~I365_IOCTL_MASK(map); 458 459 if (io->flags & MAP_0WS) ioctl |= I365_IOCTL_0WS(map); 460 if (io->flags & MAP_16BIT) ioctl |= I365_IOCTL_16BIT(map); 461 if (io->flags & MAP_AUTOSZ) ioctl |= I365_IOCTL_IOCS16(map); 462 463 indirect_write(socket, I365_IOCTL, ioctl); 464 465 /* Turn the window back on if needed */ 466 if (io->flags & MAP_ACTIVE) 467 indirect_setbit(socket, I365_ADDRWIN, I365_ENA_IO(map)); 468 469 return 0; 470 } 471 472 static int pd6729_set_mem_map(struct pcmcia_socket *sock, 473 struct pccard_mem_map *mem) 474 { 475 struct pd6729_socket *socket 476 = container_of(sock, struct pd6729_socket, socket); 477 unsigned short base, i; 478 unsigned char map; 479 480 map = mem->map; 481 if (map > 4) { 482 printk("pd6729_set_mem_map: invalid map"); 483 return -EINVAL; 484 } 485 486 if ((mem->res->start > mem->res->end) || (mem->speed > 1000)) { 487 printk("pd6729_set_mem_map: invalid address / speed"); 488 return -EINVAL; 489 } 490 491 /* Turn off the window before changing anything */ 492 if (indirect_read(socket, I365_ADDRWIN) & I365_ENA_MEM(map)) 493 indirect_resetbit(socket, I365_ADDRWIN, I365_ENA_MEM(map)); 494 495 /* write the start address */ 496 base = I365_MEM(map); 497 i = (mem->res->start >> 12) & 0x0fff; 498 if (mem->flags & MAP_16BIT) 499 i |= I365_MEM_16BIT; 500 if (mem->flags & MAP_0WS) 501 i |= I365_MEM_0WS; 502 indirect_write16(socket, base + I365_W_START, i); 503 504 /* write the stop address */ 505 506 i= (mem->res->end >> 12) & 0x0fff; 507 switch (to_cycles(mem->speed)) { 508 case 0: 509 break; 510 case 1: 511 i |= I365_MEM_WS0; 512 break; 513 case 2: 514 i |= I365_MEM_WS1; 515 break; 516 default: 517 i |= I365_MEM_WS1 | I365_MEM_WS0; 518 break; 519 } 520 521 indirect_write16(socket, base + I365_W_STOP, i); 522 523 /* Take care of high byte */ 524 indirect_write(socket, PD67_EXT_INDEX, PD67_MEM_PAGE(map)); 525 indirect_write(socket, PD67_EXT_DATA, mem->res->start >> 24); 526 527 /* card start */ 528 529 i = ((mem->card_start - mem->res->start) >> 12) & 0x3fff; 530 if (mem->flags & MAP_WRPROT) 531 i |= I365_MEM_WRPROT; 532 if (mem->flags & MAP_ATTRIB) { 533 /* dprintk("requesting attribute memory for socket %i\n", 534 socket->number);*/ 535 i |= I365_MEM_REG; 536 } else { 537 /* dprintk("requesting normal memory for socket %i\n", 538 socket->number);*/ 539 } 540 indirect_write16(socket, base + I365_W_OFF, i); 541 542 /* Enable the window if necessary */ 543 if (mem->flags & MAP_ACTIVE) 544 indirect_setbit(socket, I365_ADDRWIN, I365_ENA_MEM(map)); 545 546 return 0; 547 } 548 549 static int pd6729_init(struct pcmcia_socket *sock) 550 { 551 int i; 552 struct resource res = { .end = 0x0fff }; 553 pccard_io_map io = { 0, 0, 0, 0, 1 }; 554 pccard_mem_map mem = { .res = &res, }; 555 556 pd6729_set_socket(sock, &dead_socket); 557 for (i = 0; i < 2; i++) { 558 io.map = i; 559 pd6729_set_io_map(sock, &io); 560 } 561 for (i = 0; i < 5; i++) { 562 mem.map = i; 563 pd6729_set_mem_map(sock, &mem); 564 } 565 566 return 0; 567 } 568 569 570 /* the pccard structure and its functions */ 571 static struct pccard_operations pd6729_operations = { 572 .init = pd6729_init, 573 .get_status = pd6729_get_status, 574 .set_socket = pd6729_set_socket, 575 .set_io_map = pd6729_set_io_map, 576 .set_mem_map = pd6729_set_mem_map, 577 }; 578 579 static irqreturn_t pd6729_test(int irq, void *dev, struct pt_regs *regs) 580 { 581 dprintk("-> hit on irq %d\n", irq); 582 return IRQ_HANDLED; 583 } 584 585 static int pd6729_check_irq(int irq, int flags) 586 { 587 if (request_irq(irq, pd6729_test, flags, "x", pd6729_test) != 0) 588 return -1; 589 free_irq(irq, pd6729_test); 590 return 0; 591 } 592 593 static u_int __init pd6729_isa_scan(void) 594 { 595 u_int mask0, mask = 0; 596 int i; 597 598 if (irq_mode == 1) { 599 printk(KERN_INFO "pd6729: PCI card interrupts, " 600 "PCI status changes\n"); 601 return 0; 602 } 603 604 if (irq_list_count == 0) 605 mask0 = 0xffff; 606 else 607 for (i = mask0 = 0; i < irq_list_count; i++) 608 mask0 |= (1<<irq_list[i]); 609 610 mask0 &= PD67_MASK; 611 612 /* just find interrupts that aren't in use */ 613 for (i = 0; i < 16; i++) 614 if ((mask0 & (1 << i)) && (pd6729_check_irq(i, 0) == 0)) 615 mask |= (1 << i); 616 617 printk(KERN_INFO "pd6729: ISA irqs = "); 618 for (i = 0; i < 16; i++) 619 if (mask & (1<<i)) 620 printk("%s%d", ((mask & ((1<<i)-1)) ? "," : ""), i); 621 622 if (mask == 0) printk("none!"); 623 624 printk(" polling status changes.\n"); 625 626 return mask; 627 } 628 629 static int __devinit pd6729_pci_probe(struct pci_dev *dev, 630 const struct pci_device_id *id) 631 { 632 int i, j, ret; 633 u_int mask; 634 char configbyte; 635 struct pd6729_socket *socket; 636 637 socket = kzalloc(sizeof(struct pd6729_socket) * MAX_SOCKETS, 638 GFP_KERNEL); 639 if (!socket) 640 return -ENOMEM; 641 642 if ((ret = pci_enable_device(dev))) 643 goto err_out_free_mem; 644 645 printk(KERN_INFO "pd6729: Cirrus PD6729 PCI to PCMCIA Bridge " 646 "at 0x%lx on irq %d\n", pci_resource_start(dev, 0), dev->irq); 647 /* 648 * Since we have no memory BARs some firmware may not 649 * have had PCI_COMMAND_MEMORY enabled, yet the device needs it. 650 */ 651 pci_read_config_byte(dev, PCI_COMMAND, &configbyte); 652 if (!(configbyte & PCI_COMMAND_MEMORY)) { 653 printk(KERN_DEBUG "pd6729: Enabling PCI_COMMAND_MEMORY.\n"); 654 configbyte |= PCI_COMMAND_MEMORY; 655 pci_write_config_byte(dev, PCI_COMMAND, configbyte); 656 } 657 658 ret = pci_request_regions(dev, "pd6729"); 659 if (ret) { 660 printk(KERN_INFO "pd6729: pci request region failed.\n"); 661 goto err_out_disable; 662 } 663 664 if (dev->irq == NO_IRQ) 665 irq_mode = 0; /* fall back to ISA interrupt mode */ 666 667 mask = pd6729_isa_scan(); 668 if (irq_mode == 0 && mask == 0) { 669 printk(KERN_INFO "pd6729: no ISA interrupt is available.\n"); 670 goto err_out_free_res; 671 } 672 673 for (i = 0; i < MAX_SOCKETS; i++) { 674 socket[i].io_base = pci_resource_start(dev, 0); 675 socket[i].socket.features |= SS_CAP_PAGE_REGS | SS_CAP_PCCARD; 676 socket[i].socket.map_size = 0x1000; 677 socket[i].socket.irq_mask = mask; 678 socket[i].socket.pci_irq = dev->irq; 679 socket[i].socket.owner = THIS_MODULE; 680 681 socket[i].number = i; 682 683 socket[i].socket.ops = &pd6729_operations; 684 socket[i].socket.resource_ops = &pccard_nonstatic_ops; 685 socket[i].socket.dev.dev = &dev->dev; 686 socket[i].socket.driver_data = &socket[i]; 687 } 688 689 pci_set_drvdata(dev, socket); 690 if (irq_mode == 1) { 691 /* Register the interrupt handler */ 692 if ((ret = request_irq(dev->irq, pd6729_interrupt, SA_SHIRQ, 693 "pd6729", socket))) { 694 printk(KERN_ERR "pd6729: Failed to register irq %d, " 695 "aborting\n", dev->irq); 696 goto err_out_free_res; 697 } 698 } else { 699 /* poll Card status change */ 700 init_timer(&socket->poll_timer); 701 socket->poll_timer.function = pd6729_interrupt_wrapper; 702 socket->poll_timer.data = (unsigned long)socket; 703 socket->poll_timer.expires = jiffies + HZ; 704 add_timer(&socket->poll_timer); 705 } 706 707 for (i = 0; i < MAX_SOCKETS; i++) { 708 ret = pcmcia_register_socket(&socket[i].socket); 709 if (ret) { 710 printk(KERN_INFO "pd6729: pcmcia_register_socket " 711 "failed.\n"); 712 for (j = 0; j < i ; j++) 713 pcmcia_unregister_socket(&socket[j].socket); 714 goto err_out_free_res2; 715 } 716 } 717 718 return 0; 719 720 err_out_free_res2: 721 if (irq_mode == 1) 722 free_irq(dev->irq, socket); 723 else 724 del_timer_sync(&socket->poll_timer); 725 err_out_free_res: 726 pci_release_regions(dev); 727 err_out_disable: 728 pci_disable_device(dev); 729 730 err_out_free_mem: 731 kfree(socket); 732 return ret; 733 } 734 735 static void __devexit pd6729_pci_remove(struct pci_dev *dev) 736 { 737 int i; 738 struct pd6729_socket *socket = pci_get_drvdata(dev); 739 740 for (i = 0; i < MAX_SOCKETS; i++) { 741 /* Turn off all interrupt sources */ 742 indirect_write(&socket[i], I365_CSCINT, 0); 743 indirect_write(&socket[i], I365_INTCTL, 0); 744 745 pcmcia_unregister_socket(&socket[i].socket); 746 } 747 748 if (irq_mode == 1) 749 free_irq(dev->irq, socket); 750 else 751 del_timer_sync(&socket->poll_timer); 752 pci_release_regions(dev); 753 pci_disable_device(dev); 754 755 kfree(socket); 756 } 757 758 static int pd6729_socket_suspend(struct pci_dev *dev, pm_message_t state) 759 { 760 return pcmcia_socket_dev_suspend(&dev->dev, state); 761 } 762 763 static int pd6729_socket_resume(struct pci_dev *dev) 764 { 765 return pcmcia_socket_dev_resume(&dev->dev); 766 } 767 768 static struct pci_device_id pd6729_pci_ids[] = { 769 { 770 .vendor = PCI_VENDOR_ID_CIRRUS, 771 .device = PCI_DEVICE_ID_CIRRUS_6729, 772 .subvendor = PCI_ANY_ID, 773 .subdevice = PCI_ANY_ID, 774 }, 775 { } 776 }; 777 MODULE_DEVICE_TABLE(pci, pd6729_pci_ids); 778 779 static struct pci_driver pd6729_pci_drv = { 780 .name = "pd6729", 781 .id_table = pd6729_pci_ids, 782 .probe = pd6729_pci_probe, 783 .remove = __devexit_p(pd6729_pci_remove), 784 .suspend = pd6729_socket_suspend, 785 .resume = pd6729_socket_resume, 786 }; 787 788 static int pd6729_module_init(void) 789 { 790 return pci_register_driver(&pd6729_pci_drv); 791 } 792 793 static void pd6729_module_exit(void) 794 { 795 pci_unregister_driver(&pd6729_pci_drv); 796 } 797 798 module_init(pd6729_module_init); 799 module_exit(pd6729_module_exit); 800