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