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

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