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 void apne_reset_8390(struct net_device *dev);
  82 static void apne_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
  83                           int ring_page);
  84 static void apne_block_input(struct net_device *dev, int count,
  85                                                                 struct sk_buff *skb, int ring_offset);
  86 static void apne_block_output(struct net_device *dev, const int count,
  87                                                         const unsigned char *buf, const int start_page);
  88 static irqreturn_t apne_interrupt(int irq, void *dev_id);
  89
  90 static int init_pcmcia(void);
  91
  92 /* IO base address used for nic */
  93
  94 #define IOBASE 0x300
  95
  96 /*
  97    use MANUAL_CONFIG and MANUAL_OFFSET for enabling IO by hand
  98    you can find the values to use by looking at the cnet.device
  99    config file example (the default values are for the CNET40BC card)
 100 */
 101
 102 /*
 103 #define MANUAL_CONFIG 0x20
 104 #define MANUAL_OFFSET 0x3f8
 105
 106 #define MANUAL_HWADDR0 0x00
 107 #define MANUAL_HWADDR1 0x12
 108 #define MANUAL_HWADDR2 0x34
 109 #define MANUAL_HWADDR3 0x56
 110 #define MANUAL_HWADDR4 0x78
 111 #define MANUAL_HWADDR5 0x9a
 112 */
 113
 114 static const char version[] =
 115     "apne.c:v1.1 7/10/98 Alain Malek (Alain.Malek@cryogen.ch)\n";
 116
 117 static int apne_owned;  /* signal if card already owned */
 118
 119 struct net_device * __init apne_probe(int unit)
 120 {
 121         struct net_device *dev;
 122 #ifndef MANUAL_CONFIG
 123         char tuple[8];
 124 #endif
 125         int err;
 126
 127         if (!MACH_IS_AMIGA)
 128                 return ERR_PTR(-ENODEV);
 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
 152         /* disable pcmcia irq for readtuple */
 153         pcmcia_disable_irq();
 154
 155 #ifndef MANUAL_CONFIG
 156         if ((pcmcia_copy_tuple(CISTPL_FUNCID, tuple, 8) < 3) ||
 157                 (tuple[2] != CISTPL_FUNCID_NETWORK)) {
 158                 printk("not an ethernet card\n");
 159                 /* XXX: shouldn't we re-enable irq here? */
 160                 free_netdev(dev);
 161                 return ERR_PTR(-ENODEV);
 162         }
 163 #endif
 164
 165         printk("ethernet PCMCIA card inserted\n");
 166
 167         if (!init_pcmcia()) {
 168                 /* XXX: shouldn't we re-enable irq here? */
 169                 free_netdev(dev);
 170                 return ERR_PTR(-ENODEV);
 171         }
 172
 173         if (!request_region(IOBASE, 0x20, DRV_NAME)) {
 174                 free_netdev(dev);
 175                 return ERR_PTR(-EBUSY);
 176         }
 177
 178         err = apne_probe1(dev, IOBASE);
 179         if (err) {
 180                 release_region(IOBASE, 0x20);
 181                 free_netdev(dev);
 182                 return ERR_PTR(err);
 183         }
 184         err = register_netdev(dev);
 185         if (!err)
 186                 return dev;
 187
 188         pcmcia_disable_irq();
 189         free_irq(IRQ_AMIGA_PORTS, dev);
 190         pcmcia_reset();
 191         release_region(IOBASE, 0x20);
 192         free_netdev(dev);
 193         return ERR_PTR(err);
 194 }
 195
 196 static int __init apne_probe1(struct net_device *dev, int ioaddr)
 197 {
 198     int i;
 199     unsigned char SA_prom[32];
 200     int wordlength = 2;
 201     const char *name = NULL;
 202     int start_page, stop_page;
 203 #ifndef MANUAL_HWADDR0
 204     int neX000, ctron;
 205 #endif
 206     static unsigned version_printed;
 207
 208     if (ei_debug  &&  version_printed++ == 0)
 209         printk(version);
 210
 211     printk("PCMCIA NE*000 ethercard probe");
 212
 213     /* Reset card. Who knows what dain-bramaged state it was left in. */
 214     {   unsigned long reset_start_time = jiffies;
 215
 216         outb(inb(ioaddr + NE_RESET), ioaddr + NE_RESET);
 217
 218         while ((inb(ioaddr + NE_EN0_ISR) & ENISR_RESET) == 0)
 219                 if (time_after(jiffies, reset_start_time + 2*HZ/100)) {
 220                         printk(" not found (no reset ack).\n");
 221                         return -ENODEV;
 222                 }
 223
 224         outb(0xff, ioaddr + NE_EN0_ISR);                /* Ack all intr. */
 225     }
 226
 227 #ifndef MANUAL_HWADDR0
 228
 229     /* Read the 16 bytes of station address PROM.
 230        We must first initialize registers, similar to NS8390_init(eifdev, 0).
 231        We can't reliably read the SAPROM address without this.
 232        (I learned the hard way!). */
 233     {
 234         struct {unsigned long value, offset; } program_seq[] = {
 235             {E8390_NODMA+E8390_PAGE0+E8390_STOP, NE_CMD}, /* Select page 0*/
 236             {0x48,      NE_EN0_DCFG},   /* Set byte-wide (0x48) access. */
 237             {0x00,      NE_EN0_RCNTLO}, /* Clear the count regs. */
 238             {0x00,      NE_EN0_RCNTHI},
 239             {0x00,      NE_EN0_IMR},    /* Mask completion irq. */
 240             {0xFF,      NE_EN0_ISR},
 241             {E8390_RXOFF, NE_EN0_RXCR}, /* 0x20  Set to monitor */
 242             {E8390_TXOFF, NE_EN0_TXCR}, /* 0x02  and loopback mode. */
 243             {32,        NE_EN0_RCNTLO},
 244             {0x00,      NE_EN0_RCNTHI},
 245             {0x00,      NE_EN0_RSARLO}, /* DMA starting at 0x0000. */
 246             {0x00,      NE_EN0_RSARHI},
 247             {E8390_RREAD+E8390_START, NE_CMD},
 248         };
 249         for (i = 0; i < ARRAY_SIZE(program_seq); i++) {
 250             outb(program_seq[i].value, ioaddr + program_seq[i].offset);
 251         }
 252
 253     }
 254     for(i = 0; i < 32 /*sizeof(SA_prom)*/; i+=2) {
 255         SA_prom[i] = inb(ioaddr + NE_DATAPORT);
 256         SA_prom[i+1] = inb(ioaddr + NE_DATAPORT);
 257         if (SA_prom[i] != SA_prom[i+1])
 258             wordlength = 1;
 259     }
 260
 261     /*  At this point, wordlength *only* tells us if the SA_prom is doubled
 262         up or not because some broken PCI cards don't respect the byte-wide
 263         request in program_seq above, and hence don't have doubled up values.
 264         These broken cards would otherwise be detected as an ne1000.  */
 265
 266     if (wordlength == 2)
 267         for (i = 0; i < 16; i++)
 268                 SA_prom[i] = SA_prom[i+i];
 269
 270     if (wordlength == 2) {
 271         /* We must set the 8390 for word mode. */
 272         outb(0x49, ioaddr + NE_EN0_DCFG);
 273         start_page = NESM_START_PG;
 274         stop_page = NESM_STOP_PG;
 275     } else {
 276         start_page = NE1SM_START_PG;
 277         stop_page = NE1SM_STOP_PG;
 278     }
 279
 280     neX000 = (SA_prom[14] == 0x57  &&  SA_prom[15] == 0x57);
 281     ctron =  (SA_prom[0] == 0x00 && SA_prom[1] == 0x00 && SA_prom[2] == 0x1d);
 282
 283     /* Set up the rest of the parameters. */
 284     if (neX000) {
 285         name = (wordlength == 2) ? "NE2000" : "NE1000";
 286     } else if (ctron) {
 287         name = (wordlength == 2) ? "Ctron-8" : "Ctron-16";
 288         start_page = 0x01;
 289         stop_page = (wordlength == 2) ? 0x40 : 0x20;
 290     } else {
 291         printk(" not found.\n");
 292         return -ENXIO;
 293
 294     }
 295
 296 #else
 297     wordlength = 2;
 298     /* We must set the 8390 for word mode. */
 299     outb(0x49, ioaddr + NE_EN0_DCFG);
 300     start_page = NESM_START_PG;
 301     stop_page = NESM_STOP_PG;
 302
 303     SA_prom[0] = MANUAL_HWADDR0;
 304     SA_prom[1] = MANUAL_HWADDR1;
 305     SA_prom[2] = MANUAL_HWADDR2;
 306     SA_prom[3] = MANUAL_HWADDR3;
 307     SA_prom[4] = MANUAL_HWADDR4;
 308     SA_prom[5] = MANUAL_HWADDR5;
 309     name = "NE2000";
 310 #endif
 311
 312     dev->base_addr = ioaddr;
 313     dev->irq = IRQ_AMIGA_PORTS;
 314     dev->netdev_ops = &ei_netdev_ops;
 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         dev->dev_addr[i] = SA_prom[i];
 322
 323     printk(" %pM\n", dev->dev_addr);
 324
 325     printk("%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
 339     NS8390_init(dev, 0);
 340
 341     pcmcia_ack_int(pcmcia_get_intreq());                /* ack PCMCIA int req */
 342     pcmcia_enable_irq();
 343
 344     apne_owned = 1;
 345
 346     return 0;
 347 }
 348
 349 /* Hard reset the card.  This used to pause for the same period that a
 350    8390 reset command required, but that shouldn't be necessary. */
 351 static void
 352 apne_reset_8390(struct net_device *dev)
 353 {
 354     unsigned long reset_start_time = jiffies;
 355
 356     init_pcmcia();
 357
 358     if (ei_debug > 1) printk("resetting the 8390 t=%ld...", jiffies);
 359
 360     outb(inb(NE_BASE + NE_RESET), NE_BASE + NE_RESET);
 361
 362     ei_status.txing = 0;
 363     ei_status.dmaing = 0;
 364
 365     /* This check _should_not_ be necessary, omit eventually. */
 366     while ((inb(NE_BASE+NE_EN0_ISR) & ENISR_RESET) == 0)
 367         if (time_after(jiffies, reset_start_time + 2*HZ/100)) {
 368             printk("%s: ne_reset_8390() did not complete.\n", dev->name);
 369             break;
 370         }
 371     outb(ENISR_RESET, NE_BASE + NE_EN0_ISR);    /* Ack intr. */
 372 }
 373
 374 /* Grab the 8390 specific header. Similar to the block_input routine, but
 375    we don't need to be concerned with ring wrap as the header will be at
 376    the start of a page, so we optimize accordingly. */
 377
 378 static void
 379 apne_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
 380 {
 381
 382     int nic_base = dev->base_addr;
 383     int cnt;
 384     char *ptrc;
 385     short *ptrs;
 386
 387     /* This *shouldn't* happen. If it does, it's the last thing you'll see */
 388     if (ei_status.dmaing) {
 389         printk("%s: DMAing conflict in ne_get_8390_hdr "
 390            "[DMAstat:%d][irqlock:%d][intr:%d].\n",
 391            dev->name, ei_status.dmaing, ei_status.irqlock, dev->irq);
 392         return;
 393     }
 394
 395     ei_status.dmaing |= 0x01;
 396     outb(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
 397     outb(ENISR_RDC, nic_base + NE_EN0_ISR);
 398     outb(sizeof(struct e8390_pkt_hdr), nic_base + NE_EN0_RCNTLO);
 399     outb(0, nic_base + NE_EN0_RCNTHI);
 400     outb(0, nic_base + NE_EN0_RSARLO);          /* On page boundary */
 401     outb(ring_page, nic_base + NE_EN0_RSARHI);
 402     outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
 403
 404     if (ei_status.word16) {
 405         ptrs = (short*)hdr;
 406         for(cnt = 0; cnt < (sizeof(struct e8390_pkt_hdr)>>1); cnt++)
 407             *ptrs++ = inw(NE_BASE + NE_DATAPORT);
 408     } else {
 409         ptrc = (char*)hdr;
 410         for(cnt = 0; cnt < sizeof(struct e8390_pkt_hdr); cnt++)
 411             *ptrc++ = inb(NE_BASE + NE_DATAPORT);
 412     }
 413
 414     outb(ENISR_RDC, nic_base + NE_EN0_ISR);     /* Ack intr. */
 415     ei_status.dmaing &= ~0x01;
 416
 417     le16_to_cpus(&hdr->count);
 418 }
 419
 420 /* Block input and output, similar to the Crynwr packet driver.  If you
 421    are porting to a new ethercard, look at the packet driver source for hints.
 422    The NEx000 doesn't share the on-board packet memory -- you have to put
 423    the packet out through the "remote DMA" dataport using outb. */
 424
 425 static void
 426 apne_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
 427 {
 428     int nic_base = dev->base_addr;
 429     char *buf = skb->data;
 430     char *ptrc;
 431     short *ptrs;
 432     int cnt;
 433
 434     /* This *shouldn't* happen. If it does, it's the last thing you'll see */
 435     if (ei_status.dmaing) {
 436         printk("%s: DMAing conflict in ne_block_input "
 437            "[DMAstat:%d][irqlock:%d][intr:%d].\n",
 438            dev->name, ei_status.dmaing, ei_status.irqlock, dev->irq);
 439         return;
 440     }
 441     ei_status.dmaing |= 0x01;
 442     outb(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
 443     outb(ENISR_RDC, nic_base + NE_EN0_ISR);
 444     outb(count & 0xff, nic_base + NE_EN0_RCNTLO);
 445     outb(count >> 8, nic_base + NE_EN0_RCNTHI);
 446     outb(ring_offset & 0xff, nic_base + NE_EN0_RSARLO);
 447     outb(ring_offset >> 8, nic_base + NE_EN0_RSARHI);
 448     outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
 449     if (ei_status.word16) {
 450       ptrs = (short*)buf;
 451       for (cnt = 0; cnt < (count>>1); cnt++)
 452         *ptrs++ = inw(NE_BASE + NE_DATAPORT);
 453       if (count & 0x01) {
 454         buf[count-1] = inb(NE_BASE + NE_DATAPORT);
 455       }
 456     } else {
 457       ptrc = (char*)buf;
 458       for (cnt = 0; cnt < count; cnt++)
 459         *ptrc++ = inb(NE_BASE + NE_DATAPORT);
 460     }
 461
 462     outb(ENISR_RDC, nic_base + NE_EN0_ISR);     /* Ack intr. */
 463     ei_status.dmaing &= ~0x01;
 464 }
 465
 466 static void
 467 apne_block_output(struct net_device *dev, int count,
 468                 const unsigned char *buf, const int start_page)
 469 {
 470     int nic_base = NE_BASE;
 471     unsigned long dma_start;
 472     char *ptrc;
 473     short *ptrs;
 474     int cnt;
 475
 476     /* Round the count up for word writes.  Do we need to do this?
 477        What effect will an odd byte count have on the 8390?
 478        I should check someday. */
 479     if (ei_status.word16 && (count & 0x01))
 480       count++;
 481
 482     /* This *shouldn't* happen. If it does, it's the last thing you'll see */
 483     if (ei_status.dmaing) {
 484         printk("%s: DMAing conflict in ne_block_output."
 485            "[DMAstat:%d][irqlock:%d][intr:%d]\n",
 486            dev->name, ei_status.dmaing, ei_status.irqlock, dev->irq);
 487         return;
 488     }
 489     ei_status.dmaing |= 0x01;
 490     /* We should already be in page 0, but to be safe... */
 491     outb(E8390_PAGE0+E8390_START+E8390_NODMA, nic_base + NE_CMD);
 492
 493     outb(ENISR_RDC, nic_base + NE_EN0_ISR);
 494
 495    /* Now the normal output. */
 496     outb(count & 0xff, nic_base + NE_EN0_RCNTLO);
 497     outb(count >> 8,   nic_base + NE_EN0_RCNTHI);
 498     outb(0x00, nic_base + NE_EN0_RSARLO);
 499     outb(start_page, nic_base + NE_EN0_RSARHI);
 500
 501     outb(E8390_RWRITE+E8390_START, nic_base + NE_CMD);
 502     if (ei_status.word16) {
 503         ptrs = (short*)buf;
 504         for (cnt = 0; cnt < count>>1; cnt++)
 505             outw(*ptrs++, NE_BASE+NE_DATAPORT);
 506     } else {
 507         ptrc = (char*)buf;
 508         for (cnt = 0; cnt < count; cnt++)
 509             outb(*ptrc++, NE_BASE + NE_DATAPORT);
 510     }
 511
 512     dma_start = jiffies;
 513
 514     while ((inb(NE_BASE + NE_EN0_ISR) & ENISR_RDC) == 0)
 515         if (time_after(jiffies, dma_start + 2*HZ/100)) {        /* 20ms */
 516                 printk("%s: timeout waiting for Tx RDC.\n", dev->name);
 517                 apne_reset_8390(dev);
 518                 NS8390_init(dev,1);
 519                 break;
 520         }
 521
 522     outb(ENISR_RDC, nic_base + NE_EN0_ISR);     /* Ack intr. */
 523     ei_status.dmaing &= ~0x01;
 524 }
 525
 526 static irqreturn_t apne_interrupt(int irq, void *dev_id)
 527 {
 528     unsigned char pcmcia_intreq;
 529
 530     if (!(gayle.inten & GAYLE_IRQ_IRQ))
 531         return IRQ_NONE;
 532
 533     pcmcia_intreq = pcmcia_get_intreq();
 534
 535     if (!(pcmcia_intreq & GAYLE_IRQ_IRQ)) {
 536         pcmcia_ack_int(pcmcia_intreq);
 537         return IRQ_NONE;
 538     }
 539     if (ei_debug > 3)
 540         printk("pcmcia intreq = %x\n", pcmcia_intreq);
 541     pcmcia_disable_irq();                       /* to get rid of the sti() within ei_interrupt */
 542     ei_interrupt(irq, dev_id);
 543     pcmcia_ack_int(pcmcia_get_intreq());
 544     pcmcia_enable_irq();
 545     return IRQ_HANDLED;
 546 }
 547
 548 #ifdef MODULE
 549 static struct net_device *apne_dev;
 550
 551 static int __init apne_module_init(void)
 552 {
 553         apne_dev = apne_probe(-1);
 554         if (IS_ERR(apne_dev))
 555                 return PTR_ERR(apne_dev);
 556         return 0;
 557 }
 558
 559 static void __exit apne_module_exit(void)
 560 {
 561         unregister_netdev(apne_dev);
 562
 563         pcmcia_disable_irq();
 564
 565         free_irq(IRQ_AMIGA_PORTS, apne_dev);
 566
 567         pcmcia_reset();
 568
 569         release_region(IOBASE, 0x20);
 570
 571         free_netdev(apne_dev);
 572 }
 573 module_init(apne_module_init);
 574 module_exit(apne_module_exit);
 575 #endif
 576
 577 static int init_pcmcia(void)
 578 {
 579         u_char config;
 580 #ifndef MANUAL_CONFIG
 581         u_char tuple[32];
 582         int offset_len;
 583 #endif
 584         u_long offset;
 585
 586         pcmcia_reset();
 587         pcmcia_program_voltage(PCMCIA_0V);
 588         pcmcia_access_speed(PCMCIA_SPEED_250NS);
 589         pcmcia_write_enable();
 590
 591 #ifdef MANUAL_CONFIG
 592         config = MANUAL_CONFIG;
 593 #else
 594         /* get and write config byte to enable IO port */
 595
 596         if (pcmcia_copy_tuple(CISTPL_CFTABLE_ENTRY, tuple, 32) < 3)
 597                 return 0;
 598
 599         config = tuple[2] & 0x3f;
 600 #endif
 601 #ifdef MANUAL_OFFSET
 602         offset = MANUAL_OFFSET;
 603 #else
 604         if (pcmcia_copy_tuple(CISTPL_CONFIG, tuple, 32) < 6)
 605                 return 0;
 606
 607         offset_len = (tuple[2] & 0x3) + 1;
 608         offset = 0;
 609         while(offset_len--) {
 610                 offset = (offset << 8) | tuple[4+offset_len];
 611         }
 612 #endif
 613
 614         out_8(GAYLE_ATTRIBUTE+offset, config);
 615
 616         return 1;
 617 }
 618
 619 MODULE_LICENSE("GPL");