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