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