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