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/string.h>
  51 #include <linux/init.h>
  52 #include <linux/crc32.h>
  53 #include <linux/bitops.h>
  54
  55 #include <asm/system.h>
  56 #include <asm/io.h>
  57 #include <asm/dma.h>
  58
  59 static char version[] __initdata =
  60         "at1700.c:v1.16 9/11/06  Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";
  61
  62 #define DRV_NAME "at1700"
  63
  64 /* Tunable parameters. */
  65
  66 /* When to switch from the 64-entry multicast filter to Rx-all-multicast. */
  67 #define MC_FILTERBREAK 64
  68
  69 /* These unusual address orders are used to verify the CONFIG register. */
  70
  71 static int fmv18x_probe_list[] __initdata = {
  72         0x220, 0x240, 0x260, 0x280, 0x2a0, 0x2c0, 0x300, 0x340, 0
  73 };
  74
  75 /*
  76  *      ISA
  77  */
  78
  79 static unsigned at1700_probe_list[] __initdata = {
  80         0x260, 0x280, 0x2a0, 0x240, 0x340, 0x320, 0x380, 0x300, 0
  81 };
  82
  83 /*
  84  *      MCA
  85  */
  86 #ifdef CONFIG_MCA_LEGACY
  87 static int at1700_ioaddr_pattern[] __initdata = {
  88         0x00, 0x04, 0x01, 0x05, 0x02, 0x06, 0x03, 0x07
  89 };
  90
  91 static int at1700_mca_probe_list[] __initdata = {
  92         0x400, 0x1400, 0x2400, 0x3400, 0x4400, 0x5400, 0x6400, 0x7400, 0
  93 };
  94
  95 static int at1700_irq_pattern[] __initdata = {
  96         0x00, 0x00, 0x00, 0x30, 0x70, 0xb0, 0x00, 0x00,
  97         0x00, 0xf0, 0x34, 0x74, 0xb4, 0x00, 0x00, 0xf4, 0x00
  98 };
  99 #endif
 100
 101 /* use 0 for production, 1 for verification, >2 for debug */
 102 #ifndef NET_DEBUG
 103 #define NET_DEBUG 1
 104 #endif
 105 static unsigned int net_debug = NET_DEBUG;
 106
 107 typedef unsigned char uchar;
 108
 109 /* Information that need to be kept for each board. */
 110 struct net_local {
 111         spinlock_t lock;
 112         unsigned char mc_filter[8];
 113         uint jumpered:1;                        /* Set iff the board has jumper config. */
 114         uint tx_started:1;                      /* Packets are on the Tx queue. */
 115         uint tx_queue_ready:1;                  /* Tx queue is ready to be sent. */
 116         uint rx_started:1;                      /* Packets are Rxing. */
 117         uchar tx_queue;                         /* Number of packet on the Tx queue. */
 118         char mca_slot;                          /* -1 means ISA */
 119         ushort tx_queue_len;                    /* Current length of the Tx queue. */
 120 };
 121
 122
 123 /* Offsets from the base address. */
 124 #define STATUS                  0
 125 #define TX_STATUS               0
 126 #define RX_STATUS               1
 127 #define TX_INTR                 2               /* Bit-mapped interrupt enable registers. */
 128 #define RX_INTR                 3
 129 #define TX_MODE                 4
 130 #define RX_MODE                 5
 131 #define CONFIG_0                6               /* Misc. configuration settings. */
 132 #define CONFIG_1                7
 133 /* Run-time register bank 2 definitions. */
 134 #define DATAPORT                8               /* Word-wide DMA or programmed-I/O dataport. */
 135 #define TX_START                10
 136 #define COL16CNTL               11              /* Controll Reg for 16 collisions */
 137 #define MODE13                  13
 138 #define RX_CTRL                 14
 139 /* Configuration registers only on the '865A/B chips. */
 140 #define EEPROM_Ctrl     16
 141 #define EEPROM_Data     17
 142 #define CARDSTATUS      16                      /* FMV-18x Card Status */
 143 #define CARDSTATUS1     17                      /* FMV-18x Card Status */
 144 #define IOCONFIG                18              /* Either read the jumper, or move the I/O. */
 145 #define IOCONFIG1               19
 146 #define SAPROM                  20              /* The station address PROM, if no EEPROM. */
 147 #define MODE24                  24
 148 #define RESET                   31              /* Write to reset some parts of the chip. */
 149 #define AT1700_IO_EXTENT        32
 150 #define PORT_OFFSET(o) (o)
 151
 152
 153 #define TX_TIMEOUT              10
 154
 155
 156 /* Index to functions, as function prototypes. */
 157
 158 static int at1700_probe1(struct net_device *dev, int ioaddr);
 159 static int read_eeprom(long ioaddr, int location);
 160 static int net_open(struct net_device *dev);
 161 static netdev_tx_t net_send_packet(struct sk_buff *skb,
 162                                    struct net_device *dev);
 163 static irqreturn_t net_interrupt(int irq, void *dev_id);
 164 static void net_rx(struct net_device *dev);
 165 static int net_close(struct net_device *dev);
 166 static void set_rx_mode(struct net_device *dev);
 167 static void net_tx_timeout (struct net_device *dev);
 168
 169
 170 #ifdef CONFIG_MCA_LEGACY
 171 struct at1720_mca_adapters_struct {
 172         char* name;
 173         int id;
 174 };
 175 /* rEnE : maybe there are others I don't know off... */
 176
 177 static struct at1720_mca_adapters_struct at1720_mca_adapters[] __initdata = {
 178         { "Allied Telesys AT1720AT",    0x6410 },
 179         { "Allied Telesys AT1720BT",    0x6413 },
 180         { "Allied Telesys AT1720T",     0x6416 },
 181         { NULL, 0 },
 182 };
 183 #endif
 184
 185 /* Check for a network adaptor of this type, and return '0' iff one exists.
 186    If dev->base_addr == 0, probe all likely locations.
 187    If dev->base_addr == 1, always return failure.
 188    If dev->base_addr == 2, allocate space for the device and return success
 189    (detachable devices only).
 190    */
 191
 192 static int io = 0x260;
 193
 194 static int irq;
 195
 196 static void cleanup_card(struct net_device *dev)
 197 {
 198 #ifdef CONFIG_MCA_LEGACY
 199         struct net_local *lp = netdev_priv(dev);
 200         if (lp->mca_slot >= 0)
 201                 mca_mark_as_unused(lp->mca_slot);
 202 #endif
 203         free_irq(dev->irq, NULL);
 204         release_region(dev->base_addr, AT1700_IO_EXTENT);
 205 }
 206
 207 struct net_device * __init at1700_probe(int unit)
 208 {
 209         struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
 210         unsigned *port;
 211         int err = 0;
 212
 213         if (!dev)
 214                 return ERR_PTR(-ENODEV);
 215
 216         if (unit >= 0) {
 217                 sprintf(dev->name, "eth%d", unit);
 218                 netdev_boot_setup_check(dev);
 219                 io = dev->base_addr;
 220                 irq = dev->irq;
 221         } else {
 222                 dev->base_addr = io;
 223                 dev->irq = irq;
 224         }
 225
 226         if (io > 0x1ff) {       /* Check a single specified location. */
 227                 err = at1700_probe1(dev, io);
 228         } else if (io != 0) {   /* Don't probe at all. */
 229                 err = -ENXIO;
 230         } else {
 231                 for (port = at1700_probe_list; *port; port++) {
 232                         if (at1700_probe1(dev, *port) == 0)
 233                                 break;
 234                         dev->irq = irq;
 235                 }
 236                 if (!*port)
 237                         err = -ENODEV;
 238         }
 239         if (err)
 240                 goto out;
 241         err = register_netdev(dev);
 242         if (err)
 243                 goto out1;
 244         return dev;
 245 out1:
 246         cleanup_card(dev);
 247 out:
 248         free_netdev(dev);
 249         return ERR_PTR(err);
 250 }
 251
 252 static const struct net_device_ops at1700_netdev_ops = {
 253         .ndo_open               = net_open,
 254         .ndo_stop               = net_close,
 255         .ndo_start_xmit         = net_send_packet,
 256         .ndo_set_multicast_list = set_rx_mode,
 257         .ndo_tx_timeout         = net_tx_timeout,
 258         .ndo_change_mtu         = eth_change_mtu,
 259         .ndo_set_mac_address    = eth_mac_addr,
 260         .ndo_validate_addr      = eth_validate_addr,
 261 };
 262
 263 /* The Fujitsu datasheet suggests that the NIC be probed for by checking its
 264    "signature", the default bit pattern after a reset.  This *doesn't* work --
 265    there is no way to reset the bus interface without a complete power-cycle!
 266
 267    It turns out that ATI came to the same conclusion I did: the only thing
 268    that can be done is checking a few bits and then diving right into an
 269    EEPROM read. */
 270
 271 static int __init at1700_probe1(struct net_device *dev, int ioaddr)
 272 {
 273         char fmv_irqmap[4] = {3, 7, 10, 15};
 274         char fmv_irqmap_pnp[8] = {3, 4, 5, 7, 9, 10, 11, 15};
 275         char at1700_irqmap[8] = {3, 4, 5, 9, 10, 11, 14, 15};
 276         unsigned int i, irq, is_fmv18x = 0, is_at1700 = 0;
 277         int slot, ret = -ENODEV;
 278         struct net_local *lp = netdev_priv(dev);
 279
 280         if (!request_region(ioaddr, AT1700_IO_EXTENT, DRV_NAME))
 281                 return -EBUSY;
 282
 283         /* Resetting the chip doesn't reset the ISA interface, so don't bother.
 284            That means we have to be careful with the register values we probe
 285            for.
 286          */
 287 #ifdef notdef
 288         printk("at1700 probe at %#x, eeprom is %4.4x %4.4x %4.4x ctrl %4.4x.\n",
 289                    ioaddr, read_eeprom(ioaddr, 4), read_eeprom(ioaddr, 5),
 290                    read_eeprom(ioaddr, 6), inw(ioaddr + EEPROM_Ctrl));
 291 #endif
 292
 293 #ifdef CONFIG_MCA_LEGACY
 294         /* rEnE (rene@bss.lu): got this from 3c509 driver source , adapted for AT1720 */
 295
 296     /* Based on Erik Nygren's (nygren@mit.edu) 3c529 patch, heavily
 297         modified by Chris Beauregard (cpbeaure@csclub.uwaterloo.ca)
 298         to support standard MCA probing. */
 299
 300         /* redone for multi-card detection by ZP Gu (zpg@castle.net) */
 301         /* now works as a module */
 302
 303         if (MCA_bus) {
 304                 int j;
 305                 int l_i;
 306                 u_char pos3, pos4;
 307
 308                 for (j = 0; at1720_mca_adapters[j].name != NULL; j ++) {
 309                         slot = 0;
 310                         while (slot != MCA_NOTFOUND) {
 311
 312                                 slot = mca_find_unused_adapter( at1720_mca_adapters[j].id, slot );
 313                                 if (slot == MCA_NOTFOUND) break;
 314
 315                                 /* if we get this far, an adapter has been detected and is
 316                                 enabled */
 317
 318                                 pos3 = mca_read_stored_pos( slot, 3 );
 319                                 pos4 = mca_read_stored_pos( slot, 4 );
 320
 321                                 for (l_i = 0; l_i < 8; l_i++)
 322                                         if (( pos3 & 0x07) == at1700_ioaddr_pattern[l_i])
 323                                                 break;
 324                                 ioaddr = at1700_mca_probe_list[l_i];
 325
 326                                 for (irq = 0; irq < 0x10; irq++)
 327                                         if (((((pos4>>4) & 0x0f) | (pos3 & 0xf0)) & 0xff) == at1700_irq_pattern[irq])
 328                                                 break;
 329
 330                                         /* probing for a card at a particular IO/IRQ */
 331                                 if ((dev->irq && dev->irq != irq) ||
 332                                     (dev->base_addr && dev->base_addr != ioaddr)) {
 333                                         slot++;         /* probing next slot */
 334                                         continue;
 335                                 }
 336
 337                                 dev->irq = irq;
 338
 339                                 /* claim the slot */
 340                                 mca_set_adapter_name( slot, at1720_mca_adapters[j].name );
 341                                 mca_mark_as_used(slot);
 342
 343                                 goto found;
 344                         }
 345                 }
 346                 /* if we get here, we didn't find an MCA adapter - try ISA */
 347         }
 348 #endif
 349         slot = -1;
 350         /* We must check for the EEPROM-config boards first, else accessing
 351            IOCONFIG0 will move the board! */
 352         if (at1700_probe_list[inb(ioaddr + IOCONFIG1) & 0x07] == ioaddr &&
 353             read_eeprom(ioaddr, 4) == 0x0000 &&
 354             (read_eeprom(ioaddr, 5) & 0xff00) == 0xF400)
 355                 is_at1700 = 1;
 356         else if (inb(ioaddr + SAPROM    ) == 0x00 &&
 357                  inb(ioaddr + SAPROM + 1) == 0x00 &&
 358                  inb(ioaddr + SAPROM + 2) == 0x0e)
 359                 is_fmv18x = 1;
 360         else {
 361                 goto err_out;
 362         }
 363
 364 #ifdef CONFIG_MCA_LEGACY
 365 found:
 366 #endif
 367
 368                 /* Reset the internal state machines. */
 369         outb(0, ioaddr + RESET);
 370
 371         if (is_at1700) {
 372                 irq = at1700_irqmap[(read_eeprom(ioaddr, 12)&0x04)
 373                                                    | (read_eeprom(ioaddr, 0)>>14)];
 374         } else {
 375                 /* Check PnP mode for FMV-183/184/183A/184A. */
 376                 /* This PnP routine is very poor. IO and IRQ should be known. */
 377                 if (inb(ioaddr + CARDSTATUS1) & 0x20) {
 378                         irq = dev->irq;
 379                         for (i = 0; i < 8; i++) {
 380                                 if (irq == fmv_irqmap_pnp[i])
 381                                         break;
 382                         }
 383                         if (i == 8) {
 384                                 goto err_mca;
 385                         }
 386                 } else {
 387                         if (fmv18x_probe_list[inb(ioaddr + IOCONFIG) & 0x07] != ioaddr)
 388                                 goto err_mca;
 389                         irq = fmv_irqmap[(inb(ioaddr + IOCONFIG)>>6) & 0x03];
 390                 }
 391         }
 392
 393         printk("%s: %s found at %#3x, IRQ %d, address ", dev->name,
 394                    is_at1700 ? "AT1700" : "FMV-18X", ioaddr, irq);
 395
 396         dev->base_addr = ioaddr;
 397         dev->irq = irq;
 398
 399         if (is_at1700) {
 400                 for(i = 0; i < 3; i++) {
 401                         unsigned short eeprom_val = read_eeprom(ioaddr, 4+i);
 402                         ((unsigned short *)dev->dev_addr)[i] = ntohs(eeprom_val);
 403                 }
 404         } else {
 405                 for(i = 0; i < 6; i++) {
 406                         unsigned char val = inb(ioaddr + SAPROM + i);
 407                         dev->dev_addr[i] = val;
 408                 }
 409         }
 410         printk("%pM", dev->dev_addr);
 411
 412         /* The EEPROM word 12 bit 0x0400 means use regular 100 ohm 10baseT signals,
 413            rather than 150 ohm shielded twisted pair compensation.
 414            0x0000 == auto-sense the interface
 415            0x0800 == use TP interface
 416            0x1800 == use coax interface
 417            */
 418         {
 419                 const char *porttype[] = {"auto-sense", "10baseT", "auto-sense", "10base2"};
 420                 if (is_at1700) {
 421                         ushort setup_value = read_eeprom(ioaddr, 12);
 422                         dev->if_port = setup_value >> 8;
 423                 } else {
 424                         ushort setup_value = inb(ioaddr + CARDSTATUS);
 425                         switch (setup_value & 0x07) {
 426                         case 0x01: /* 10base5 */
 427                         case 0x02: /* 10base2 */
 428                                 dev->if_port = 0x18; break;
 429                         case 0x04: /* 10baseT */
 430                                 dev->if_port = 0x08; break;
 431                         default:   /* auto-sense */
 432                                 dev->if_port = 0x00; break;
 433                         }
 434                 }
 435                 printk(" %s interface.\n", porttype[(dev->if_port>>3) & 3]);
 436         }
 437
 438         /* Set the configuration register 0 to 32K 100ns. byte-wide memory, 16 bit
 439            bus access, two 4K Tx queues, and disabled Tx and Rx. */
 440         outb(0xda, ioaddr + CONFIG_0);
 441
 442         /* Set the station address in bank zero. */
 443         outb(0x00, ioaddr + CONFIG_1);
 444         for (i = 0; i < 6; i++)
 445                 outb(dev->dev_addr[i], ioaddr + PORT_OFFSET(8 + i));
 446
 447         /* Switch to bank 1 and set the multicast table to accept none. */
 448         outb(0x04, ioaddr + CONFIG_1);
 449         for (i = 0; i < 8; i++)
 450                 outb(0x00, ioaddr + PORT_OFFSET(8 + i));
 451
 452
 453         /* Switch to bank 2 */
 454         /* Lock our I/O address, and set manual processing mode for 16 collisions. */
 455         outb(0x08, ioaddr + CONFIG_1);
 456         outb(dev->if_port, ioaddr + MODE13);
 457         outb(0x00, ioaddr + COL16CNTL);
 458
 459         if (net_debug)
 460                 printk(version);
 461
 462         dev->netdev_ops = &at1700_netdev_ops;
 463         dev->watchdog_timeo = TX_TIMEOUT;
 464
 465         spin_lock_init(&lp->lock);
 466
 467         lp->jumpered = is_fmv18x;
 468         lp->mca_slot = slot;
 469         /* Snarf the interrupt vector now. */
 470         ret = request_irq(irq, net_interrupt, 0, DRV_NAME, dev);
 471         if (ret) {
 472                 printk(KERN_ERR "AT1700 at %#3x is unusable due to a "
 473                        "conflict on IRQ %d.\n",
 474                        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
 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
 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         dev->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 netdev_tx_t net_send_packet (struct sk_buff *skb,
 599                                     struct net_device *dev)
 600 {
 601         struct net_local *lp = netdev_priv(dev);
 602         int ioaddr = dev->base_addr;
 603         short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
 604         short len = skb->len;
 605         unsigned char *buf = skb->data;
 606         static u8 pad[ETH_ZLEN];
 607
 608         netif_stop_queue (dev);
 609
 610         /* We may not start transmitting unless we finish transferring
 611            a packet into the Tx queue. During executing the following
 612            codes we possibly catch a Tx interrupt. Thus we flag off
 613            tx_queue_ready, so that we prevent the interrupt routine
 614            (net_interrupt) to start transmitting. */
 615         lp->tx_queue_ready = 0;
 616         {
 617                 outw (length, ioaddr + DATAPORT);
 618                 /* Packet data */
 619                 outsw (ioaddr + DATAPORT, buf, len >> 1);
 620                 /* Check for dribble byte */
 621                 if (len & 1) {
 622                         outw(skb->data[skb->len-1], ioaddr + DATAPORT);
 623                         len++;
 624                 }
 625                 /* Check for packet padding */
 626                 if (length != skb->len)
 627                         outsw(ioaddr + DATAPORT, pad, (length - len + 1) >> 1);
 628
 629                 lp->tx_queue++;
 630                 lp->tx_queue_len += length + 2;
 631         }
 632         lp->tx_queue_ready = 1;
 633
 634         if (lp->tx_started == 0) {
 635                 /* If the Tx is idle, always trigger a transmit. */
 636                 outb (0x80 | lp->tx_queue, ioaddr + TX_START);
 637                 lp->tx_queue = 0;
 638                 lp->tx_queue_len = 0;
 639                 dev->trans_start = jiffies;
 640                 lp->tx_started = 1;
 641                 netif_start_queue (dev);
 642         } else if (lp->tx_queue_len < 4096 - 1502)
 643                 /* Yes, there is room for one more packet. */
 644                 netif_start_queue (dev);
 645         dev_kfree_skb (skb);
 646
 647         return NETDEV_TX_OK;
 648 }
 649
 650 /* The typical workload of the driver:
 651    Handle the network interface interrupts. */
 652 static irqreturn_t net_interrupt(int irq, void *dev_id)
 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                         dev->stats.collisions++;
 698                 }
 699                 if (status & 0x82) {
 700                         dev->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         int ioaddr = dev->base_addr;
 726         int boguscount = 5;
 727
 728         while ((inb(ioaddr + RX_MODE) & 0x40) == 0) {
 729                 ushort status = inw(ioaddr + DATAPORT);
 730                 ushort pkt_len = inw(ioaddr + DATAPORT);
 731
 732                 if (net_debug > 4)
 733                         printk("%s: Rxing packet mode %02x status %04x.\n",
 734                                    dev->name, inb(ioaddr + RX_MODE), status);
 735 #ifndef final_version
 736                 if (status == 0) {
 737                         outb(0x05, ioaddr + RX_CTRL);
 738                         break;
 739                 }
 740 #endif
 741
 742                 if ((status & 0xF0) != 0x20) {  /* There was an error. */
 743                         dev->stats.rx_errors++;
 744                         if (status & 0x08) dev->stats.rx_length_errors++;
 745                         if (status & 0x04) dev->stats.rx_frame_errors++;
 746                         if (status & 0x02) dev->stats.rx_crc_errors++;
 747                         if (status & 0x01) dev->stats.rx_over_errors++;
 748                 } else {
 749                         /* Malloc up new buffer. */
 750                         struct sk_buff *skb;
 751
 752                         if (pkt_len > 1550) {
 753                                 printk("%s: The AT1700 claimed a very large packet, size %d.\n",
 754                                            dev->name, pkt_len);
 755                                 /* Prime the FIFO and then flush the packet. */
 756                                 inw(ioaddr + DATAPORT); inw(ioaddr + DATAPORT);
 757                                 outb(0x05, ioaddr + RX_CTRL);
 758                                 dev->stats.rx_errors++;
 759                                 break;
 760                         }
 761                         skb = dev_alloc_skb(pkt_len+3);
 762                         if (skb == NULL) {
 763                                 printk("%s: Memory squeeze, dropping packet (len %d).\n",
 764                                            dev->name, pkt_len);
 765                                 /* Prime the FIFO and then flush the packet. */
 766                                 inw(ioaddr + DATAPORT); inw(ioaddr + DATAPORT);
 767                                 outb(0x05, ioaddr + RX_CTRL);
 768                                 dev->stats.rx_dropped++;
 769                                 break;
 770                         }
 771                         skb_reserve(skb,2);
 772
 773                         insw(ioaddr + DATAPORT, skb_put(skb,pkt_len), (pkt_len + 1) >> 1);
 774                         skb->protocol=eth_type_trans(skb, dev);
 775                         netif_rx(skb);
 776                         dev->stats.rx_packets++;
 777                         dev->stats.rx_bytes += pkt_len;
 778                 }
 779                 if (--boguscount <= 0)
 780                         break;
 781         }
 782
 783         /* If any worth-while packets have been received, dev_rint()
 784            has done a mark_bh(NET_BH) for us and will work on them
 785            when we get to the bottom-half routine. */
 786         {
 787                 int i;
 788                 for (i = 0; i < 20; i++) {
 789                         if ((inb(ioaddr + RX_MODE) & 0x40) == 0x40)
 790                                 break;
 791                         inw(ioaddr + DATAPORT);                         /* dummy status read */
 792                         outb(0x05, ioaddr + RX_CTRL);
 793                 }
 794
 795                 if (net_debug > 5)
 796                         printk("%s: Exint Rx packet with mode %02x after %d ticks.\n",
 797                                    dev->name, inb(ioaddr + RX_MODE), i);
 798         }
 799         return;
 800 }
 801
 802 /* The inverse routine to net_open(). */
 803 static int net_close(struct net_device *dev)
 804 {
 805         struct net_local *lp = netdev_priv(dev);
 806         int ioaddr = dev->base_addr;
 807
 808         netif_stop_queue(dev);
 809
 810         /* Set configuration register 0 to disable Tx and Rx. */
 811         outb(0xda, ioaddr + CONFIG_0);
 812
 813         /* No statistic counters on the chip to update. */
 814
 815         /* Disable the IRQ on boards of fmv18x where it is feasible. */
 816         if (lp->jumpered) {
 817                 outb(0x00, ioaddr + IOCONFIG1);
 818                 free_irq(dev->irq, dev);
 819         }
 820
 821         /* Power-down the chip.  Green, green, green! */
 822         outb(0x00, ioaddr + CONFIG_1);
 823         return 0;
 824 }
 825
 826 /*
 827   Set the multicast/promiscuous mode for this adaptor.
 828 */
 829
 830 static void
 831 set_rx_mode(struct net_device *dev)
 832 {
 833         int ioaddr = dev->base_addr;
 834         struct net_local *lp = netdev_priv(dev);
 835         unsigned char mc_filter[8];              /* Multicast hash filter */
 836         unsigned long flags;
 837
 838         if (dev->flags & IFF_PROMISC) {
 839                 memset(mc_filter, 0xff, sizeof(mc_filter));
 840                 outb(3, ioaddr + RX_MODE);      /* Enable promiscuous mode */
 841         } else if (netdev_mc_count(dev) > MC_FILTERBREAK ||
 842                            (dev->flags & IFF_ALLMULTI)) {
 843                 /* Too many to filter perfectly -- accept all multicasts. */
 844                 memset(mc_filter, 0xff, sizeof(mc_filter));
 845                 outb(2, ioaddr + RX_MODE);      /* Use normal mode. */
 846         } else if (netdev_mc_empty(dev)) {
 847                 memset(mc_filter, 0x00, sizeof(mc_filter));
 848                 outb(1, ioaddr + RX_MODE);      /* Ignore almost all multicasts. */
 849         } else {
 850                 struct dev_mc_list *mclist;
 851
 852                 memset(mc_filter, 0, sizeof(mc_filter));
 853                 netdev_for_each_mc_addr(mclist, dev) {
 854                         unsigned int bit =
 855                                 ether_crc_le(ETH_ALEN, mclist->dmi_addr) >> 26;
 856                         mc_filter[bit >> 3] |= (1 << bit);
 857                 }
 858                 outb(0x02, ioaddr + RX_MODE);   /* Use normal mode. */
 859         }
 860
 861         spin_lock_irqsave (&lp->lock, flags);
 862         if (memcmp(mc_filter, lp->mc_filter, sizeof(mc_filter))) {
 863                 int i;
 864                 int saved_bank = inw(ioaddr + CONFIG_0);
 865                 /* Switch to bank 1 and set the multicast table. */
 866                 outw((saved_bank & ~0x0C00) | 0x0480, ioaddr + CONFIG_0);
 867                 for (i = 0; i < 8; i++)
 868                         outb(mc_filter[i], ioaddr + PORT_OFFSET(8 + i));
 869                 memcpy(lp->mc_filter, mc_filter, sizeof(mc_filter));
 870                 outw(saved_bank, ioaddr + CONFIG_0);
 871         }
 872         spin_unlock_irqrestore (&lp->lock, flags);
 873         return;
 874 }
 875
 876 #ifdef MODULE
 877 static struct net_device *dev_at1700;
 878
 879 module_param(io, int, 0);
 880 module_param(irq, int, 0);
 881 module_param(net_debug, int, 0);
 882 MODULE_PARM_DESC(io, "AT1700/FMV18X I/O base address");
 883 MODULE_PARM_DESC(irq, "AT1700/FMV18X IRQ number");
 884 MODULE_PARM_DESC(net_debug, "AT1700/FMV18X debug level (0-6)");
 885
 886 static int __init at1700_module_init(void)
 887 {
 888         if (io == 0)
 889                 printk("at1700: You should not use auto-probing with insmod!\n");
 890         dev_at1700 = at1700_probe(-1);
 891         if (IS_ERR(dev_at1700))
 892                 return PTR_ERR(dev_at1700);
 893         return 0;
 894 }
 895
 896 static void __exit at1700_module_exit(void)
 897 {
 898         unregister_netdev(dev_at1700);
 899         cleanup_card(dev_at1700);
 900         free_netdev(dev_at1700);
 901 }
 902 module_init(at1700_module_init);
 903 module_exit(at1700_module_exit);
 904 #endif /* MODULE */
 905 MODULE_LICENSE("GPL");