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 ("  AT1700 at %#3x is unusable due to a conflict on"
 469                                 "IRQ %d.\n", ioaddr, irq);
 470                 goto err_mca;
 471         }
 472
 473         return 0;
 474
 475 err_mca:
 476 #ifdef CONFIG_MCA_LEGACY
 477         if (slot >= 0)
 478                 mca_mark_as_unused(slot);
 479 #endif
 480 err_out:
 481         release_region(ioaddr, AT1700_IO_EXTENT);
 482         return ret;
 483 }
 484
 485
 486 /*  EEPROM_Ctrl bits. */
 487 #define EE_SHIFT_CLK    0x40    /* EEPROM shift clock, in reg. 16. */
 488 #define EE_CS                   0x20    /* EEPROM chip select, in reg. 16. */
 489 #define EE_DATA_WRITE   0x80    /* EEPROM chip data in, in reg. 17. */
 490 #define EE_DATA_READ    0x80    /* EEPROM chip data out, in reg. 17. */
 491
 492 /* The EEPROM commands include the alway-set leading bit. */
 493 #define EE_WRITE_CMD    (5 << 6)
 494 #define EE_READ_CMD             (6 << 6)
 495 #define EE_ERASE_CMD    (7 << 6)
 496
 497 static int __init read_eeprom(long ioaddr, int location)
 498 {
 499         int i;
 500         unsigned short retval = 0;
 501         long ee_addr = ioaddr + EEPROM_Ctrl;
 502         long ee_daddr = ioaddr + EEPROM_Data;
 503         int read_cmd = location | EE_READ_CMD;
 504
 505         /* Shift the read command bits out. */
 506         for (i = 9; i >= 0; i--) {
 507                 short dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
 508                 outb(EE_CS, ee_addr);
 509                 outb(dataval, ee_daddr);
 510                 outb(EE_CS | EE_SHIFT_CLK, ee_addr);    /* EEPROM clock tick. */
 511         }
 512         outb(EE_DATA_WRITE, ee_daddr);
 513         for (i = 16; i > 0; i--) {
 514                 outb(EE_CS, ee_addr);
 515                 outb(EE_CS | EE_SHIFT_CLK, ee_addr);
 516                 retval = (retval << 1) | ((inb(ee_daddr) & EE_DATA_READ) ? 1 : 0);
 517         }
 518
 519         /* Terminate the EEPROM access. */
 520         outb(EE_CS, ee_addr);
 521         outb(EE_SHIFT_CLK, ee_addr);
 522         outb(0, ee_addr);
 523         return retval;
 524 }
 525
 526
 527
 528 static int net_open(struct net_device *dev)
 529 {
 530         struct net_local *lp = netdev_priv(dev);
 531         int ioaddr = dev->base_addr;
 532
 533         /* Set the configuration register 0 to 32K 100ns. byte-wide memory, 16 bit
 534            bus access, and two 4K Tx queues. */
 535         outb(0x5a, ioaddr + CONFIG_0);
 536
 537         /* Powerup, switch to register bank 2, and enable the Rx and Tx. */
 538         outb(0xe8, ioaddr + CONFIG_1);
 539
 540         lp->tx_started = 0;
 541         lp->tx_queue_ready = 1;
 542         lp->rx_started = 0;
 543         lp->tx_queue = 0;
 544         lp->tx_queue_len = 0;
 545
 546         /* Turn on hardware Tx and Rx interrupts. */
 547         outb(0x82, ioaddr + TX_INTR);
 548         outb(0x81, ioaddr + RX_INTR);
 549
 550         /* Enable the IRQ on boards of fmv18x it is feasible. */
 551         if (lp->jumpered) {
 552                 outb(0x80, ioaddr + IOCONFIG1);
 553         }
 554
 555         netif_start_queue(dev);
 556         return 0;
 557 }
 558
 559 static void net_tx_timeout (struct net_device *dev)
 560 {
 561         struct net_local *lp = netdev_priv(dev);
 562         int ioaddr = dev->base_addr;
 563
 564         printk ("%s: transmit timed out with status %04x, %s?\n", dev->name,
 565                 inw (ioaddr + STATUS), inb (ioaddr + TX_STATUS) & 0x80
 566                 ? "IRQ conflict" : "network cable problem");
 567         printk ("%s: timeout registers: %04x %04x %04x %04x %04x %04x %04x %04x.\n",
 568          dev->name, inw(ioaddr + TX_STATUS), inw(ioaddr + TX_INTR), inw(ioaddr + TX_MODE),
 569                 inw(ioaddr + CONFIG_0), inw(ioaddr + DATAPORT), inw(ioaddr + TX_START),
 570                 inw(ioaddr + MODE13 - 1), inw(ioaddr + RX_CTRL));
 571         dev->stats.tx_errors++;
 572         /* ToDo: We should try to restart the adaptor... */
 573         outw(0xffff, ioaddr + MODE24);
 574         outw (0xffff, ioaddr + TX_STATUS);
 575         outb (0x5a, ioaddr + CONFIG_0);
 576         outb (0xe8, ioaddr + CONFIG_1);
 577         outw (0x8182, ioaddr + TX_INTR);
 578         outb (0x00, ioaddr + TX_START);
 579         outb (0x03, ioaddr + COL16CNTL);
 580
 581         dev->trans_start = jiffies;
 582
 583         lp->tx_started = 0;
 584         lp->tx_queue_ready = 1;
 585         lp->rx_started = 0;
 586         lp->tx_queue = 0;
 587         lp->tx_queue_len = 0;
 588
 589         netif_wake_queue(dev);
 590 }
 591
 592
 593 static int net_send_packet (struct sk_buff *skb, struct net_device *dev)
 594 {
 595         struct net_local *lp = netdev_priv(dev);
 596         int ioaddr = dev->base_addr;
 597         short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
 598         short len = skb->len;
 599         unsigned char *buf = skb->data;
 600         static u8 pad[ETH_ZLEN];
 601
 602         netif_stop_queue (dev);
 603
 604         /* We may not start transmitting unless we finish transferring
 605            a packet into the Tx queue. During executing the following
 606            codes we possibly catch a Tx interrupt. Thus we flag off
 607            tx_queue_ready, so that we prevent the interrupt routine
 608            (net_interrupt) to start transmitting. */
 609         lp->tx_queue_ready = 0;
 610         {
 611                 outw (length, ioaddr + DATAPORT);
 612                 /* Packet data */
 613                 outsw (ioaddr + DATAPORT, buf, len >> 1);
 614                 /* Check for dribble byte */
 615                 if (len & 1) {
 616                         outw(skb->data[skb->len-1], ioaddr + DATAPORT);
 617                         len++;
 618                 }
 619                 /* Check for packet padding */
 620                 if (length != skb->len)
 621                         outsw(ioaddr + DATAPORT, pad, (length - len + 1) >> 1);
 622
 623                 lp->tx_queue++;
 624                 lp->tx_queue_len += length + 2;
 625         }
 626         lp->tx_queue_ready = 1;
 627
 628         if (lp->tx_started == 0) {
 629                 /* If the Tx is idle, always trigger a transmit. */
 630                 outb (0x80 | lp->tx_queue, ioaddr + TX_START);
 631                 lp->tx_queue = 0;
 632                 lp->tx_queue_len = 0;
 633                 dev->trans_start = jiffies;
 634                 lp->tx_started = 1;
 635                 netif_start_queue (dev);
 636         } else if (lp->tx_queue_len < 4096 - 1502)
 637                 /* Yes, there is room for one more packet. */
 638                 netif_start_queue (dev);
 639         dev_kfree_skb (skb);
 640
 641         return 0;
 642 }
 643
 644 /* The typical workload of the driver:
 645    Handle the network interface interrupts. */
 646 static irqreturn_t net_interrupt(int irq, void *dev_id)
 647 {
 648         struct net_device *dev = dev_id;
 649         struct net_local *lp;
 650         int ioaddr, status;
 651         int handled = 0;
 652
 653         if (dev == NULL) {
 654                 printk ("at1700_interrupt(): irq %d for unknown device.\n", irq);
 655                 return IRQ_NONE;
 656         }
 657
 658         ioaddr = dev->base_addr;
 659         lp = netdev_priv(dev);
 660
 661         spin_lock (&lp->lock);
 662
 663         status = inw(ioaddr + TX_STATUS);
 664         outw(status, ioaddr + TX_STATUS);
 665
 666         if (net_debug > 4)
 667                 printk("%s: Interrupt with status %04x.\n", dev->name, status);
 668         if (lp->rx_started == 0 &&
 669             (status & 0xff00 || (inb(ioaddr + RX_MODE) & 0x40) == 0)) {
 670                 /* Got a packet(s).
 671                    We cannot execute net_rx more than once at the same time for
 672                    the same device. During executing net_rx, we possibly catch a
 673                    Tx interrupt. Thus we flag on rx_started, so that we prevent
 674                    the interrupt routine (net_interrupt) to dive into net_rx
 675                    again. */
 676                 handled = 1;
 677                 lp->rx_started = 1;
 678                 outb(0x00, ioaddr + RX_INTR);   /* Disable RX intr. */
 679                 net_rx(dev);
 680                 outb(0x81, ioaddr + RX_INTR);   /* Enable  RX intr. */
 681                 lp->rx_started = 0;
 682         }
 683         if (status & 0x00ff) {
 684                 handled = 1;
 685                 if (status & 0x02) {
 686                         /* More than 16 collisions occurred */
 687                         if (net_debug > 4)
 688                                 printk("%s: 16 Collision occur during Txing.\n", dev->name);
 689                         /* Cancel sending a packet. */
 690                         outb(0x03, ioaddr + COL16CNTL);
 691                         dev->stats.collisions++;
 692                 }
 693                 if (status & 0x82) {
 694                         dev->stats.tx_packets++;
 695                         /* The Tx queue has any packets and is not being
 696                            transferred a packet from the host, start
 697                            transmitting. */
 698                         if (lp->tx_queue && lp->tx_queue_ready) {
 699                                 outb(0x80 | lp->tx_queue, ioaddr + TX_START);
 700                                 lp->tx_queue = 0;
 701                                 lp->tx_queue_len = 0;
 702                                 dev->trans_start = jiffies;
 703                                 netif_wake_queue (dev);
 704                         } else {
 705                                 lp->tx_started = 0;
 706                                 netif_wake_queue (dev);
 707                         }
 708                 }
 709         }
 710
 711         spin_unlock (&lp->lock);
 712         return IRQ_RETVAL(handled);
 713 }
 714
 715 /* We have a good packet(s), get it/them out of the buffers. */
 716 static void
 717 net_rx(struct net_device *dev)
 718 {
 719         int ioaddr = dev->base_addr;
 720         int boguscount = 5;
 721
 722         while ((inb(ioaddr + RX_MODE) & 0x40) == 0) {
 723                 ushort status = inw(ioaddr + DATAPORT);
 724                 ushort pkt_len = inw(ioaddr + DATAPORT);
 725
 726                 if (net_debug > 4)
 727                         printk("%s: Rxing packet mode %02x status %04x.\n",
 728                                    dev->name, inb(ioaddr + RX_MODE), status);
 729 #ifndef final_version
 730                 if (status == 0) {
 731                         outb(0x05, ioaddr + RX_CTRL);
 732                         break;
 733                 }
 734 #endif
 735
 736                 if ((status & 0xF0) != 0x20) {  /* There was an error. */
 737                         dev->stats.rx_errors++;
 738                         if (status & 0x08) dev->stats.rx_length_errors++;
 739                         if (status & 0x04) dev->stats.rx_frame_errors++;
 740                         if (status & 0x02) dev->stats.rx_crc_errors++;
 741                         if (status & 0x01) dev->stats.rx_over_errors++;
 742                 } else {
 743                         /* Malloc up new buffer. */
 744                         struct sk_buff *skb;
 745
 746                         if (pkt_len > 1550) {
 747                                 printk("%s: The AT1700 claimed a very large packet, size %d.\n",
 748                                            dev->name, pkt_len);
 749                                 /* Prime the FIFO and then flush the packet. */
 750                                 inw(ioaddr + DATAPORT); inw(ioaddr + DATAPORT);
 751                                 outb(0x05, ioaddr + RX_CTRL);
 752                                 dev->stats.rx_errors++;
 753                                 break;
 754                         }
 755                         skb = dev_alloc_skb(pkt_len+3);
 756                         if (skb == NULL) {
 757                                 printk("%s: Memory squeeze, dropping packet (len %d).\n",
 758                                            dev->name, pkt_len);
 759                                 /* Prime the FIFO and then flush the packet. */
 760                                 inw(ioaddr + DATAPORT); inw(ioaddr + DATAPORT);
 761                                 outb(0x05, ioaddr + RX_CTRL);
 762                                 dev->stats.rx_dropped++;
 763                                 break;
 764                         }
 765                         skb_reserve(skb,2);
 766
 767                         insw(ioaddr + DATAPORT, skb_put(skb,pkt_len), (pkt_len + 1) >> 1);
 768                         skb->protocol=eth_type_trans(skb, dev);
 769                         netif_rx(skb);
 770                         dev->last_rx = jiffies;
 771                         dev->stats.rx_packets++;
 772                         dev->stats.rx_bytes += pkt_len;
 773                 }
 774                 if (--boguscount <= 0)
 775                         break;
 776         }
 777
 778         /* If any worth-while packets have been received, dev_rint()
 779            has done a mark_bh(NET_BH) for us and will work on them
 780            when we get to the bottom-half routine. */
 781         {
 782                 int i;
 783                 for (i = 0; i < 20; i++) {
 784                         if ((inb(ioaddr + RX_MODE) & 0x40) == 0x40)
 785                                 break;
 786                         inw(ioaddr + DATAPORT);                         /* dummy status read */
 787                         outb(0x05, ioaddr + RX_CTRL);
 788                 }
 789
 790                 if (net_debug > 5)
 791                         printk("%s: Exint Rx packet with mode %02x after %d ticks.\n",
 792                                    dev->name, inb(ioaddr + RX_MODE), i);
 793         }
 794         return;
 795 }
 796
 797 /* The inverse routine to net_open(). */
 798 static int net_close(struct net_device *dev)
 799 {
 800         struct net_local *lp = netdev_priv(dev);
 801         int ioaddr = dev->base_addr;
 802
 803         netif_stop_queue(dev);
 804
 805         /* Set configuration register 0 to disable Tx and Rx. */
 806         outb(0xda, ioaddr + CONFIG_0);
 807
 808         /* No statistic counters on the chip to update. */
 809
 810         /* Disable the IRQ on boards of fmv18x where it is feasible. */
 811         if (lp->jumpered) {
 812                 outb(0x00, ioaddr + IOCONFIG1);
 813                 free_irq(dev->irq, dev);
 814         }
 815
 816         /* Power-down the chip.  Green, green, green! */
 817         outb(0x00, ioaddr + CONFIG_1);
 818         return 0;
 819 }
 820
 821 /*
 822   Set the multicast/promiscuous mode for this adaptor.
 823 */
 824
 825 static void
 826 set_rx_mode(struct net_device *dev)
 827 {
 828         int ioaddr = dev->base_addr;
 829         struct net_local *lp = netdev_priv(dev);
 830         unsigned char mc_filter[8];              /* Multicast hash filter */
 831         unsigned long flags;
 832         int i;
 833
 834         if (dev->flags & IFF_PROMISC) {
 835                 memset(mc_filter, 0xff, sizeof(mc_filter));
 836                 outb(3, ioaddr + RX_MODE);      /* Enable promiscuous mode */
 837         } else if (dev->mc_count > MC_FILTERBREAK
 838                            ||  (dev->flags & IFF_ALLMULTI)) {
 839                 /* Too many to filter perfectly -- accept all multicasts. */
 840                 memset(mc_filter, 0xff, sizeof(mc_filter));
 841                 outb(2, ioaddr + RX_MODE);      /* Use normal mode. */
 842         } else if (dev->mc_count == 0) {
 843                 memset(mc_filter, 0x00, sizeof(mc_filter));
 844                 outb(1, ioaddr + RX_MODE);      /* Ignore almost all multicasts. */
 845         } else {
 846                 struct dev_mc_list *mclist;
 847                 int i;
 848
 849                 memset(mc_filter, 0, sizeof(mc_filter));
 850                 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
 851                          i++, mclist = mclist->next) {
 852                         unsigned int bit =
 853                                 ether_crc_le(ETH_ALEN, mclist->dmi_addr) >> 26;
 854                         mc_filter[bit >> 3] |= (1 << bit);
 855                 }
 856                 outb(0x02, ioaddr + RX_MODE);   /* Use normal mode. */
 857         }
 858
 859         spin_lock_irqsave (&lp->lock, flags);
 860         if (memcmp(mc_filter, lp->mc_filter, sizeof(mc_filter))) {
 861                 int saved_bank = inw(ioaddr + CONFIG_0);
 862                 /* Switch to bank 1 and set the multicast table. */
 863                 outw((saved_bank & ~0x0C00) | 0x0480, ioaddr + CONFIG_0);
 864                 for (i = 0; i < 8; i++)
 865                         outb(mc_filter[i], ioaddr + PORT_OFFSET(8 + i));
 866                 memcpy(lp->mc_filter, mc_filter, sizeof(mc_filter));
 867                 outw(saved_bank, ioaddr + CONFIG_0);
 868         }
 869         spin_unlock_irqrestore (&lp->lock, flags);
 870         return;
 871 }
 872
 873 #ifdef MODULE
 874 static struct net_device *dev_at1700;
 875
 876 module_param(io, int, 0);
 877 module_param(irq, int, 0);
 878 module_param(net_debug, int, 0);
 879 MODULE_PARM_DESC(io, "AT1700/FMV18X I/O base address");
 880 MODULE_PARM_DESC(irq, "AT1700/FMV18X IRQ number");
 881 MODULE_PARM_DESC(net_debug, "AT1700/FMV18X debug level (0-6)");
 882
 883 int __init init_module(void)
 884 {
 885         if (io == 0)
 886                 printk("at1700: You should not use auto-probing with insmod!\n");
 887         dev_at1700 = at1700_probe(-1);
 888         if (IS_ERR(dev_at1700))
 889                 return PTR_ERR(dev_at1700);
 890         return 0;
 891 }
 892
 893 void __exit
 894 cleanup_module(void)
 895 {
 896         unregister_netdev(dev_at1700);
 897         cleanup_card(dev_at1700);
 898         free_netdev(dev_at1700);
 899 }
 900 #endif /* MODULE */
 901 MODULE_LICENSE("GPL");
 902
 903
 904 /*
 905  * Local variables:
 906  *  compile-command: "gcc -DMODULE -D__KERNEL__ -Wall -Wstrict-prototypes -O6 -c at1700.c"
 907  *  alt-compile-command: "gcc -DMODVERSIONS -DMODULE -D__KERNEL__ -Wall -Wstrict-prototypes -O6 -c at1700.c"
 908  *  tab-width: 4
 909  *  c-basic-offset: 4
 910  *  c-indent-level: 4
 911  * End:
 912  */
 913