SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/net/at1700.c

   1 /* at1700.c: A network device driver for  the Allied Telesis AT1700.
   2
   3         Written 1993-98 by Donald Becker.
   4
   5         Copyright 1993 United States Government as represented by the
   6         Director, National Security Agency.
   7
   8         This software may be used and distributed according to the terms
   9         of the GNU General Public License, incorporated herein by reference.
  10
  11         The author may be reached as becker@scyld.com, or C/O
  12         Scyld Computing Corporation
  13         410 Severn Ave., Suite 210
  14         Annapolis MD 21403
  15
  16         This is a device driver for the Allied Telesis AT1700, and
  17         Fujitsu FMV-181/182/181A/182A/183/184/183A/184A, which are
  18         straight-forward Fujitsu MB86965 implementations.
  19
  20         Modification for Fujitsu FMV-18X cards is done by Yutaka Tamiya
  21         (tamy@flab.fujitsu.co.jp).
  22
  23   Sources:
  24     The Fujitsu MB86965 datasheet.
  25
  26         After the initial version of this driver was written Gerry Sawkins of
  27         ATI provided their EEPROM configuration code header file.
  28     Thanks to NIIBE Yutaka <gniibe@mri.co.jp> for bug fixes.
  29
  30     MCA bus (AT1720) support by Rene Schmit <rene@bss.lu>
  31
  32   Bugs:
  33         The MB86965 has a design flaw that makes all probes unreliable.  Not
  34         only is it difficult to detect, it also moves around in I/O space in
  35         response to inb()s from other device probes!
  36 */
  37
  38 #include <linux/errno.h>
  39 #include <linux/netdevice.h>
  40 #include <linux/etherdevice.h>
  41 #include <linux/mca-legacy.h>
  42 #include <linux/module.h>
  43 #include <linux/kernel.h>
  44 #include <linux/types.h>
  45 #include <linux/fcntl.h>
  46 #include <linux/interrupt.h>
  47 #include <linux/ioport.h>
  48 #include <linux/in.h>
  49 #include <linux/skbuff.h>
  50 #include <linux/slab.h>
  51 #include <linux/string.h>
  52 #include <linux/init.h>
  53 #include <linux/crc32.h>
  54 #include <linux/bitops.h>
  55
  56 #include <asm/system.h>
  57 #include <asm/io.h>
  58 #include <asm/dma.h>
  59
  60 static char version[] __initdata =
  61         "at1700.c:v1.16 9/11/06  Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";
  62
  63 #define DRV_NAME "at1700"
  64
  65 /* Tunable parameters. */
  66
  67 /* When to switch from the 64-entry multicast filter to Rx-all-multicast. */
  68 #define MC_FILTERBREAK 64
  69
  70 /* These unusual address orders are used to verify the CONFIG register. */
  71
  72 static int fmv18x_probe_list[] __initdata = {
  73         0x220, 0x240, 0x260, 0x280, 0x2a0, 0x2c0, 0x300, 0x340, 0
  74 };
  75
  76 /*
  77  *      ISA
  78  */
  79
  80 static unsigned at1700_probe_list[] __initdata = {
  81         0x260, 0x280, 0x2a0, 0x240, 0x340, 0x320, 0x380, 0x300, 0
  82 };
  83
  84 /*
  85  *      MCA
  86  */
  87 #ifdef CONFIG_MCA_LEGACY
  88 static int at1700_ioaddr_pattern[] __initdata = {
  89         0x00, 0x04, 0x01, 0x05, 0x02, 0x06, 0x03, 0x07
  90 };
  91
  92 static int at1700_mca_probe_list[] __initdata = {
  93         0x400, 0x1400, 0x2400, 0x3400, 0x4400, 0x5400, 0x6400, 0x7400, 0
  94 };
  95
  96 static int at1700_irq_pattern[] __initdata = {
  97         0x00, 0x00, 0x00, 0x30, 0x70, 0xb0, 0x00, 0x00,
  98         0x00, 0xf0, 0x34, 0x74, 0xb4, 0x00, 0x00, 0xf4, 0x00
  99 };
 100 #endif
 101
 102 /* use 0 for production, 1 for verification, >2 for debug */
 103 #ifndef NET_DEBUG
 104 #define NET_DEBUG 1
 105 #endif
 106 static unsigned int net_debug = NET_DEBUG;
 107
 108 typedef unsigned char uchar;
 109
 110 /* Information that need to be kept for each board. */
 111 struct net_local {
 112         spinlock_t lock;
 113         unsigned char mc_filter[8];
 114         uint jumpered:1;                        /* Set iff the board has jumper config. */
 115         uint tx_started:1;                      /* Packets are on the Tx queue. */
 116         uint tx_queue_ready:1;                  /* Tx queue is ready to be sent. */
 117         uint rx_started:1;                      /* Packets are Rxing. */
 118         uchar tx_queue;                         /* Number of packet on the Tx queue. */
 119         char mca_slot;                          /* -1 means ISA */
 120         ushort tx_queue_len;                    /* Current length of the Tx queue. */
 121 };
 122
 123
 124 /* Offsets from the base address. */
 125 #define STATUS                  0
 126 #define TX_STATUS               0
 127 #define RX_STATUS               1
 128 #define TX_INTR                 2               /* Bit-mapped interrupt enable registers. */
 129 #define RX_INTR                 3
 130 #define TX_MODE                 4
 131 #define RX_MODE                 5
 132 #define CONFIG_0                6               /* Misc. configuration settings. */
 133 #define CONFIG_1                7
 134 /* Run-time register bank 2 definitions. */
 135 #define DATAPORT                8               /* Word-wide DMA or programmed-I/O dataport. */
 136 #define TX_START                10
 137 #define COL16CNTL               11              /* Controll Reg for 16 collisions */
 138 #define MODE13                  13
 139 #define RX_CTRL                 14
 140 /* Configuration registers only on the '865A/B chips. */
 141 #define EEPROM_Ctrl     16
 142 #define EEPROM_Data     17
 143 #define CARDSTATUS      16                      /* FMV-18x Card Status */
 144 #define CARDSTATUS1     17                      /* FMV-18x Card Status */
 145 #define IOCONFIG                18              /* Either read the jumper, or move the I/O. */
 146 #define IOCONFIG1               19
 147 #define SAPROM                  20              /* The station address PROM, if no EEPROM. */
 148 #define MODE24                  24
 149 #define RESET                   31              /* Write to reset some parts of the chip. */
 150 #define AT1700_IO_EXTENT        32
 151 #define PORT_OFFSET(o) (o)
 152
 153
 154 #define TX_TIMEOUT              10
 155
 156
 157 /* Index to functions, as function prototypes. */
 158
 159 static int at1700_probe1(struct net_device *dev, int ioaddr);
 160 static int read_eeprom(long ioaddr, int location);
 161 static int net_open(struct net_device *dev);
 162 static netdev_tx_t net_send_packet(struct sk_buff *skb,
 163                                    struct net_device *dev);
 164 static irqreturn_t net_interrupt(int irq, void *dev_id);
 165 static void net_rx(struct net_device *dev);
 166 static int net_close(struct net_device *dev);
 167 static void set_rx_mode(struct net_device *dev);
 168 static void net_tx_timeout (struct net_device *dev);
 169
 170
 171 #ifdef CONFIG_MCA_LEGACY
 172 struct at1720_mca_adapters_struct {
 173         char* name;
 174         int id;
 175 };
 176 /* rEnE : maybe there are others I don't know off... */
 177
 178 static struct at1720_mca_adapters_struct at1720_mca_adapters[] __initdata = {
 179         { "Allied Telesys AT1720AT",    0x6410 },
 180         { "Allied Telesys AT1720BT",    0x6413 },
 181         { "Allied Telesys AT1720T",     0x6416 },
 182         { NULL, 0 },
 183 };
 184 #endif
 185
 186 /* Check for a network adaptor of this type, and return '0' iff one exists.
 187    If dev->base_addr == 0, probe all likely locations.
 188    If dev->base_addr == 1, always return failure.
 189    If dev->base_addr == 2, allocate space for the device and return success
 190    (detachable devices only).
 191    */
 192
 193 static int io = 0x260;
 194
 195 static int irq;
 196
 197 static void cleanup_card(struct net_device *dev)
 198 {
 199 #ifdef CONFIG_MCA_LEGACY
 200         struct net_local *lp = netdev_priv(dev);
 201         if (lp->mca_slot >= 0)
 202                 mca_mark_as_unused(lp->mca_slot);
 203 #endif
 204         free_irq(dev->irq, NULL);
 205         release_region(dev->base_addr, AT1700_IO_EXTENT);
 206 }
 207
 208 struct net_device * __init at1700_probe(int unit)
 209 {
 210         struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
 211         unsigned *port;
 212         int err = 0;
 213
 214         if (!dev)
 215                 return ERR_PTR(-ENODEV);
 216
 217         if (unit >= 0) {
 218                 sprintf(dev->name, "eth%d", unit);
 219                 netdev_boot_setup_check(dev);
 220                 io = dev->base_addr;
 221                 irq = dev->irq;
 222         } else {
 223                 dev->base_addr = io;
 224                 dev->irq = irq;
 225         }
 226
 227         if (io > 0x1ff) {       /* Check a single specified location. */
 228                 err = at1700_probe1(dev, io);
 229         } else if (io != 0) {   /* Don't probe at all. */
 230                 err = -ENXIO;
 231         } else {
 232                 for (port = at1700_probe_list; *port; port++) {
 233                         if (at1700_probe1(dev, *port) == 0)
 234                                 break;
 235                         dev->irq = irq;
 236                 }
 237                 if (!*port)
 238                         err = -ENODEV;
 239         }
 240         if (err)
 241                 goto out;
 242         err = register_netdev(dev);
 243         if (err)
 244                 goto out1;
 245         return dev;
 246 out1:
 247         cleanup_card(dev);
 248 out:
 249         free_netdev(dev);
 250         return ERR_PTR(err);
 251 }
 252
 253 static const struct net_device_ops at1700_netdev_ops = {
 254         .ndo_open               = net_open,
 255         .ndo_stop               = net_close,
 256         .ndo_start_xmit         = net_send_packet,
 257         .ndo_set_multicast_list = set_rx_mode,
 258         .ndo_tx_timeout         = net_tx_timeout,
 259         .ndo_change_mtu         = eth_change_mtu,
 260         .ndo_set_mac_address    = eth_mac_addr,
 261         .ndo_validate_addr      = eth_validate_addr,
 262 };
 263
 264 /* The Fujitsu datasheet suggests that the NIC be probed for by checking its
 265    "signature", the default bit pattern after a reset.  This *doesn't* work --
 266    there is no way to reset the bus interface without a complete power-cycle!
 267
 268    It turns out that ATI came to the same conclusion I did: the only thing
 269    that can be done is checking a few bits and then diving right into an
 270    EEPROM read. */
 271
 272 static int __init at1700_probe1(struct net_device *dev, int ioaddr)
 273 {
 274         char fmv_irqmap[4] = {3, 7, 10, 15};
 275         char fmv_irqmap_pnp[8] = {3, 4, 5, 7, 9, 10, 11, 15};
 276         char at1700_irqmap[8] = {3, 4, 5, 9, 10, 11, 14, 15};
 277         unsigned int i, irq, is_fmv18x = 0, is_at1700 = 0;
 278         int slot, ret = -ENODEV;
 279         struct net_local *lp = netdev_priv(dev);
 280
 281         if (!request_region(ioaddr, AT1700_IO_EXTENT, DRV_NAME))
 282                 return -EBUSY;
 283
 284         /* Resetting the chip doesn't reset the ISA interface, so don't bother.
 285            That means we have to be careful with the register values we probe
 286            for.
 287          */
 288 #ifdef notdef
 289         printk("at1700 probe at %#x, eeprom is %4.4x %4.4x %4.4x ctrl %4.4x.\n",
 290                    ioaddr, read_eeprom(ioaddr, 4), read_eeprom(ioaddr, 5),
 291                    read_eeprom(ioaddr, 6), inw(ioaddr + EEPROM_Ctrl));
 292 #endif
 293
 294 #ifdef CONFIG_MCA_LEGACY
 295         /* rEnE (rene@bss.lu): got this from 3c509 driver source , adapted for AT1720 */
 296
 297     /* Based on Erik Nygren's (nygren@mit.edu) 3c529 patch, heavily
 298         modified by Chris Beauregard (cpbeaure@csclub.uwaterloo.ca)
 299         to support standard MCA probing. */
 300
 301         /* redone for multi-card detection by ZP Gu (zpg@castle.net) */
 302         /* now works as a module */
 303
 304         if (MCA_bus) {
 305                 int j;
 306                 int l_i;
 307                 u_char pos3, pos4;
 308
 309                 for (j = 0; at1720_mca_adapters[j].name != NULL; j ++) {
 310                         slot = 0;
 311                         while (slot != MCA_NOTFOUND) {
 312
 313                                 slot = mca_find_unused_adapter( at1720_mca_adapters[j].id, slot );
 314                                 if (slot == MCA_NOTFOUND) break;
 315
 316                                 /* if we get this far, an adapter has been detected and is
 317                                 enabled */
 318
 319                                 pos3 = mca_read_stored_pos( slot, 3 );
 320                                 pos4 = mca_read_stored_pos( slot, 4 );
 321
 322                                 for (l_i = 0; l_i < 8; l_i++)
 323                                         if (( pos3 & 0x07) == at1700_ioaddr_pattern[l_i])
 324                                                 break;
 325                                 ioaddr = at1700_mca_probe_list[l_i];
 326
 327                                 for (irq = 0; irq < 0x10; irq++)
 328                                         if (((((pos4>>4) & 0x0f) | (pos3 & 0xf0)) & 0xff) == at1700_irq_pattern[irq])
 329                                                 break;
 330
 331                                         /* probing for a card at a particular IO/IRQ */
 332                                 if ((dev->irq && dev->irq != irq) ||
 333                                     (dev->base_addr && dev->base_addr != ioaddr)) {
 334                                         slot++;         /* probing next slot */
 335                                         continue;
 336                                 }
 337
 338                                 dev->irq = irq;
 339
 340                                 /* claim the slot */
 341                                 mca_set_adapter_name( slot, at1720_mca_adapters[j].name );
 342                                 mca_mark_as_used(slot);
 343
 344                                 goto found;
 345                         }
 346                 }
 347                 /* if we get here, we didn't find an MCA adapter - try ISA */
 348         }
 349 #endif
 350         slot = -1;
 351         /* We must check for the EEPROM-config boards first, else accessing
 352            IOCONFIG0 will move the board! */
 353         if (at1700_probe_list[inb(ioaddr + IOCONFIG1) & 0x07] == ioaddr &&
 354             read_eeprom(ioaddr, 4) == 0x0000 &&
 355             (read_eeprom(ioaddr, 5) & 0xff00) == 0xF400)
 356                 is_at1700 = 1;
 357         else if (inb(ioaddr + SAPROM    ) == 0x00 &&
 358                  inb(ioaddr + SAPROM + 1) == 0x00 &&
 359                  inb(ioaddr + SAPROM + 2) == 0x0e)
 360                 is_fmv18x = 1;
 361         else {
 362                 goto err_out;
 363         }
 364
 365 #ifdef CONFIG_MCA_LEGACY
 366 found:
 367 #endif
 368
 369                 /* Reset the internal state machines. */
 370         outb(0, ioaddr + RESET);
 371
 372         if (is_at1700) {
 373                 irq = at1700_irqmap[(read_eeprom(ioaddr, 12)&0x04)
 374                                                    | (read_eeprom(ioaddr, 0)>>14)];
 375         } else {
 376                 /* Check PnP mode for FMV-183/184/183A/184A. */
 377                 /* This PnP routine is very poor. IO and IRQ should be known. */
 378                 if (inb(ioaddr + CARDSTATUS1) & 0x20) {
 379                         irq = dev->irq;
 380                         for (i = 0; i < 8; i++) {
 381                                 if (irq == fmv_irqmap_pnp[i])
 382                                         break;
 383                         }
 384                         if (i == 8) {
 385                                 goto err_mca;
 386                         }
 387                 } else {
 388                         if (fmv18x_probe_list[inb(ioaddr + IOCONFIG) & 0x07] != ioaddr)
 389                                 goto err_mca;
 390                         irq = fmv_irqmap[(inb(ioaddr + IOCONFIG)>>6) & 0x03];
 391                 }
 392         }
 393
 394         printk("%s: %s found at %#3x, IRQ %d, address ", dev->name,
 395                    is_at1700 ? "AT1700" : "FMV-18X", ioaddr, irq);
 396
 397         dev->base_addr = ioaddr;
 398         dev->irq = irq;
 399
 400         if (is_at1700) {
 401                 for(i = 0; i < 3; i++) {
 402                         unsigned short eeprom_val = read_eeprom(ioaddr, 4+i);
 403                         ((unsigned short *)dev->dev_addr)[i] = ntohs(eeprom_val);
 404                 }
 405         } else {
 406                 for(i = 0; i < 6; i++) {
 407                         unsigned char val = inb(ioaddr + SAPROM + i);
 408                         dev->dev_addr[i] = val;
 409                 }
 410         }
 411         printk("%pM", dev->dev_addr);
 412
 413         /* The EEPROM word 12 bit 0x0400 means use regular 100 ohm 10baseT signals,
 414            rather than 150 ohm shielded twisted pair compensation.
 415            0x0000 == auto-sense the interface
 416            0x0800 == use TP interface
 417            0x1800 == use coax interface
 418            */
 419         {
 420                 const char *porttype[] = {"auto-sense", "10baseT", "auto-sense", "10base2"};
 421                 if (is_at1700) {
 422                         ushort setup_value = read_eeprom(ioaddr, 12);
 423                         dev->if_port = setup_value >> 8;
 424                 } else {
 425                         ushort setup_value = inb(ioaddr + CARDSTATUS);
 426                         switch (setup_value & 0x07) {
 427                         case 0x01: /* 10base5 */
 428                         case 0x02: /* 10base2 */
 429                                 dev->if_port = 0x18; break;
 430                         case 0x04: /* 10baseT */
 431                                 dev->if_port = 0x08; break;
 432                         default:   /* auto-sense */
 433                                 dev->if_port = 0x00; break;
 434                         }
 435                 }
 436                 printk(" %s interface.\n", porttype[(dev->if_port>>3) & 3]);
 437         }
 438
 439         /* Set the configuration register 0 to 32K 100ns. byte-wide memory, 16 bit
 440            bus access, two 4K Tx queues, and disabled Tx and Rx. */
 441         outb(0xda, ioaddr + CONFIG_0);
 442
 443         /* Set the station address in bank zero. */
 444         outb(0x00, ioaddr + CONFIG_1);
 445         for (i = 0; i < 6; i++)
 446                 outb(dev->dev_addr[i], ioaddr + PORT_OFFSET(8 + i));
 447
 448         /* Switch to bank 1 and set the multicast table to accept none. */
 449         outb(0x04, ioaddr + CONFIG_1);
 450         for (i = 0; i < 8; i++)
 451                 outb(0x00, ioaddr + PORT_OFFSET(8 + i));
 452
 453
 454         /* Switch to bank 2 */
 455         /* Lock our I/O address, and set manual processing mode for 16 collisions. */
 456         outb(0x08, ioaddr + CONFIG_1);
 457         outb(dev->if_port, ioaddr + MODE13);
 458         outb(0x00, ioaddr + COL16CNTL);
 459
 460         if (net_debug)
 461                 printk(version);
 462
 463         dev->netdev_ops = &at1700_netdev_ops;
 464         dev->watchdog_timeo = TX_TIMEOUT;
 465
 466         spin_lock_init(&lp->lock);
 467
 468         lp->jumpered = is_fmv18x;
 469         lp->mca_slot = slot;
 470         /* Snarf the interrupt vector now. */
 471         ret = request_irq(irq, net_interrupt, 0, DRV_NAME, dev);
 472         if (ret) {
 473                 printk(KERN_ERR "AT1700 at %#3x is unusable due to a "
 474                        "conflict on IRQ %d.\n",
 475                        ioaddr, irq);
 476                 goto err_mca;
 477         }
 478
 479         return 0;
 480
 481 err_mca:
 482 #ifdef CONFIG_MCA_LEGACY
 483         if (slot >= 0)
 484                 mca_mark_as_unused(slot);
 485 #endif
 486 err_out:
 487         release_region(ioaddr, AT1700_IO_EXTENT);
 488         return ret;
 489 }
 490
 491
 492 /*  EEPROM_Ctrl bits. */
 493 #define EE_SHIFT_CLK    0x40    /* EEPROM shift clock, in reg. 16. */
 494 #define EE_CS                   0x20    /* EEPROM chip select, in reg. 16. */
 495 #define EE_DATA_WRITE   0x80    /* EEPROM chip data in, in reg. 17. */
 496 #define EE_DATA_READ    0x80    /* EEPROM chip data out, in reg. 17. */
 497
 498 /* The EEPROM commands include the alway-set leading bit. */
 499 #define EE_WRITE_CMD    (5 << 6)
 500 #define EE_READ_CMD             (6 << 6)
 501 #define EE_ERASE_CMD    (7 << 6)
 502
 503 static int __init read_eeprom(long ioaddr, int location)
 504 {
 505         int i;
 506         unsigned short retval = 0;
 507         long ee_addr = ioaddr + EEPROM_Ctrl;
 508         long ee_daddr = ioaddr + EEPROM_Data;
 509         int read_cmd = location | EE_READ_CMD;
 510
 511         /* Shift the read command bits out. */
 512         for (i = 9; i >= 0; i--) {
 513                 short dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
 514                 outb(EE_CS, ee_addr);
 515                 outb(dataval, ee_daddr);
 516                 outb(EE_CS | EE_SHIFT_CLK, ee_addr);    /* EEPROM clock tick. */
 517         }
 518         outb(EE_DATA_WRITE, ee_daddr);
 519         for (i = 16; i > 0; i--) {
 520                 outb(EE_CS, ee_addr);
 521                 outb(EE_CS | EE_SHIFT_CLK, ee_addr);
 522                 retval = (retval << 1) | ((inb(ee_daddr) & EE_DATA_READ) ? 1 : 0);
 523         }
 524
 525         /* Terminate the EEPROM access. */
 526         outb(EE_CS, ee_addr);
 527         outb(EE_SHIFT_CLK, ee_addr);
 528         outb(0, ee_addr);
 529         return retval;
 530 }
 531
 532
 533
 534 static int net_open(struct net_device *dev)
 535 {
 536         struct net_local *lp = netdev_priv(dev);
 537         int ioaddr = dev->base_addr;
 538
 539         /* Set the configuration register 0 to 32K 100ns. byte-wide memory, 16 bit
 540            bus access, and two 4K Tx queues. */
 541         outb(0x5a, ioaddr + CONFIG_0);
 542
 543         /* Powerup, switch to register bank 2, and enable the Rx and Tx. */
 544         outb(0xe8, ioaddr + CONFIG_1);
 545
 546         lp->tx_started = 0;
 547         lp->tx_queue_ready = 1;
 548         lp->rx_started = 0;
 549         lp->tx_queue = 0;
 550         lp->tx_queue_len = 0;
 551
 552         /* Turn on hardware Tx and Rx interrupts. */
 553         outb(0x82, ioaddr + TX_INTR);
 554         outb(0x81, ioaddr + RX_INTR);
 555
 556         /* Enable the IRQ on boards of fmv18x it is feasible. */
 557         if (lp->jumpered) {
 558                 outb(0x80, ioaddr + IOCONFIG1);
 559         }
 560
 561         netif_start_queue(dev);
 562         return 0;
 563 }
 564
 565 static void net_tx_timeout (struct net_device *dev)
 566 {
 567         struct net_local *lp = netdev_priv(dev);
 568         int ioaddr = dev->base_addr;
 569
 570         printk ("%s: transmit timed out with status %04x, %s?\n", dev->name,
 571                 inw (ioaddr + STATUS), inb (ioaddr + TX_STATUS) & 0x80
 572                 ? "IRQ conflict" : "network cable problem");
 573         printk ("%s: timeout registers: %04x %04x %04x %04x %04x %04x %04x %04x.\n",
 574          dev->name, inw(ioaddr + TX_STATUS), inw(ioaddr + TX_INTR), inw(ioaddr + TX_MODE),
 575                 inw(ioaddr + CONFIG_0), inw(ioaddr + DATAPORT), inw(ioaddr + TX_START),
 576                 inw(ioaddr + MODE13 - 1), inw(ioaddr + RX_CTRL));
 577         dev->stats.tx_errors++;
 578         /* ToDo: We should try to restart the adaptor... */
 579         outw(0xffff, ioaddr + MODE24);
 580         outw (0xffff, ioaddr + TX_STATUS);
 581         outb (0x5a, ioaddr + CONFIG_0);
 582         outb (0xe8, ioaddr + CONFIG_1);
 583         outw (0x8182, ioaddr + TX_INTR);
 584         outb (0x00, ioaddr + TX_START);
 585         outb (0x03, ioaddr + COL16CNTL);
 586
 587         dev->trans_start = jiffies;
 588
 589         lp->tx_started = 0;
 590         lp->tx_queue_ready = 1;
 591         lp->rx_started = 0;
 592         lp->tx_queue = 0;
 593         lp->tx_queue_len = 0;
 594
 595         netif_wake_queue(dev);
 596 }
 597
 598
 599 static netdev_tx_t net_send_packet (struct sk_buff *skb,
 600                                     struct net_device *dev)
 601 {
 602         struct net_local *lp = netdev_priv(dev);
 603         int ioaddr = dev->base_addr;
 604         short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
 605         short len = skb->len;
 606         unsigned char *buf = skb->data;
 607         static u8 pad[ETH_ZLEN];
 608
 609         netif_stop_queue (dev);
 610
 611         /* We may not start transmitting unless we finish transferring
 612            a packet into the Tx queue. During executing the following
 613            codes we possibly catch a Tx interrupt. Thus we flag off
 614            tx_queue_ready, so that we prevent the interrupt routine
 615            (net_interrupt) to start transmitting. */
 616         lp->tx_queue_ready = 0;
 617         {
 618                 outw (length, ioaddr + DATAPORT);
 619                 /* Packet data */
 620                 outsw (ioaddr + DATAPORT, buf, len >> 1);
 621                 /* Check for dribble byte */
 622                 if (len & 1) {
 623                         outw(skb->data[skb->len-1], ioaddr + DATAPORT);
 624                         len++;
 625                 }
 626                 /* Check for packet padding */
 627                 if (length != skb->len)
 628                         outsw(ioaddr + DATAPORT, pad, (length - len + 1) >> 1);
 629
 630                 lp->tx_queue++;
 631                 lp->tx_queue_len += length + 2;
 632         }
 633         lp->tx_queue_ready = 1;
 634
 635         if (lp->tx_started == 0) {
 636                 /* If the Tx is idle, always trigger a transmit. */
 637                 outb (0x80 | lp->tx_queue, ioaddr + TX_START);
 638                 lp->tx_queue = 0;
 639                 lp->tx_queue_len = 0;
 640                 dev->trans_start = jiffies;
 641                 lp->tx_started = 1;
 642                 netif_start_queue (dev);
 643         } else if (lp->tx_queue_len < 4096 - 1502)
 644                 /* Yes, there is room for one more packet. */
 645                 netif_start_queue (dev);
 646         dev_kfree_skb (skb);
 647
 648         return NETDEV_TX_OK;
 649 }
 650
 651 /* The typical workload of the driver:
 652    Handle the network interface interrupts. */
 653 static irqreturn_t net_interrupt(int irq, void *dev_id)
 654 {
 655         struct net_device *dev = dev_id;
 656         struct net_local *lp;
 657         int ioaddr, status;
 658         int handled = 0;
 659
 660         if (dev == NULL) {
 661                 printk ("at1700_interrupt(): irq %d for unknown device.\n", irq);
 662                 return IRQ_NONE;
 663         }
 664
 665         ioaddr = dev->base_addr;
 666         lp = netdev_priv(dev);
 667
 668         spin_lock (&lp->lock);
 669
 670         status = inw(ioaddr + TX_STATUS);
 671         outw(status, ioaddr + TX_STATUS);
 672
 673         if (net_debug > 4)
 674                 printk("%s: Interrupt with status %04x.\n", dev->name, status);
 675         if (lp->rx_started == 0 &&
 676             (status & 0xff00 || (inb(ioaddr + RX_MODE) & 0x40) == 0)) {
 677                 /* Got a packet(s).
 678                    We cannot execute net_rx more than once at the same time for
 679                    the same device. During executing net_rx, we possibly catch a
 680                    Tx interrupt. Thus we flag on rx_started, so that we prevent
 681                    the interrupt routine (net_interrupt) to dive into net_rx
 682                    again. */
 683                 handled = 1;
 684                 lp->rx_started = 1;
 685                 outb(0x00, ioaddr + RX_INTR);   /* Disable RX intr. */
 686                 net_rx(dev);
 687                 outb(0x81, ioaddr + RX_INTR);   /* Enable  RX intr. */
 688                 lp->rx_started = 0;
 689         }
 690         if (status & 0x00ff) {
 691                 handled = 1;
 692                 if (status & 0x02) {
 693                         /* More than 16 collisions occurred */
 694                         if (net_debug > 4)
 695                                 printk("%s: 16 Collision occur during Txing.\n", dev->name);
 696                         /* Cancel sending a packet. */
 697                         outb(0x03, ioaddr + COL16CNTL);
 698                         dev->stats.collisions++;
 699                 }
 700                 if (status & 0x82) {
 701                         dev->stats.tx_packets++;
 702                         /* The Tx queue has any packets and is not being
 703                            transferred a packet from the host, start
 704                            transmitting. */
 705                         if (lp->tx_queue && lp->tx_queue_ready) {
 706                                 outb(0x80 | lp->tx_queue, ioaddr + TX_START);
 707                                 lp->tx_queue = 0;
 708                                 lp->tx_queue_len = 0;
 709                                 dev->trans_start = jiffies;
 710                                 netif_wake_queue (dev);
 711                         } else {
 712                                 lp->tx_started = 0;
 713                                 netif_wake_queue (dev);
 714                         }
 715                 }
 716         }
 717
 718         spin_unlock (&lp->lock);
 719         return IRQ_RETVAL(handled);
 720 }
 721
 722 /* We have a good packet(s), get it/them out of the buffers. */
 723 static void
 724 net_rx(struct net_device *dev)
 725 {
 726         int ioaddr = dev->base_addr;
 727         int boguscount = 5;
 728
 729         while ((inb(ioaddr + RX_MODE) & 0x40) == 0) {
 730                 ushort status = inw(ioaddr + DATAPORT);
 731                 ushort pkt_len = inw(ioaddr + DATAPORT);
 732
 733                 if (net_debug > 4)
 734                         printk("%s: Rxing packet mode %02x status %04x.\n",
 735                                    dev->name, inb(ioaddr + RX_MODE), status);
 736 #ifndef final_version
 737                 if (status == 0) {
 738                         outb(0x05, ioaddr + RX_CTRL);
 739                         break;
 740                 }
 741 #endif
 742
 743                 if ((status & 0xF0) != 0x20) {  /* There was an error. */
 744                         dev->stats.rx_errors++;
 745                         if (status & 0x08) dev->stats.rx_length_errors++;
 746                         if (status & 0x04) dev->stats.rx_frame_errors++;
 747                         if (status & 0x02) dev->stats.rx_crc_errors++;
 748                         if (status & 0x01) dev->stats.rx_over_errors++;
 749                 } else {
 750                         /* Malloc up new buffer. */
 751                         struct sk_buff *skb;
 752
 753                         if (pkt_len > 1550) {
 754                                 printk("%s: The AT1700 claimed a very large packet, size %d.\n",
 755                                            dev->name, pkt_len);
 756                                 /* Prime the FIFO and then flush the packet. */
 757                                 inw(ioaddr + DATAPORT); inw(ioaddr + DATAPORT);
 758                                 outb(0x05, ioaddr + RX_CTRL);
 759                                 dev->stats.rx_errors++;
 760                                 break;
 761                         }
 762                         skb = dev_alloc_skb(pkt_len+3);
 763                         if (skb == NULL) {
 764                                 printk("%s: Memory squeeze, dropping packet (len %d).\n",
 765                                            dev->name, pkt_len);
 766                                 /* Prime the FIFO and then flush the packet. */
 767                                 inw(ioaddr + DATAPORT); inw(ioaddr + DATAPORT);
 768                                 outb(0x05, ioaddr + RX_CTRL);
 769                                 dev->stats.rx_dropped++;
 770                                 break;
 771                         }
 772                         skb_reserve(skb,2);
 773
 774                         insw(ioaddr + DATAPORT, skb_put(skb,pkt_len), (pkt_len + 1) >> 1);
 775                         skb->protocol=eth_type_trans(skb, dev);
 776                         netif_rx(skb);
 777                         dev->stats.rx_packets++;
 778                         dev->stats.rx_bytes += pkt_len;
 779                 }
 780                 if (--boguscount <= 0)
 781                         break;
 782         }
 783
 784         /* If any worth-while packets have been received, dev_rint()
 785            has done a mark_bh(NET_BH) for us and will work on them
 786            when we get to the bottom-half routine. */
 787         {
 788                 int i;
 789                 for (i = 0; i < 20; i++) {
 790                         if ((inb(ioaddr + RX_MODE) & 0x40) == 0x40)
 791                                 break;
 792                         inw(ioaddr + DATAPORT);                         /* dummy status read */
 793                         outb(0x05, ioaddr + RX_CTRL);
 794                 }
 795
 796                 if (net_debug > 5)
 797                         printk("%s: Exint Rx packet with mode %02x after %d ticks.\n",
 798                                    dev->name, inb(ioaddr + RX_MODE), i);
 799         }
 800         return;
 801 }
 802
 803 /* The inverse routine to net_open(). */
 804 static int net_close(struct net_device *dev)
 805 {
 806         struct net_local *lp = netdev_priv(dev);
 807         int ioaddr = dev->base_addr;
 808
 809         netif_stop_queue(dev);
 810
 811         /* Set configuration register 0 to disable Tx and Rx. */
 812         outb(0xda, ioaddr + CONFIG_0);
 813
 814         /* No statistic counters on the chip to update. */
 815
 816         /* Disable the IRQ on boards of fmv18x where it is feasible. */
 817         if (lp->jumpered) {
 818                 outb(0x00, ioaddr + IOCONFIG1);
 819                 free_irq(dev->irq, dev);
 820         }
 821
 822         /* Power-down the chip.  Green, green, green! */
 823         outb(0x00, ioaddr + CONFIG_1);
 824         return 0;
 825 }
 826
 827 /*
 828   Set the multicast/promiscuous mode for this adaptor.
 829 */
 830
 831 static void
 832 set_rx_mode(struct net_device *dev)
 833 {
 834         int ioaddr = dev->base_addr;
 835         struct net_local *lp = netdev_priv(dev);
 836         unsigned char mc_filter[8];              /* Multicast hash filter */
 837         unsigned long flags;
 838
 839         if (dev->flags & IFF_PROMISC) {
 840                 memset(mc_filter, 0xff, sizeof(mc_filter));
 841                 outb(3, ioaddr + RX_MODE);      /* Enable promiscuous mode */
 842         } else if (netdev_mc_count(dev) > MC_FILTERBREAK ||
 843                            (dev->flags & IFF_ALLMULTI)) {
 844                 /* Too many to filter perfectly -- accept all multicasts. */
 845                 memset(mc_filter, 0xff, sizeof(mc_filter));
 846                 outb(2, ioaddr + RX_MODE);      /* Use normal mode. */
 847         } else if (netdev_mc_empty(dev)) {
 848                 memset(mc_filter, 0x00, sizeof(mc_filter));
 849                 outb(1, ioaddr + RX_MODE);      /* Ignore almost all multicasts. */
 850         } else {
 851                 struct dev_mc_list *mclist;
 852                 int i;
 853
 854                 memset(mc_filter, 0, sizeof(mc_filter));
 855                 for (i = 0, mclist = dev->mc_list; mclist && i < netdev_mc_count(dev);
 856                          i++, mclist = mclist->next) {
 857                         unsigned int bit =
 858                                 ether_crc_le(ETH_ALEN, mclist->dmi_addr) >> 26;
 859                         mc_filter[bit >> 3] |= (1 << bit);
 860                 }
 861                 outb(0x02, ioaddr + RX_MODE);   /* Use normal mode. */
 862         }
 863
 864         spin_lock_irqsave (&lp->lock, flags);
 865         if (memcmp(mc_filter, lp->mc_filter, sizeof(mc_filter))) {
 866                 int i;
 867                 int saved_bank = inw(ioaddr + CONFIG_0);
 868                 /* Switch to bank 1 and set the multicast table. */
 869                 outw((saved_bank & ~0x0C00) | 0x0480, ioaddr + CONFIG_0);
 870                 for (i = 0; i < 8; i++)
 871                         outb(mc_filter[i], ioaddr + PORT_OFFSET(8 + i));
 872                 memcpy(lp->mc_filter, mc_filter, sizeof(mc_filter));
 873                 outw(saved_bank, ioaddr + CONFIG_0);
 874         }
 875         spin_unlock_irqrestore (&lp->lock, flags);
 876         return;
 877 }
 878
 879 #ifdef MODULE
 880 static struct net_device *dev_at1700;
 881
 882 module_param(io, int, 0);
 883 module_param(irq, int, 0);
 884 module_param(net_debug, int, 0);
 885 MODULE_PARM_DESC(io, "AT1700/FMV18X I/O base address");
 886 MODULE_PARM_DESC(irq, "AT1700/FMV18X IRQ number");
 887 MODULE_PARM_DESC(net_debug, "AT1700/FMV18X debug level (0-6)");
 888
 889 static int __init at1700_module_init(void)
 890 {
 891         if (io == 0)
 892                 printk("at1700: You should not use auto-probing with insmod!\n");
 893         dev_at1700 = at1700_probe(-1);
 894         if (IS_ERR(dev_at1700))
 895                 return PTR_ERR(dev_at1700);
 896         return 0;
 897 }
 898
 899 static void __exit at1700_module_exit(void)
 900 {
 901         unregister_netdev(dev_at1700);
 902         cleanup_card(dev_at1700);
 903         free_netdev(dev_at1700);
 904 }
 905 module_init(at1700_module_init);
 906 module_exit(at1700_module_exit);
 907 #endif /* MODULE */
 908 MODULE_LICENSE("GPL");