drivers/pcmcia/pd6729.c

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