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