drivers/net/apne.c

   1 /*
   2  * Amiga Linux/68k 8390 based PCMCIA Ethernet Driver for the Amiga 1200
   3  *
   4  * (C) Copyright 1997 Alain Malek
   5  *                    (Alain.Malek@cryogen.com)
   6  *
   7  * ----------------------------------------------------------------------------
   8  *
   9  * This program is based on
  10  *
  11  * ne.c:       A general non-shared-memory NS8390 ethernet driver for linux
  12  *             Written 1992-94 by Donald Becker.
  13  *
  14  * 8390.c:     A general NS8390 ethernet driver core for linux.
  15  *             Written 1992-94 by Donald Becker.
  16  *
  17  * cnetdevice: A Sana-II ethernet driver for AmigaOS
  18  *             Written by Bruce Abbott (bhabbott@inhb.co.nz)
  19  *
  20  * ----------------------------------------------------------------------------
  21  *
  22  * This file is subject to the terms and conditions of the GNU General Public
  23  * License.  See the file COPYING in the main directory of the Linux
  24  * distribution for more details.
  25  *
  26  * ----------------------------------------------------------------------------
  27  *
  28  */
  29
  30
  31 #include <linux/module.h>
  32 #include <linux/kernel.h>
  33 #include <linux/errno.h>
  34 #include <linux/pci.h>
  35 #include <linux/init.h>
  36 #include <linux/delay.h>
  37 #include <linux/netdevice.h>
  38 #include <linux/etherdevice.h>
  39 #include <linux/jiffies.h>
  40
  41 #include <asm/system.h>
  42 #include <asm/io.h>
  43 #include <asm/setup.h>
  44 #include <asm/amigaints.h>
  45 #include <asm/amigahw.h>
  46 #include <asm/amigayle.h>
  47 #include <asm/amipcmcia.h>
  48
  49 #include "8390.h"
  50
  51 /* ---- No user-serviceable parts below ---- */
  52
  53 #define DRV_NAME "apne"
  54
  55 #define NE_BASE  (dev->base_addr)
  56 #define NE_CMD                  0x00
  57 #define NE_DATAPORT             0x10            /* NatSemi-defined port window offset. */
  58 #define NE_RESET                0x1f            /* Issue a read to reset, a write to clear. */
  59 #define NE_IO_EXTENT            0x20
  60
  61 #define NE_EN0_ISR              0x07
  62 #define NE_EN0_DCFG             0x0e
  63
  64 #define NE_EN0_RSARLO           0x08
  65 #define NE_EN0_RSARHI           0x09
  66 #define NE_EN0_RCNTLO           0x0a
  67 #define NE_EN0_RXCR             0x0c
  68 #define NE_EN0_TXCR             0x0d
  69 #define NE_EN0_RCNTHI           0x0b
  70 #define NE_EN0_IMR              0x0f
  71
  72 #define NE1SM_START_PG  0x20    /* First page of TX buffer */
  73 #define NE1SM_STOP_PG   0x40    /* Last page +1 of RX ring */
  74 #define NESM_START_PG   0x40    /* First page of TX buffer */
  75 #define NESM_STOP_PG    0x80    /* Last page +1 of RX ring */
  76
  77
  78 struct net_device * __init apne_probe(int unit);
  79 static int apne_probe1(struct net_device *dev, int ioaddr);
  80
  81 static int apne_open(struct net_device *dev);
  82 static int apne_close(struct net_device *dev);
  83
  84 static void apne_reset_8390(struct net_device *dev);
  85 static void apne_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
  86                           int ring_page);
  87 static void apne_block_input(struct net_device *dev, int count,
  88                                                                 struct sk_buff *skb, int ring_offset);
  89 static void apne_block_output(struct net_device *dev, const int count,
  90                                                         const unsigned char *buf, const int start_page);
  91 static irqreturn_t apne_interrupt(int irq, void *dev_id);
  92
  93 static int init_pcmcia(void);
  94
  95 /* IO base address used for nic */
  96
  97 #define IOBASE 0x300
  98
  99 /*
 100    use MANUAL_CONFIG and MANUAL_OFFSET for enabling IO by hand
 101    you can find the values to use by looking at the cnet.device
 102    config file example (the default values are for the CNET40BC card)
 103 */
 104
 105 /*
 106 #define MANUAL_CONFIG 0x20
 107 #define MANUAL_OFFSET 0x3f8
 108
 109 #define MANUAL_HWADDR0 0x00
 110 #define MANUAL_HWADDR1 0x12
 111 #define MANUAL_HWADDR2 0x34
 112 #define MANUAL_HWADDR3 0x56
 113 #define MANUAL_HWADDR4 0x78
 114 #define MANUAL_HWADDR5 0x9a
 115 */
 116
 117 static const char version[] =
 118     "apne.c:v1.1 7/10/98 Alain Malek (Alain.Malek@cryogen.ch)\n";
 119
 120 static int apne_owned;  /* signal if card already owned */
 121
 122 struct net_device * __init apne_probe(int unit)
 123 {
 124         struct net_device *dev;
 125 #ifndef MANUAL_CONFIG
 126         char tuple[8];
 127 #endif
 128         int err;
 129
 130         if (apne_owned)
 131                 return ERR_PTR(-ENODEV);
 132
 133         if ( !(AMIGAHW_PRESENT(PCMCIA)) )
 134                 return ERR_PTR(-ENODEV);
 135
 136         printk("Looking for PCMCIA ethernet card : ");
 137
 138         /* check if a card is inserted */
 139         if (!(PCMCIA_INSERTED)) {
 140                 printk("NO PCMCIA card inserted\n");
 141                 return ERR_PTR(-ENODEV);
 142         }
 143
 144         dev = alloc_ei_netdev();
 145         if (!dev)
 146                 return ERR_PTR(-ENOMEM);
 147         if (unit >= 0) {
 148                 sprintf(dev->name, "eth%d", unit);
 149                 netdev_boot_setup_check(dev);
 150         }
 151         SET_MODULE_OWNER(dev);
 152
 153         /* disable pcmcia irq for readtuple */
 154         pcmcia_disable_irq();
 155
 156 #ifndef MANUAL_CONFIG
 157         if ((pcmcia_copy_tuple(CISTPL_FUNCID, tuple, 8) < 3) ||
 158                 (tuple[2] != CISTPL_FUNCID_NETWORK)) {
 159                 printk("not an ethernet card\n");
 160                 /* XXX: shouldn't we re-enable irq here? */
 161                 free_netdev(dev);
 162                 return ERR_PTR(-ENODEV);
 163         }
 164 #endif
 165
 166         printk("ethernet PCMCIA card inserted\n");
 167
 168         if (!init_pcmcia()) {
 169                 /* XXX: shouldn't we re-enable irq here? */
 170                 free_netdev(dev);
 171                 return ERR_PTR(-ENODEV);
 172         }
 173
 174         if (!request_region(IOBASE, 0x20, DRV_NAME)) {
 175                 free_netdev(dev);
 176                 return ERR_PTR(-EBUSY);
 177         }
 178
 179         err = apne_probe1(dev, IOBASE);
 180         if (err) {
 181                 release_region(IOBASE, 0x20);
 182                 free_netdev(dev);
 183                 return ERR_PTR(err);
 184         }
 185         err = register_netdev(dev);
 186         if (!err)
 187                 return dev;
 188
 189         pcmcia_disable_irq();
 190         free_irq(IRQ_AMIGA_PORTS, dev);
 191         pcmcia_reset();
 192         release_region(IOBASE, 0x20);
 193         free_netdev(dev);
 194         return ERR_PTR(err);
 195 }
 196
 197 static int __init apne_probe1(struct net_device *dev, int ioaddr)
 198 {
 199     int i;
 200     unsigned char SA_prom[32];
 201     int wordlength = 2;
 202     const char *name = NULL;
 203     int start_page, stop_page;
 204 #ifndef MANUAL_HWADDR0
 205     int neX000, ctron;
 206 #endif
 207     static unsigned version_printed;
 208
 209     if (ei_debug  &&  version_printed++ == 0)
 210         printk(version);
 211
 212     printk("PCMCIA NE*000 ethercard probe");
 213
 214     /* Reset card. Who knows what dain-bramaged state it was left in. */
 215     {   unsigned long reset_start_time = jiffies;
 216
 217         outb(inb(ioaddr + NE_RESET), ioaddr + NE_RESET);
 218
 219         while ((inb(ioaddr + NE_EN0_ISR) & ENISR_RESET) == 0)
 220                 if (time_after(jiffies, reset_start_time + 2*HZ/100)) {
 221                         printk(" not found (no reset ack).\n");
 222                         return -ENODEV;
 223                 }
 224
 225         outb(0xff, ioaddr + NE_EN0_ISR);                /* Ack all intr. */
 226     }
 227
 228 #ifndef MANUAL_HWADDR0
 229
 230     /* Read the 16 bytes of station address PROM.
 231        We must first initialize registers, similar to NS8390_init(eifdev, 0).
 232        We can't reliably read the SAPROM address without this.
 233        (I learned the hard way!). */
 234     {
 235         struct {unsigned long value, offset; } program_seq[] = {
 236             {E8390_NODMA+E8390_PAGE0+E8390_STOP, NE_CMD}, /* Select page 0*/
 237             {0x48,      NE_EN0_DCFG},   /* Set byte-wide (0x48) access. */
 238             {0x00,      NE_EN0_RCNTLO}, /* Clear the count regs. */
 239             {0x00,      NE_EN0_RCNTHI},
 240             {0x00,      NE_EN0_IMR},    /* Mask completion irq. */
 241             {0xFF,      NE_EN0_ISR},
 242             {E8390_RXOFF, NE_EN0_RXCR}, /* 0x20  Set to monitor */
 243             {E8390_TXOFF, NE_EN0_TXCR}, /* 0x02  and loopback mode. */
 244             {32,        NE_EN0_RCNTLO},
 245             {0x00,      NE_EN0_RCNTHI},
 246             {0x00,      NE_EN0_RSARLO}, /* DMA starting at 0x0000. */
 247             {0x00,      NE_EN0_RSARHI},
 248             {E8390_RREAD+E8390_START, NE_CMD},
 249         };
 250         for (i = 0; i < sizeof(program_seq)/sizeof(program_seq[0]); i++) {
 251             outb(program_seq[i].value, ioaddr + program_seq[i].offset);
 252         }
 253
 254     }
 255     for(i = 0; i < 32 /*sizeof(SA_prom)*/; i+=2) {
 256         SA_prom[i] = inb(ioaddr + NE_DATAPORT);
 257         SA_prom[i+1] = inb(ioaddr + NE_DATAPORT);
 258         if (SA_prom[i] != SA_prom[i+1])
 259             wordlength = 1;
 260     }
 261
 262     /*  At this point, wordlength *only* tells us if the SA_prom is doubled
 263         up or not because some broken PCI cards don't respect the byte-wide
 264         request in program_seq above, and hence don't have doubled up values.
 265         These broken cards would otherwise be detected as an ne1000.  */
 266
 267     if (wordlength == 2)
 268         for (i = 0; i < 16; i++)
 269                 SA_prom[i] = SA_prom[i+i];
 270
 271     if (wordlength == 2) {
 272         /* We must set the 8390 for word mode. */
 273         outb(0x49, ioaddr + NE_EN0_DCFG);
 274         start_page = NESM_START_PG;
 275         stop_page = NESM_STOP_PG;
 276     } else {
 277         start_page = NE1SM_START_PG;
 278         stop_page = NE1SM_STOP_PG;
 279     }
 280
 281     neX000 = (SA_prom[14] == 0x57  &&  SA_prom[15] == 0x57);
 282     ctron =  (SA_prom[0] == 0x00 && SA_prom[1] == 0x00 && SA_prom[2] == 0x1d);
 283
 284     /* Set up the rest of the parameters. */
 285     if (neX000) {
 286         name = (wordlength == 2) ? "NE2000" : "NE1000";
 287     } else if (ctron) {
 288         name = (wordlength == 2) ? "Ctron-8" : "Ctron-16";
 289         start_page = 0x01;
 290         stop_page = (wordlength == 2) ? 0x40 : 0x20;
 291     } else {
 292         printk(" not found.\n");
 293         return -ENXIO;
 294
 295     }
 296
 297 #else
 298     wordlength = 2;
 299     /* We must set the 8390 for word mode. */
 300     outb(0x49, ioaddr + NE_EN0_DCFG);
 301     start_page = NESM_START_PG;
 302     stop_page = NESM_STOP_PG;
 303
 304     SA_prom[0] = MANUAL_HWADDR0;
 305     SA_prom[1] = MANUAL_HWADDR1;
 306     SA_prom[2] = MANUAL_HWADDR2;
 307     SA_prom[3] = MANUAL_HWADDR3;
 308     SA_prom[4] = MANUAL_HWADDR4;
 309     SA_prom[5] = MANUAL_HWADDR5;
 310     name = "NE2000";
 311 #endif
 312
 313     dev->base_addr = ioaddr;
 314     dev->irq = IRQ_AMIGA_PORTS;
 315
 316     /* Install the Interrupt handler */
 317     i = request_irq(dev->irq, apne_interrupt, IRQF_SHARED, DRV_NAME, dev);
 318     if (i) return i;
 319
 320     for(i = 0; i < ETHER_ADDR_LEN; i++) {
 321         printk(" %2.2x", SA_prom[i]);
 322         dev->dev_addr[i] = SA_prom[i];
 323     }
 324
 325     printk("\n%s: %s found.\n", dev->name, name);
 326
 327     ei_status.name = name;
 328     ei_status.tx_start_page = start_page;
 329     ei_status.stop_page = stop_page;
 330     ei_status.word16 = (wordlength == 2);
 331
 332     ei_status.rx_start_page = start_page + TX_PAGES;
 333
 334     ei_status.reset_8390 = &apne_reset_8390;
 335     ei_status.block_input = &apne_block_input;
 336     ei_status.block_output = &apne_block_output;
 337     ei_status.get_8390_hdr = &apne_get_8390_hdr;
 338     dev->open = &apne_open;
 339     dev->stop = &apne_close;
 340 #ifdef CONFIG_NET_POLL_CONTROLLER
 341     dev->poll_controller = ei_poll;
 342 #endif
 343     NS8390_init(dev, 0);
 344
 345     pcmcia_ack_int(pcmcia_get_intreq());                /* ack PCMCIA int req */
 346     pcmcia_enable_irq();
 347
 348     apne_owned = 1;
 349
 350     return 0;
 351 }
 352
 353 static int
 354 apne_open(struct net_device *dev)
 355 {
 356     ei_open(dev);
 357     return 0;
 358 }
 359
 360 static int
 361 apne_close(struct net_device *dev)
 362 {
 363     if (ei_debug > 1)
 364         printk("%s: Shutting down ethercard.\n", dev->name);
 365     ei_close(dev);
 366     return 0;
 367 }
 368
 369 /* Hard reset the card.  This used to pause for the same period that a
 370    8390 reset command required, but that shouldn't be necessary. */
 371 static void
 372 apne_reset_8390(struct net_device *dev)
 373 {
 374     unsigned long reset_start_time = jiffies;
 375
 376     init_pcmcia();
 377
 378     if (ei_debug > 1) printk("resetting the 8390 t=%ld...", jiffies);
 379
 380     outb(inb(NE_BASE + NE_RESET), NE_BASE + NE_RESET);
 381
 382     ei_status.txing = 0;
 383     ei_status.dmaing = 0;
 384
 385     /* This check _should_not_ be necessary, omit eventually. */
 386     while ((inb(NE_BASE+NE_EN0_ISR) & ENISR_RESET) == 0)
 387         if (time_after(jiffies, reset_start_time + 2*HZ/100)) {
 388             printk("%s: ne_reset_8390() did not complete.\n", dev->name);
 389             break;
 390         }
 391     outb(ENISR_RESET, NE_BASE + NE_EN0_ISR);    /* Ack intr. */
 392 }
 393
 394 /* Grab the 8390 specific header. Similar to the block_input routine, but
 395    we don't need to be concerned with ring wrap as the header will be at
 396    the start of a page, so we optimize accordingly. */
 397
 398 static void
 399 apne_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
 400 {
 401
 402     int nic_base = dev->base_addr;
 403     int cnt;
 404     char *ptrc;
 405     short *ptrs;
 406
 407     /* This *shouldn't* happen. If it does, it's the last thing you'll see */
 408     if (ei_status.dmaing) {
 409         printk("%s: DMAing conflict in ne_get_8390_hdr "
 410            "[DMAstat:%d][irqlock:%d][intr:%d].\n",
 411            dev->name, ei_status.dmaing, ei_status.irqlock, dev->irq);
 412         return;
 413     }
 414
 415     ei_status.dmaing |= 0x01;
 416     outb(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
 417     outb(ENISR_RDC, nic_base + NE_EN0_ISR);
 418     outb(sizeof(struct e8390_pkt_hdr), nic_base + NE_EN0_RCNTLO);
 419     outb(0, nic_base + NE_EN0_RCNTHI);
 420     outb(0, nic_base + NE_EN0_RSARLO);          /* On page boundary */
 421     outb(ring_page, nic_base + NE_EN0_RSARHI);
 422     outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
 423
 424     if (ei_status.word16) {
 425         ptrs = (short*)hdr;
 426         for(cnt = 0; cnt < (sizeof(struct e8390_pkt_hdr)>>1); cnt++)
 427             *ptrs++ = inw(NE_BASE + NE_DATAPORT);
 428     } else {
 429         ptrc = (char*)hdr;
 430         for(cnt = 0; cnt < sizeof(struct e8390_pkt_hdr); cnt++)
 431             *ptrc++ = inb(NE_BASE + NE_DATAPORT);
 432     }
 433
 434     outb(ENISR_RDC, nic_base + NE_EN0_ISR);     /* Ack intr. */
 435     ei_status.dmaing &= ~0x01;
 436
 437     le16_to_cpus(&hdr->count);
 438 }
 439
 440 /* Block input and output, similar to the Crynwr packet driver.  If you
 441    are porting to a new ethercard, look at the packet driver source for hints.
 442    The NEx000 doesn't share the on-board packet memory -- you have to put
 443    the packet out through the "remote DMA" dataport using outb. */
 444
 445 static void
 446 apne_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
 447 {
 448     int nic_base = dev->base_addr;
 449     char *buf = skb->data;
 450     char *ptrc;
 451     short *ptrs;
 452     int cnt;
 453
 454     /* This *shouldn't* happen. If it does, it's the last thing you'll see */
 455     if (ei_status.dmaing) {
 456         printk("%s: DMAing conflict in ne_block_input "
 457            "[DMAstat:%d][irqlock:%d][intr:%d].\n",
 458            dev->name, ei_status.dmaing, ei_status.irqlock, dev->irq);
 459         return;
 460     }
 461     ei_status.dmaing |= 0x01;
 462     outb(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
 463     outb(ENISR_RDC, nic_base + NE_EN0_ISR);
 464     outb(count & 0xff, nic_base + NE_EN0_RCNTLO);
 465     outb(count >> 8, nic_base + NE_EN0_RCNTHI);
 466     outb(ring_offset & 0xff, nic_base + NE_EN0_RSARLO);
 467     outb(ring_offset >> 8, nic_base + NE_EN0_RSARHI);
 468     outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
 469     if (ei_status.word16) {
 470       ptrs = (short*)buf;
 471       for (cnt = 0; cnt < (count>>1); cnt++)
 472         *ptrs++ = inw(NE_BASE + NE_DATAPORT);
 473       if (count & 0x01) {
 474         buf[count-1] = inb(NE_BASE + NE_DATAPORT);
 475       }
 476     } else {
 477       ptrc = (char*)buf;
 478       for (cnt = 0; cnt < count; cnt++)
 479         *ptrc++ = inb(NE_BASE + NE_DATAPORT);
 480     }
 481
 482     outb(ENISR_RDC, nic_base + NE_EN0_ISR);     /* Ack intr. */
 483     ei_status.dmaing &= ~0x01;
 484 }
 485
 486 static void
 487 apne_block_output(struct net_device *dev, int count,
 488                 const unsigned char *buf, const int start_page)
 489 {
 490     int nic_base = NE_BASE;
 491     unsigned long dma_start;
 492     char *ptrc;
 493     short *ptrs;
 494     int cnt;
 495
 496     /* Round the count up for word writes.  Do we need to do this?
 497        What effect will an odd byte count have on the 8390?
 498        I should check someday. */
 499     if (ei_status.word16 && (count & 0x01))
 500       count++;
 501
 502     /* This *shouldn't* happen. If it does, it's the last thing you'll see */
 503     if (ei_status.dmaing) {
 504         printk("%s: DMAing conflict in ne_block_output."
 505            "[DMAstat:%d][irqlock:%d][intr:%d]\n",
 506            dev->name, ei_status.dmaing, ei_status.irqlock, dev->irq);
 507         return;
 508     }
 509     ei_status.dmaing |= 0x01;
 510     /* We should already be in page 0, but to be safe... */
 511     outb(E8390_PAGE0+E8390_START+E8390_NODMA, nic_base + NE_CMD);
 512
 513     outb(ENISR_RDC, nic_base + NE_EN0_ISR);
 514
 515    /* Now the normal output. */
 516     outb(count & 0xff, nic_base + NE_EN0_RCNTLO);
 517     outb(count >> 8,   nic_base + NE_EN0_RCNTHI);
 518     outb(0x00, nic_base + NE_EN0_RSARLO);
 519     outb(start_page, nic_base + NE_EN0_RSARHI);
 520
 521     outb(E8390_RWRITE+E8390_START, nic_base + NE_CMD);
 522     if (ei_status.word16) {
 523         ptrs = (short*)buf;
 524         for (cnt = 0; cnt < count>>1; cnt++)
 525             outw(*ptrs++, NE_BASE+NE_DATAPORT);
 526     } else {
 527         ptrc = (char*)buf;
 528         for (cnt = 0; cnt < count; cnt++)
 529             outb(*ptrc++, NE_BASE + NE_DATAPORT);
 530     }
 531
 532     dma_start = jiffies;
 533
 534     while ((inb(NE_BASE + NE_EN0_ISR) & ENISR_RDC) == 0)
 535         if (time_after(jiffies, dma_start + 2*HZ/100)) {        /* 20ms */
 536                 printk("%s: timeout waiting for Tx RDC.\n", dev->name);
 537                 apne_reset_8390(dev);
 538                 NS8390_init(dev,1);
 539                 break;
 540         }
 541
 542     outb(ENISR_RDC, nic_base + NE_EN0_ISR);     /* Ack intr. */
 543     ei_status.dmaing &= ~0x01;
 544     return;
 545 }
 546
 547 static irqreturn_t apne_interrupt(int irq, void *dev_id)
 548 {
 549     unsigned char pcmcia_intreq;
 550
 551     if (!(gayle.inten & GAYLE_IRQ_IRQ))
 552         return IRQ_NONE;
 553
 554     pcmcia_intreq = pcmcia_get_intreq();
 555
 556     if (!(pcmcia_intreq & GAYLE_IRQ_IRQ)) {
 557         pcmcia_ack_int(pcmcia_intreq);
 558         return IRQ_NONE;
 559     }
 560     if (ei_debug > 3)
 561         printk("pcmcia intreq = %x\n", pcmcia_intreq);
 562     pcmcia_disable_irq();                       /* to get rid of the sti() within ei_interrupt */
 563     ei_interrupt(irq, dev_id);
 564     pcmcia_ack_int(pcmcia_get_intreq());
 565     pcmcia_enable_irq();
 566     return IRQ_HANDLED;
 567 }
 568
 569 #ifdef MODULE
 570 static struct net_device *apne_dev;
 571
 572 int __init init_module(void)
 573 {
 574         apne_dev = apne_probe(-1);
 575         if (IS_ERR(apne_dev))
 576                 return PTR_ERR(apne_dev);
 577         return 0;
 578 }
 579
 580 void __exit cleanup_module(void)
 581 {
 582         unregister_netdev(apne_dev);
 583
 584         pcmcia_disable_irq();
 585
 586         free_irq(IRQ_AMIGA_PORTS, apne_dev);
 587
 588         pcmcia_reset();
 589
 590         release_region(IOBASE, 0x20);
 591
 592         free_netdev(apne_dev);
 593 }
 594
 595 #endif
 596
 597 static int init_pcmcia(void)
 598 {
 599         u_char config;
 600 #ifndef MANUAL_CONFIG
 601         u_char tuple[32];
 602         int offset_len;
 603 #endif
 604         u_long offset;
 605
 606         pcmcia_reset();
 607         pcmcia_program_voltage(PCMCIA_0V);
 608         pcmcia_access_speed(PCMCIA_SPEED_250NS);
 609         pcmcia_write_enable();
 610
 611 #ifdef MANUAL_CONFIG
 612         config = MANUAL_CONFIG;
 613 #else
 614         /* get and write config byte to enable IO port */
 615
 616         if (pcmcia_copy_tuple(CISTPL_CFTABLE_ENTRY, tuple, 32) < 3)
 617                 return 0;
 618
 619         config = tuple[2] & 0x3f;
 620 #endif
 621 #ifdef MANUAL_OFFSET
 622         offset = MANUAL_OFFSET;
 623 #else
 624         if (pcmcia_copy_tuple(CISTPL_CONFIG, tuple, 32) < 6)
 625                 return 0;
 626
 627         offset_len = (tuple[2] & 0x3) + 1;
 628         offset = 0;
 629         while(offset_len--) {
 630                 offset = (offset << 8) | tuple[4+offset_len];
 631         }
 632 #endif
 633
 634         out_8(GAYLE_ATTRIBUTE+offset, config);
 635
 636         return 1;
 637 }
 638
 639 MODULE_LICENSE("GPL");