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