LXR linux/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
  78struct net_device * __init apne_probe(int unit);
  79static int apne_probe1(struct net_device *dev, int ioaddr);
  80
  81static void apne_reset_8390(struct net_device *dev);
  82static void apne_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
  83                          int ring_page);
  84static void apne_block_input(struct net_device *dev, int count,
  85                                                                struct sk_buff *skb, int ring_offset);
  86static void apne_block_output(struct net_device *dev, const int count,
  87                                                        const unsigned char *buf, const int start_page);
  88static irqreturn_t apne_interrupt(int irq, void *dev_id);
  89
  90static 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
 114static const char version[] =
 115    "apne.c:v1.1 7/10/98 Alain Malek (Alain.Malek@cryogen.ch)\n";
 116
 117static int apne_owned;  /* signal if card already owned */
 118
 119struct 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
 196static 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. */
 351static void
 352apne_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
 378static void
 379apne_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
 425static void
 426apne_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
 466static void
 467apne_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    return;
 525}
 526
 527static irqreturn_t apne_interrupt(int irq, void *dev_id)
 528{
 529    unsigned char pcmcia_intreq;
 530
 531    if (!(gayle.inten & GAYLE_IRQ_IRQ))
 532        return IRQ_NONE;
 533
 534    pcmcia_intreq = pcmcia_get_intreq();
 535
 536    if (!(pcmcia_intreq & GAYLE_IRQ_IRQ)) {
 537        pcmcia_ack_int(pcmcia_intreq);
 538        return IRQ_NONE;
 539    }
 540    if (ei_debug > 3)
 541        printk("pcmcia intreq = %x\n", pcmcia_intreq);
 542    pcmcia_disable_irq();                       /* to get rid of the sti() within ei_interrupt */
 543    ei_interrupt(irq, dev_id);
 544    pcmcia_ack_int(pcmcia_get_intreq());
 545    pcmcia_enable_irq();
 546    return IRQ_HANDLED;
 547}
 548
 549#ifdef MODULE
 550static struct net_device *apne_dev;
 551
 552static int __init apne_module_init(void)
 553{
 554        apne_dev = apne_probe(-1);
 555        if (IS_ERR(apne_dev))
 556                return PTR_ERR(apne_dev);
 557        return 0;
 558}
 559
 560static void __exit apne_module_exit(void)
 561{
 562        unregister_netdev(apne_dev);
 563
 564        pcmcia_disable_irq();
 565
 566        free_irq(IRQ_AMIGA_PORTS, apne_dev);
 567
 568        pcmcia_reset();
 569
 570        release_region(IOBASE, 0x20);
 571
 572        free_netdev(apne_dev);
 573}
 574module_init(apne_module_init);
 575module_exit(apne_module_exit);
 576#endif
 577
 578static int init_pcmcia(void)
 579{
 580        u_char config;
 581#ifndef MANUAL_CONFIG
 582        u_char tuple[32];
 583        int offset_len;
 584#endif
 585        u_long offset;
 586
 587        pcmcia_reset();
 588        pcmcia_program_voltage(PCMCIA_0V);
 589        pcmcia_access_speed(PCMCIA_SPEED_250NS);
 590        pcmcia_write_enable();
 591
 592#ifdef MANUAL_CONFIG
 593        config = MANUAL_CONFIG;
 594#else
 595        /* get and write config byte to enable IO port */
 596
 597        if (pcmcia_copy_tuple(CISTPL_CFTABLE_ENTRY, tuple, 32) < 3)
 598                return 0;
 599
 600        config = tuple[2] & 0x3f;
 601#endif
 602#ifdef MANUAL_OFFSET
 603        offset = MANUAL_OFFSET;
 604#else
 605        if (pcmcia_copy_tuple(CISTPL_CONFIG, tuple, 32) < 6)
 606                return 0;
 607
 608        offset_len = (tuple[2] & 0x3) + 1;
 609        offset = 0;
 610        while(offset_len--) {
 611                offset = (offset << 8) | tuple[4+offset_len];
 612        }
 613#endif
 614
 615        out_8(GAYLE_ATTRIBUTE+offset, config);
 616
 617        return 1;
 618}
 619
 620MODULE_LICENSE("GPL");
 621