SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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/pci.h>
  13 #include <linux/init.h>
  14 #include <linux/workqueue.h>
  15 #include <linux/interrupt.h>
  16 #include <linux/device.h>
  17
  18 #include <pcmcia/cs_types.h>
  19 #include <pcmcia/ss.h>
  20 #include <pcmcia/cs.h>
  21
  22 #include <asm/system.h>
  23 #include <asm/io.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         /*
 264          * IO cards have a different meaning of bits 0,1
 265          * Also notice the inverse-logic on the bits
 266          */
 267         if (indirect_read(socket, I365_INTCTL) & I365_PC_IOCARD) {
 268                 /* IO card */
 269                 if (!(status & I365_CS_STSCHG))
 270                         *value |= SS_STSCHG;
 271         } else {
 272                 /* non I/O card */
 273                 if (!(status & I365_CS_BVD1))
 274                         *value |= SS_BATDEAD;
 275                 if (!(status & I365_CS_BVD2))
 276                         *value |= SS_BATWARN;
 277         }
 278
 279         if (status & I365_CS_WRPROT)
 280                 *value |= SS_WRPROT;    /* card is write protected */
 281
 282         if (status & I365_CS_READY)
 283                 *value |= SS_READY;     /* card is not busy */
 284
 285         if (status & I365_CS_POWERON)
 286                 *value |= SS_POWERON;   /* power is applied to the card */
 287
 288         t = (socket->number) ? socket : socket + 1;
 289         indirect_write(t, PD67_EXT_INDEX, PD67_EXTERN_DATA);
 290         data = indirect_read16(t, PD67_EXT_DATA);
 291         *value |= (data & PD67_EXD_VS1(socket->number)) ? 0 : SS_3VCARD;
 292
 293         return 0;
 294 }
 295
 296
 297 static int pd6729_set_socket(struct pcmcia_socket *sock, socket_state_t *state)
 298 {
 299         struct pd6729_socket *socket
 300                         = container_of(sock, struct pd6729_socket, socket);
 301         unsigned char reg, data;
 302
 303         /* First, set the global controller options */
 304         indirect_write(socket, I365_GBLCTL, 0x00);
 305         indirect_write(socket, I365_GENCTL, 0x00);
 306
 307         /* Values for the IGENC register */
 308         socket->card_irq = state->io_irq;
 309
 310         reg = 0;
 311         /* The reset bit has "inverse" logic */
 312         if (!(state->flags & SS_RESET))
 313                 reg |= I365_PC_RESET;
 314         if (state->flags & SS_IOCARD)
 315                 reg |= I365_PC_IOCARD;
 316
 317         /* IGENC, Interrupt and General Control Register */
 318         indirect_write(socket, I365_INTCTL, reg);
 319
 320         /* Power registers */
 321
 322         reg = I365_PWR_NORESET; /* default: disable resetdrv on resume */
 323
 324         if (state->flags & SS_PWR_AUTO) {
 325                 dev_dbg(&sock->dev, "Auto power\n");
 326                 reg |= I365_PWR_AUTO;   /* automatic power mngmnt */
 327         }
 328         if (state->flags & SS_OUTPUT_ENA) {
 329                 dev_dbg(&sock->dev, "Power Enabled\n");
 330                 reg |= I365_PWR_OUT;    /* enable power */
 331         }
 332
 333         switch (state->Vcc) {
 334         case 0:
 335                 break;
 336         case 33:
 337                 dev_dbg(&sock->dev,
 338                         "setting voltage to Vcc to 3.3V on socket %i\n",
 339                         socket->number);
 340                 reg |= I365_VCC_5V;
 341                 indirect_setbit(socket, PD67_MISC_CTL_1, PD67_MC1_VCC_3V);
 342                 break;
 343         case 50:
 344                 dev_dbg(&sock->dev,
 345                         "setting voltage to Vcc to 5V on socket %i\n",
 346                         socket->number);
 347                 reg |= I365_VCC_5V;
 348                 indirect_resetbit(socket, PD67_MISC_CTL_1, PD67_MC1_VCC_3V);
 349                 break;
 350         default:
 351                 dev_dbg(&sock->dev,
 352                         "pd6729_set_socket called with invalid VCC power "
 353                         "value: %i\n", state->Vcc);
 354                 return -EINVAL;
 355         }
 356
 357         switch (state->Vpp) {
 358         case 0:
 359                 dev_dbg(&sock->dev, "not setting Vpp on socket %i\n",
 360                         socket->number);
 361                 break;
 362         case 33:
 363         case 50:
 364                 dev_dbg(&sock->dev, "setting Vpp to Vcc for socket %i\n",
 365                         socket->number);
 366                 reg |= I365_VPP1_5V;
 367                 break;
 368         case 120:
 369                 dev_dbg(&sock->dev, "setting Vpp to 12.0\n");
 370                 reg |= I365_VPP1_12V;
 371                 break;
 372         default:
 373                 dev_dbg(&sock->dev, "pd6729: pd6729_set_socket called with "
 374                         "invalid VPP power value: %i\n", state->Vpp);
 375                 return -EINVAL;
 376         }
 377
 378         /* only write if changed */
 379         if (reg != indirect_read(socket, I365_POWER))
 380                 indirect_write(socket, I365_POWER, reg);
 381
 382         if (irq_mode == 1) {
 383                  /* all interrupts are to be done as PCI interrupts */
 384                 data = PD67_EC1_INV_MGMT_IRQ | PD67_EC1_INV_CARD_IRQ;
 385         } else
 386                 data = 0;
 387
 388         indirect_write(socket, PD67_EXT_INDEX, PD67_EXT_CTL_1);
 389         indirect_write(socket, PD67_EXT_DATA, data);
 390
 391         /* Enable specific interrupt events */
 392
 393         reg = 0x00;
 394         if (state->csc_mask & SS_DETECT) {
 395                 reg |= I365_CSC_DETECT;
 396         }
 397         if (state->flags & SS_IOCARD) {
 398                 if (state->csc_mask & SS_STSCHG)
 399                         reg |= I365_CSC_STSCHG;
 400         } else {
 401                 if (state->csc_mask & SS_BATDEAD)
 402                         reg |= I365_CSC_BVD1;
 403                 if (state->csc_mask & SS_BATWARN)
 404                         reg |= I365_CSC_BVD2;
 405                 if (state->csc_mask & SS_READY)
 406                         reg |= I365_CSC_READY;
 407         }
 408         if (irq_mode == 1)
 409                 reg |= 0x30;    /* management IRQ: PCI INTA# = "irq 3" */
 410         indirect_write(socket, I365_CSCINT, reg);
 411
 412         reg = indirect_read(socket, I365_INTCTL);
 413         if (irq_mode == 1)
 414                 reg |= 0x03;    /* card IRQ: PCI INTA# = "irq 3" */
 415         else
 416                 reg |= socket->card_irq;
 417         indirect_write(socket, I365_INTCTL, reg);
 418
 419         /* now clear the (probably bogus) pending stuff by doing a dummy read */
 420         (void)indirect_read(socket, I365_CSC);
 421
 422         return 0;
 423 }
 424
 425 static int pd6729_set_io_map(struct pcmcia_socket *sock,
 426                              struct pccard_io_map *io)
 427 {
 428         struct pd6729_socket *socket
 429                         = container_of(sock, struct pd6729_socket, socket);
 430         unsigned char map, ioctl;
 431
 432         map = io->map;
 433
 434         /* Check error conditions */
 435         if (map > 1) {
 436                 dev_dbg(&sock->dev, "pd6729_set_io_map with invalid map\n");
 437                 return -EINVAL;
 438         }
 439
 440         /* Turn off the window before changing anything */
 441         if (indirect_read(socket, I365_ADDRWIN) & I365_ENA_IO(map))
 442                 indirect_resetbit(socket, I365_ADDRWIN, I365_ENA_IO(map));
 443
 444         /* dev_dbg(&sock->dev, "set_io_map: Setting range to %x - %x\n",
 445            io->start, io->stop);*/
 446
 447         /* write the new values */
 448         indirect_write16(socket, I365_IO(map)+I365_W_START, io->start);
 449         indirect_write16(socket, I365_IO(map)+I365_W_STOP, io->stop);
 450
 451         ioctl = indirect_read(socket, I365_IOCTL) & ~I365_IOCTL_MASK(map);
 452
 453         if (io->flags & MAP_0WS) ioctl |= I365_IOCTL_0WS(map);
 454         if (io->flags & MAP_16BIT) ioctl |= I365_IOCTL_16BIT(map);
 455         if (io->flags & MAP_AUTOSZ) 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         if (request_irq(irq, pd6729_test, IRQF_PROBE_SHARED, "x", pd6729_test)
 582                 != 0) return -1;
 583         free_irq(irq, pd6729_test);
 584         return 0;
 585 }
 586
 587 static u_int __devinit pd6729_isa_scan(void)
 588 {
 589         u_int mask0, mask = 0;
 590         int i;
 591
 592         if (irq_mode == 1) {
 593                 printk(KERN_INFO "pd6729: PCI card interrupts, "
 594                                                 "PCI status changes\n");
 595                 return 0;
 596         }
 597
 598         mask0 = PD67_MASK;
 599
 600         /* just find interrupts that aren't in use */
 601         for (i = 0; i < 16; i++)
 602                 if ((mask0 & (1 << i)) && (pd6729_check_irq(i) == 0))
 603                         mask |= (1 << i);
 604
 605         printk(KERN_INFO "pd6729: ISA irqs = ");
 606         for (i = 0; i < 16; i++)
 607                 if (mask & (1<<i))
 608                         printk("%s%d", ((mask & ((1<<i)-1)) ? "," : ""), i);
 609
 610         if (mask == 0) printk("none!");
 611
 612         printk("  polling status changes.\n");
 613
 614         return mask;
 615 }
 616
 617 static int __devinit pd6729_pci_probe(struct pci_dev *dev,
 618                                       const struct pci_device_id *id)
 619 {
 620         int i, j, ret;
 621         u_int mask;
 622         char configbyte;
 623         struct pd6729_socket *socket;
 624
 625         socket = kzalloc(sizeof(struct pd6729_socket) * MAX_SOCKETS,
 626                          GFP_KERNEL);
 627         if (!socket)
 628                 return -ENOMEM;
 629
 630         if ((ret = pci_enable_device(dev)))
 631                 goto err_out_free_mem;
 632
 633         if (!pci_resource_start(dev, 0)) {
 634                 dev_warn(&dev->dev, "refusing to load the driver as the "
 635                         "io_base is NULL.\n");
 636                 goto err_out_free_mem;
 637         }
 638
 639         dev_info(&dev->dev, "Cirrus PD6729 PCI to PCMCIA Bridge at 0x%llx "
 640                 "on irq %d\n",
 641                 (unsigned long long)pci_resource_start(dev, 0), dev->irq);
 642         /*
 643          * Since we have no memory BARs some firmware may not
 644          * have had PCI_COMMAND_MEMORY enabled, yet the device needs it.
 645          */
 646         pci_read_config_byte(dev, PCI_COMMAND, &configbyte);
 647         if (!(configbyte & PCI_COMMAND_MEMORY)) {
 648                 dev_dbg(&dev->dev, "pd6729: Enabling PCI_COMMAND_MEMORY.\n");
 649                 configbyte |= PCI_COMMAND_MEMORY;
 650                 pci_write_config_byte(dev, PCI_COMMAND, configbyte);
 651         }
 652
 653         ret = pci_request_regions(dev, "pd6729");
 654         if (ret) {
 655                 dev_warn(&dev->dev, "pci request region failed.\n");
 656                 goto err_out_disable;
 657         }
 658
 659         if (dev->irq == NO_IRQ)
 660                 irq_mode = 0;   /* fall back to ISA interrupt mode */
 661
 662         mask = pd6729_isa_scan();
 663         if (irq_mode == 0 && mask == 0) {
 664                 dev_warn(&dev->dev, "no ISA interrupt is available.\n");
 665                 goto err_out_free_res;
 666         }
 667
 668         for (i = 0; i < MAX_SOCKETS; i++) {
 669                 socket[i].io_base = pci_resource_start(dev, 0);
 670                 socket[i].socket.features |= SS_CAP_PAGE_REGS | SS_CAP_PCCARD;
 671                 socket[i].socket.map_size = 0x1000;
 672                 socket[i].socket.irq_mask = mask;
 673                 socket[i].socket.pci_irq  = dev->irq;
 674                 socket[i].socket.owner = THIS_MODULE;
 675
 676                 socket[i].number = i;
 677
 678                 socket[i].socket.ops = &pd6729_operations;
 679                 socket[i].socket.resource_ops = &pccard_nonstatic_ops;
 680                 socket[i].socket.dev.parent = &dev->dev;
 681                 socket[i].socket.driver_data = &socket[i];
 682         }
 683
 684         pci_set_drvdata(dev, socket);
 685         if (irq_mode == 1) {
 686                 /* Register the interrupt handler */
 687                 if ((ret = request_irq(dev->irq, pd6729_interrupt, IRQF_SHARED,
 688                                                         "pd6729", socket))) {
 689                         dev_err(&dev->dev, "Failed to register irq %d\n",
 690                                 dev->irq);
 691                         goto err_out_free_res;
 692                 }
 693         } else {
 694                 /* poll Card status change */
 695                 init_timer(&socket->poll_timer);
 696                 socket->poll_timer.function = pd6729_interrupt_wrapper;
 697                 socket->poll_timer.data = (unsigned long)socket;
 698                 socket->poll_timer.expires = jiffies + HZ;
 699                 add_timer(&socket->poll_timer);
 700         }
 701
 702         for (i = 0; i < MAX_SOCKETS; i++) {
 703                 ret = pcmcia_register_socket(&socket[i].socket);
 704                 if (ret) {
 705                         dev_warn(&dev->dev, "pcmcia_register_socket failed.\n");
 706                         for (j = 0; j < i ; j++)
 707                                 pcmcia_unregister_socket(&socket[j].socket);
 708                         goto err_out_free_res2;
 709                 }
 710         }
 711
 712         return 0;
 713
 714  err_out_free_res2:
 715         if (irq_mode == 1)
 716                 free_irq(dev->irq, socket);
 717         else
 718                 del_timer_sync(&socket->poll_timer);
 719  err_out_free_res:
 720         pci_release_regions(dev);
 721  err_out_disable:
 722         pci_disable_device(dev);
 723
 724  err_out_free_mem:
 725         kfree(socket);
 726         return ret;
 727 }
 728
 729 static void __devexit pd6729_pci_remove(struct pci_dev *dev)
 730 {
 731         int i;
 732         struct pd6729_socket *socket = pci_get_drvdata(dev);
 733
 734         for (i = 0; i < MAX_SOCKETS; i++) {
 735                 /* Turn off all interrupt sources */
 736                 indirect_write(&socket[i], I365_CSCINT, 0);
 737                 indirect_write(&socket[i], I365_INTCTL, 0);
 738
 739                 pcmcia_unregister_socket(&socket[i].socket);
 740         }
 741
 742         if (irq_mode == 1)
 743                 free_irq(dev->irq, socket);
 744         else
 745                 del_timer_sync(&socket->poll_timer);
 746         pci_release_regions(dev);
 747         pci_disable_device(dev);
 748
 749         kfree(socket);
 750 }
 751
 752 #ifdef CONFIG_PM
 753 static int pd6729_socket_suspend(struct pci_dev *dev, pm_message_t state)
 754 {
 755         return pcmcia_socket_dev_suspend(&dev->dev);
 756 }
 757
 758 static int pd6729_socket_resume(struct pci_dev *dev)
 759 {
 760         return pcmcia_socket_dev_resume(&dev->dev);
 761 }
 762 #endif
 763
 764 static struct pci_device_id pd6729_pci_ids[] = {
 765         {
 766                 .vendor         = PCI_VENDOR_ID_CIRRUS,
 767                 .device         = PCI_DEVICE_ID_CIRRUS_6729,
 768                 .subvendor      = PCI_ANY_ID,
 769                 .subdevice      = PCI_ANY_ID,
 770         },
 771         { }
 772 };
 773 MODULE_DEVICE_TABLE(pci, pd6729_pci_ids);
 774
 775 static struct pci_driver pd6729_pci_driver = {
 776         .name           = "pd6729",
 777         .id_table       = pd6729_pci_ids,
 778         .probe          = pd6729_pci_probe,
 779         .remove         = __devexit_p(pd6729_pci_remove),
 780 #ifdef CONFIG_PM
 781         .suspend        = pd6729_socket_suspend,
 782         .resume         = pd6729_socket_resume,
 783 #endif
 784 };
 785
 786 static int pd6729_module_init(void)
 787 {
 788         return pci_register_driver(&pd6729_pci_driver);
 789 }
 790
 791 static void pd6729_module_exit(void)
 792 {
 793         pci_unregister_driver(&pd6729_pci_driver);
 794 }
 795
 796 module_init(pd6729_module_init);
 797 module_exit(pd6729_module_exit);