drivers/net/ethernet/fujitsu/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 (now deleted) 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/module.h>
  42 #include <linux/kernel.h>
  43 #include <linux/types.h>
  44 #include <linux/fcntl.h>
  45 #include <linux/interrupt.h>
  46 #include <linux/ioport.h>
  47 #include <linux/in.h>
  48 #include <linux/skbuff.h>
  49 #include <linux/string.h>
  50 #include <linux/init.h>
  51 #include <linux/crc32.h>
  52 #include <linux/bitops.h>
  53
  54 #include <asm/io.h>
  55 #include <asm/dma.h>
  56
  57 static char version[] __initdata =
  58         "at1700.c:v1.16 9/11/06  Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";
  59
  60 #define DRV_NAME "at1700"
  61
  62 /* Tunable parameters. */
  63
  64 /* When to switch from the 64-entry multicast filter to Rx-all-multicast. */
  65 #define MC_FILTERBREAK 64
  66
  67 /* These unusual address orders are used to verify the CONFIG register. */
  68
  69 static int fmv18x_probe_list[] __initdata = {
  70         0x220, 0x240, 0x260, 0x280, 0x2a0, 0x2c0, 0x300, 0x340, 0
  71 };
  72
  73 /*
  74  *      ISA
  75  */
  76
  77 static unsigned at1700_probe_list[] __initdata = {
  78         0x260, 0x280, 0x2a0, 0x240, 0x340, 0x320, 0x380, 0x300, 0
  79 };
  80
  81 /* use 0 for production, 1 for verification, >2 for debug */
  82 #ifndef NET_DEBUG
  83 #define NET_DEBUG 1
  84 #endif
  85 static unsigned int net_debug = NET_DEBUG;
  86
  87 typedef unsigned char uchar;
  88
  89 /* Information that need to be kept for each board. */
  90 struct net_local {
  91         spinlock_t lock;
  92         unsigned char mc_filter[8];
  93         uint jumpered:1;                        /* Set iff the board has jumper config. */
  94         uint tx_started:1;                      /* Packets are on the Tx queue. */
  95         uint tx_queue_ready:1;                  /* Tx queue is ready to be sent. */
  96         uint rx_started:1;                      /* Packets are Rxing. */
  97         uchar tx_queue;                         /* Number of packet on the Tx queue. */
  98         ushort tx_queue_len;                    /* Current length of the Tx queue. */
  99 };
 100
 101
 102 /* Offsets from the base address. */
 103 #define STATUS                  0
 104 #define TX_STATUS               0
 105 #define RX_STATUS               1
 106 #define TX_INTR                 2               /* Bit-mapped interrupt enable registers. */
 107 #define RX_INTR                 3
 108 #define TX_MODE                 4
 109 #define RX_MODE                 5
 110 #define CONFIG_0                6               /* Misc. configuration settings. */
 111 #define CONFIG_1                7
 112 /* Run-time register bank 2 definitions. */
 113 #define DATAPORT                8               /* Word-wide DMA or programmed-I/O dataport. */
 114 #define TX_START                10
 115 #define COL16CNTL               11              /* Control Reg for 16 collisions */
 116 #define MODE13                  13
 117 #define RX_CTRL                 14
 118 /* Configuration registers only on the '865A/B chips. */
 119 #define EEPROM_Ctrl     16
 120 #define EEPROM_Data     17
 121 #define CARDSTATUS      16                      /* FMV-18x Card Status */
 122 #define CARDSTATUS1     17                      /* FMV-18x Card Status */
 123 #define IOCONFIG                18              /* Either read the jumper, or move the I/O. */
 124 #define IOCONFIG1               19
 125 #define SAPROM                  20              /* The station address PROM, if no EEPROM. */
 126 #define MODE24                  24
 127 #define RESET                   31              /* Write to reset some parts of the chip. */
 128 #define AT1700_IO_EXTENT        32
 129 #define PORT_OFFSET(o) (o)
 130
 131
 132 #define TX_TIMEOUT              (HZ/10)
 133
 134
 135 /* Index to functions, as function prototypes. */
 136
 137 static int at1700_probe1(struct net_device *dev, int ioaddr);
 138 static int read_eeprom(long ioaddr, int location);
 139 static int net_open(struct net_device *dev);
 140 static netdev_tx_t net_send_packet(struct sk_buff *skb,
 141                                    struct net_device *dev);
 142 static irqreturn_t net_interrupt(int irq, void *dev_id);
 143 static void net_rx(struct net_device *dev);
 144 static int net_close(struct net_device *dev);
 145 static void set_rx_mode(struct net_device *dev);
 146 static void net_tx_timeout (struct net_device *dev);
 147
 148
 149 /* Check for a network adaptor of this type, and return '0' iff one exists.
 150    If dev->base_addr == 0, probe all likely locations.
 151    If dev->base_addr == 1, always return failure.
 152    If dev->base_addr == 2, allocate space for the device and return success
 153    (detachable devices only).
 154    */
 155
 156 static int io = 0x260;
 157
 158 static int irq;
 159
 160 static void cleanup_card(struct net_device *dev)
 161 {
 162         free_irq(dev->irq, NULL);
 163         release_region(dev->base_addr, AT1700_IO_EXTENT);
 164 }
 165
 166 struct net_device * __init at1700_probe(int unit)
 167 {
 168         struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
 169         unsigned *port;
 170         int err = 0;
 171
 172         if (!dev)
 173                 return ERR_PTR(-ENODEV);
 174
 175         if (unit >= 0) {
 176                 sprintf(dev->name, "eth%d", unit);
 177                 netdev_boot_setup_check(dev);
 178                 io = dev->base_addr;
 179                 irq = dev->irq;
 180         } else {
 181                 dev->base_addr = io;
 182                 dev->irq = irq;
 183         }
 184
 185         if (io > 0x1ff) {       /* Check a single specified location. */
 186                 err = at1700_probe1(dev, io);
 187         } else if (io != 0) {   /* Don't probe at all. */
 188                 err = -ENXIO;
 189         } else {
 190                 for (port = at1700_probe_list; *port; port++) {
 191                         if (at1700_probe1(dev, *port) == 0)
 192                                 break;
 193                         dev->irq = irq;
 194                 }
 195                 if (!*port)
 196                         err = -ENODEV;
 197         }
 198         if (err)
 199                 goto out;
 200         err = register_netdev(dev);
 201         if (err)
 202                 goto out1;
 203         return dev;
 204 out1:
 205         cleanup_card(dev);
 206 out:
 207         free_netdev(dev);
 208         return ERR_PTR(err);
 209 }
 210
 211 static const struct net_device_ops at1700_netdev_ops = {
 212         .ndo_open               = net_open,
 213         .ndo_stop               = net_close,
 214         .ndo_start_xmit         = net_send_packet,
 215         .ndo_set_rx_mode        = set_rx_mode,
 216         .ndo_tx_timeout         = net_tx_timeout,
 217         .ndo_change_mtu         = eth_change_mtu,
 218         .ndo_set_mac_address    = eth_mac_addr,
 219         .ndo_validate_addr      = eth_validate_addr,
 220 };
 221
 222 /* The Fujitsu datasheet suggests that the NIC be probed for by checking its
 223    "signature", the default bit pattern after a reset.  This *doesn't* work --
 224    there is no way to reset the bus interface without a complete power-cycle!
 225
 226    It turns out that ATI came to the same conclusion I did: the only thing
 227    that can be done is checking a few bits and then diving right into an
 228    EEPROM read. */
 229
 230 static int __init at1700_probe1(struct net_device *dev, int ioaddr)
 231 {
 232         static const char fmv_irqmap[4] = {3, 7, 10, 15};
 233         static const char fmv_irqmap_pnp[8] = {3, 4, 5, 7, 9, 10, 11, 15};
 234         static const char at1700_irqmap[8] = {3, 4, 5, 9, 10, 11, 14, 15};
 235         unsigned int i, irq, is_fmv18x = 0, is_at1700 = 0;
 236         int ret = -ENODEV;
 237         struct net_local *lp = netdev_priv(dev);
 238
 239         if (!request_region(ioaddr, AT1700_IO_EXTENT, DRV_NAME))
 240                 return -EBUSY;
 241
 242         /* Resetting the chip doesn't reset the ISA interface, so don't bother.
 243            That means we have to be careful with the register values we probe
 244            for.
 245          */
 246 #ifdef notdef
 247         printk("at1700 probe at %#x, eeprom is %4.4x %4.4x %4.4x ctrl %4.4x.\n",
 248                    ioaddr, read_eeprom(ioaddr, 4), read_eeprom(ioaddr, 5),
 249                    read_eeprom(ioaddr, 6), inw(ioaddr + EEPROM_Ctrl));
 250 #endif
 251         /* We must check for the EEPROM-config boards first, else accessing
 252            IOCONFIG0 will move the board! */
 253         if (at1700_probe_list[inb(ioaddr + IOCONFIG1) & 0x07] == ioaddr &&
 254             read_eeprom(ioaddr, 4) == 0x0000 &&
 255             (read_eeprom(ioaddr, 5) & 0xff00) == 0xF400)
 256                 is_at1700 = 1;
 257         else if (inb(ioaddr + SAPROM    ) == 0x00 &&
 258                  inb(ioaddr + SAPROM + 1) == 0x00 &&
 259                  inb(ioaddr + SAPROM + 2) == 0x0e)
 260                 is_fmv18x = 1;
 261         else {
 262                 goto err_out;
 263         }
 264
 265         /* Reset the internal state machines. */
 266         outb(0, ioaddr + RESET);
 267
 268         if (is_at1700) {
 269                 irq = at1700_irqmap[(read_eeprom(ioaddr, 12)&0x04)
 270                                                    | (read_eeprom(ioaddr, 0)>>14)];
 271         } else {
 272                 /* Check PnP mode for FMV-183/184/183A/184A. */
 273                 /* This PnP routine is very poor. IO and IRQ should be known. */
 274                 if (inb(ioaddr + CARDSTATUS1) & 0x20) {
 275                         irq = dev->irq;
 276                         for (i = 0; i < 8; i++) {
 277                                 if (irq == fmv_irqmap_pnp[i])
 278                                         break;
 279                         }
 280                         if (i == 8) {
 281                                 goto err_out;
 282                         }
 283                 } else {
 284                         if (fmv18x_probe_list[inb(ioaddr + IOCONFIG) & 0x07] != ioaddr)
 285                                 goto err_out;
 286                         irq = fmv_irqmap[(inb(ioaddr + IOCONFIG)>>6) & 0x03];
 287                 }
 288         }
 289
 290         printk("%s: %s found at %#3x, IRQ %d, address ", dev->name,
 291                    is_at1700 ? "AT1700" : "FMV-18X", ioaddr, irq);
 292
 293         dev->base_addr = ioaddr;
 294         dev->irq = irq;
 295
 296         if (is_at1700) {
 297                 for(i = 0; i < 3; i++) {
 298                         unsigned short eeprom_val = read_eeprom(ioaddr, 4+i);
 299                         ((unsigned short *)dev->dev_addr)[i] = ntohs(eeprom_val);
 300                 }
 301         } else {
 302                 for(i = 0; i < 6; i++) {
 303                         unsigned char val = inb(ioaddr + SAPROM + i);
 304                         dev->dev_addr[i] = val;
 305                 }
 306         }
 307         printk("%pM", dev->dev_addr);
 308
 309         /* The EEPROM word 12 bit 0x0400 means use regular 100 ohm 10baseT signals,
 310            rather than 150 ohm shielded twisted pair compensation.
 311            0x0000 == auto-sense the interface
 312            0x0800 == use TP interface
 313            0x1800 == use coax interface
 314            */
 315         {
 316                 const char *porttype[] = {"auto-sense", "10baseT", "auto-sense", "10base2"};
 317                 if (is_at1700) {
 318                         ushort setup_value = read_eeprom(ioaddr, 12);
 319                         dev->if_port = setup_value >> 8;
 320                 } else {
 321                         ushort setup_value = inb(ioaddr + CARDSTATUS);
 322                         switch (setup_value & 0x07) {
 323                         case 0x01: /* 10base5 */
 324                         case 0x02: /* 10base2 */
 325                                 dev->if_port = 0x18; break;
 326                         case 0x04: /* 10baseT */
 327                                 dev->if_port = 0x08; break;
 328                         default:   /* auto-sense */
 329                                 dev->if_port = 0x00; break;
 330                         }
 331                 }
 332                 printk(" %s interface.\n", porttype[(dev->if_port>>3) & 3]);
 333         }
 334
 335         /* Set the configuration register 0 to 32K 100ns. byte-wide memory, 16 bit
 336            bus access, two 4K Tx queues, and disabled Tx and Rx. */
 337         outb(0xda, ioaddr + CONFIG_0);
 338
 339         /* Set the station address in bank zero. */
 340         outb(0x00, ioaddr + CONFIG_1);
 341         for (i = 0; i < 6; i++)
 342                 outb(dev->dev_addr[i], ioaddr + PORT_OFFSET(8 + i));
 343
 344         /* Switch to bank 1 and set the multicast table to accept none. */
 345         outb(0x04, ioaddr + CONFIG_1);
 346         for (i = 0; i < 8; i++)
 347                 outb(0x00, ioaddr + PORT_OFFSET(8 + i));
 348
 349
 350         /* Switch to bank 2 */
 351         /* Lock our I/O address, and set manual processing mode for 16 collisions. */
 352         outb(0x08, ioaddr + CONFIG_1);
 353         outb(dev->if_port, ioaddr + MODE13);
 354         outb(0x00, ioaddr + COL16CNTL);
 355
 356         if (net_debug)
 357                 printk(version);
 358
 359         dev->netdev_ops = &at1700_netdev_ops;
 360         dev->watchdog_timeo = TX_TIMEOUT;
 361
 362         spin_lock_init(&lp->lock);
 363
 364         lp->jumpered = is_fmv18x;
 365         /* Snarf the interrupt vector now. */
 366         ret = request_irq(irq, net_interrupt, 0, DRV_NAME, dev);
 367         if (ret) {
 368                 printk(KERN_ERR "AT1700 at %#3x is unusable due to a "
 369                        "conflict on IRQ %d.\n",
 370                        ioaddr, irq);
 371                 goto err_out;
 372         }
 373
 374         return 0;
 375
 376 err_out:
 377         release_region(ioaddr, AT1700_IO_EXTENT);
 378         return ret;
 379 }
 380
 381
 382 /*  EEPROM_Ctrl bits. */
 383 #define EE_SHIFT_CLK    0x40    /* EEPROM shift clock, in reg. 16. */
 384 #define EE_CS                   0x20    /* EEPROM chip select, in reg. 16. */
 385 #define EE_DATA_WRITE   0x80    /* EEPROM chip data in, in reg. 17. */
 386 #define EE_DATA_READ    0x80    /* EEPROM chip data out, in reg. 17. */
 387
 388 /* The EEPROM commands include the alway-set leading bit. */
 389 #define EE_WRITE_CMD    (5 << 6)
 390 #define EE_READ_CMD             (6 << 6)
 391 #define EE_ERASE_CMD    (7 << 6)
 392
 393 static int __init read_eeprom(long ioaddr, int location)
 394 {
 395         int i;
 396         unsigned short retval = 0;
 397         long ee_addr = ioaddr + EEPROM_Ctrl;
 398         long ee_daddr = ioaddr + EEPROM_Data;
 399         int read_cmd = location | EE_READ_CMD;
 400
 401         /* Shift the read command bits out. */
 402         for (i = 9; i >= 0; i--) {
 403                 short dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
 404                 outb(EE_CS, ee_addr);
 405                 outb(dataval, ee_daddr);
 406                 outb(EE_CS | EE_SHIFT_CLK, ee_addr);    /* EEPROM clock tick. */
 407         }
 408         outb(EE_DATA_WRITE, ee_daddr);
 409         for (i = 16; i > 0; i--) {
 410                 outb(EE_CS, ee_addr);
 411                 outb(EE_CS | EE_SHIFT_CLK, ee_addr);
 412                 retval = (retval << 1) | ((inb(ee_daddr) & EE_DATA_READ) ? 1 : 0);
 413         }
 414
 415         /* Terminate the EEPROM access. */
 416         outb(EE_CS, ee_addr);
 417         outb(EE_SHIFT_CLK, ee_addr);
 418         outb(0, ee_addr);
 419         return retval;
 420 }
 421
 422
 423
 424 static int net_open(struct net_device *dev)
 425 {
 426         struct net_local *lp = netdev_priv(dev);
 427         int ioaddr = dev->base_addr;
 428
 429         /* Set the configuration register 0 to 32K 100ns. byte-wide memory, 16 bit
 430            bus access, and two 4K Tx queues. */
 431         outb(0x5a, ioaddr + CONFIG_0);
 432
 433         /* Powerup, switch to register bank 2, and enable the Rx and Tx. */
 434         outb(0xe8, ioaddr + CONFIG_1);
 435
 436         lp->tx_started = 0;
 437         lp->tx_queue_ready = 1;
 438         lp->rx_started = 0;
 439         lp->tx_queue = 0;
 440         lp->tx_queue_len = 0;
 441
 442         /* Turn on hardware Tx and Rx interrupts. */
 443         outb(0x82, ioaddr + TX_INTR);
 444         outb(0x81, ioaddr + RX_INTR);
 445
 446         /* Enable the IRQ on boards of fmv18x it is feasible. */
 447         if (lp->jumpered) {
 448                 outb(0x80, ioaddr + IOCONFIG1);
 449         }
 450
 451         netif_start_queue(dev);
 452         return 0;
 453 }
 454
 455 static void net_tx_timeout (struct net_device *dev)
 456 {
 457         struct net_local *lp = netdev_priv(dev);
 458         int ioaddr = dev->base_addr;
 459
 460         printk ("%s: transmit timed out with status %04x, %s?\n", dev->name,
 461                 inw (ioaddr + STATUS), inb (ioaddr + TX_STATUS) & 0x80
 462                 ? "IRQ conflict" : "network cable problem");
 463         printk ("%s: timeout registers: %04x %04x %04x %04x %04x %04x %04x %04x.\n",
 464          dev->name, inw(ioaddr + TX_STATUS), inw(ioaddr + TX_INTR), inw(ioaddr + TX_MODE),
 465                 inw(ioaddr + CONFIG_0), inw(ioaddr + DATAPORT), inw(ioaddr + TX_START),
 466                 inw(ioaddr + MODE13 - 1), inw(ioaddr + RX_CTRL));
 467         dev->stats.tx_errors++;
 468         /* ToDo: We should try to restart the adaptor... */
 469         outw(0xffff, ioaddr + MODE24);
 470         outw (0xffff, ioaddr + TX_STATUS);
 471         outb (0x5a, ioaddr + CONFIG_0);
 472         outb (0xe8, ioaddr + CONFIG_1);
 473         outw (0x8182, ioaddr + TX_INTR);
 474         outb (0x00, ioaddr + TX_START);
 475         outb (0x03, ioaddr + COL16CNTL);
 476
 477         dev->trans_start = jiffies; /* prevent tx timeout */
 478
 479         lp->tx_started = 0;
 480         lp->tx_queue_ready = 1;
 481         lp->rx_started = 0;
 482         lp->tx_queue = 0;
 483         lp->tx_queue_len = 0;
 484
 485         netif_wake_queue(dev);
 486 }
 487
 488
 489 static netdev_tx_t net_send_packet (struct sk_buff *skb,
 490                                     struct net_device *dev)
 491 {
 492         struct net_local *lp = netdev_priv(dev);
 493         int ioaddr = dev->base_addr;
 494         short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
 495         short len = skb->len;
 496         unsigned char *buf = skb->data;
 497         static u8 pad[ETH_ZLEN];
 498
 499         netif_stop_queue (dev);
 500
 501         /* We may not start transmitting unless we finish transferring
 502            a packet into the Tx queue. During executing the following
 503            codes we possibly catch a Tx interrupt. Thus we flag off
 504            tx_queue_ready, so that we prevent the interrupt routine
 505            (net_interrupt) to start transmitting. */
 506         lp->tx_queue_ready = 0;
 507         {
 508                 outw (length, ioaddr + DATAPORT);
 509                 /* Packet data */
 510                 outsw (ioaddr + DATAPORT, buf, len >> 1);
 511                 /* Check for dribble byte */
 512                 if (len & 1) {
 513                         outw(skb->data[skb->len-1], ioaddr + DATAPORT);
 514                         len++;
 515                 }
 516                 /* Check for packet padding */
 517                 if (length != skb->len)
 518                         outsw(ioaddr + DATAPORT, pad, (length - len + 1) >> 1);
 519
 520                 lp->tx_queue++;
 521                 lp->tx_queue_len += length + 2;
 522         }
 523         lp->tx_queue_ready = 1;
 524
 525         if (lp->tx_started == 0) {
 526                 /* If the Tx is idle, always trigger a transmit. */
 527                 outb (0x80 | lp->tx_queue, ioaddr + TX_START);
 528                 lp->tx_queue = 0;
 529                 lp->tx_queue_len = 0;
 530                 lp->tx_started = 1;
 531                 netif_start_queue (dev);
 532         } else if (lp->tx_queue_len < 4096 - 1502)
 533                 /* Yes, there is room for one more packet. */
 534                 netif_start_queue (dev);
 535         dev_kfree_skb (skb);
 536
 537         return NETDEV_TX_OK;
 538 }
 539
 540 /* The typical workload of the driver:
 541    Handle the network interface interrupts. */
 542 static irqreturn_t net_interrupt(int irq, void *dev_id)
 543 {
 544         struct net_device *dev = dev_id;
 545         struct net_local *lp;
 546         int ioaddr, status;
 547         int handled = 0;
 548
 549         if (dev == NULL) {
 550                 printk ("at1700_interrupt(): irq %d for unknown device.\n", irq);
 551                 return IRQ_NONE;
 552         }
 553
 554         ioaddr = dev->base_addr;
 555         lp = netdev_priv(dev);
 556
 557         spin_lock (&lp->lock);
 558
 559         status = inw(ioaddr + TX_STATUS);
 560         outw(status, ioaddr + TX_STATUS);
 561
 562         if (net_debug > 4)
 563                 printk("%s: Interrupt with status %04x.\n", dev->name, status);
 564         if (lp->rx_started == 0 &&
 565             (status & 0xff00 || (inb(ioaddr + RX_MODE) & 0x40) == 0)) {
 566                 /* Got a packet(s).
 567                    We cannot execute net_rx more than once at the same time for
 568                    the same device. During executing net_rx, we possibly catch a
 569                    Tx interrupt. Thus we flag on rx_started, so that we prevent
 570                    the interrupt routine (net_interrupt) to dive into net_rx
 571                    again. */
 572                 handled = 1;
 573                 lp->rx_started = 1;
 574                 outb(0x00, ioaddr + RX_INTR);   /* Disable RX intr. */
 575                 net_rx(dev);
 576                 outb(0x81, ioaddr + RX_INTR);   /* Enable  RX intr. */
 577                 lp->rx_started = 0;
 578         }
 579         if (status & 0x00ff) {
 580                 handled = 1;
 581                 if (status & 0x02) {
 582                         /* More than 16 collisions occurred */
 583                         if (net_debug > 4)
 584                                 printk("%s: 16 Collision occur during Txing.\n", dev->name);
 585                         /* Cancel sending a packet. */
 586                         outb(0x03, ioaddr + COL16CNTL);
 587                         dev->stats.collisions++;
 588                 }
 589                 if (status & 0x82) {
 590                         dev->stats.tx_packets++;
 591                         /* The Tx queue has any packets and is not being
 592                            transferred a packet from the host, start
 593                            transmitting. */
 594                         if (lp->tx_queue && lp->tx_queue_ready) {
 595                                 outb(0x80 | lp->tx_queue, ioaddr + TX_START);
 596                                 lp->tx_queue = 0;
 597                                 lp->tx_queue_len = 0;
 598                                 dev->trans_start = jiffies;
 599                                 netif_wake_queue (dev);
 600                         } else {
 601                                 lp->tx_started = 0;
 602                                 netif_wake_queue (dev);
 603                         }
 604                 }
 605         }
 606
 607         spin_unlock (&lp->lock);
 608         return IRQ_RETVAL(handled);
 609 }
 610
 611 /* We have a good packet(s), get it/them out of the buffers. */
 612 static void
 613 net_rx(struct net_device *dev)
 614 {
 615         int ioaddr = dev->base_addr;
 616         int boguscount = 5;
 617
 618         while ((inb(ioaddr + RX_MODE) & 0x40) == 0) {
 619                 ushort status = inw(ioaddr + DATAPORT);
 620                 ushort pkt_len = inw(ioaddr + DATAPORT);
 621
 622                 if (net_debug > 4)
 623                         printk("%s: Rxing packet mode %02x status %04x.\n",
 624                                    dev->name, inb(ioaddr + RX_MODE), status);
 625 #ifndef final_version
 626                 if (status == 0) {
 627                         outb(0x05, ioaddr + RX_CTRL);
 628                         break;
 629                 }
 630 #endif
 631
 632                 if ((status & 0xF0) != 0x20) {  /* There was an error. */
 633                         dev->stats.rx_errors++;
 634                         if (status & 0x08) dev->stats.rx_length_errors++;
 635                         if (status & 0x04) dev->stats.rx_frame_errors++;
 636                         if (status & 0x02) dev->stats.rx_crc_errors++;
 637                         if (status & 0x01) dev->stats.rx_over_errors++;
 638                 } else {
 639                         /* Malloc up new buffer. */
 640                         struct sk_buff *skb;
 641
 642                         if (pkt_len > 1550) {
 643                                 printk("%s: The AT1700 claimed a very large packet, size %d.\n",
 644                                            dev->name, pkt_len);
 645                                 /* Prime the FIFO and then flush the packet. */
 646                                 inw(ioaddr + DATAPORT); inw(ioaddr + DATAPORT);
 647                                 outb(0x05, ioaddr + RX_CTRL);
 648                                 dev->stats.rx_errors++;
 649                                 break;
 650                         }
 651                         skb = netdev_alloc_skb(dev, pkt_len + 3);
 652                         if (skb == NULL) {
 653                                 printk("%s: Memory squeeze, dropping packet (len %d).\n",
 654                                            dev->name, pkt_len);
 655                                 /* Prime the FIFO and then flush the packet. */
 656                                 inw(ioaddr + DATAPORT); inw(ioaddr + DATAPORT);
 657                                 outb(0x05, ioaddr + RX_CTRL);
 658                                 dev->stats.rx_dropped++;
 659                                 break;
 660                         }
 661                         skb_reserve(skb,2);
 662
 663                         insw(ioaddr + DATAPORT, skb_put(skb,pkt_len), (pkt_len + 1) >> 1);
 664                         skb->protocol=eth_type_trans(skb, dev);
 665                         netif_rx(skb);
 666                         dev->stats.rx_packets++;
 667                         dev->stats.rx_bytes += pkt_len;
 668                 }
 669                 if (--boguscount <= 0)
 670                         break;
 671         }
 672
 673         /* If any worth-while packets have been received, dev_rint()
 674            has done a mark_bh(NET_BH) for us and will work on them
 675            when we get to the bottom-half routine. */
 676         {
 677                 int i;
 678                 for (i = 0; i < 20; i++) {
 679                         if ((inb(ioaddr + RX_MODE) & 0x40) == 0x40)
 680                                 break;
 681                         inw(ioaddr + DATAPORT);                         /* dummy status read */
 682                         outb(0x05, ioaddr + RX_CTRL);
 683                 }
 684
 685                 if (net_debug > 5)
 686                         printk("%s: Exint Rx packet with mode %02x after %d ticks.\n",
 687                                    dev->name, inb(ioaddr + RX_MODE), i);
 688         }
 689 }
 690
 691 /* The inverse routine to net_open(). */
 692 static int net_close(struct net_device *dev)
 693 {
 694         struct net_local *lp = netdev_priv(dev);
 695         int ioaddr = dev->base_addr;
 696
 697         netif_stop_queue(dev);
 698
 699         /* Set configuration register 0 to disable Tx and Rx. */
 700         outb(0xda, ioaddr + CONFIG_0);
 701
 702         /* No statistic counters on the chip to update. */
 703
 704         /* Disable the IRQ on boards of fmv18x where it is feasible. */
 705         if (lp->jumpered)
 706                 outb(0x00, ioaddr + IOCONFIG1);
 707
 708         /* Power-down the chip.  Green, green, green! */
 709         outb(0x00, ioaddr + CONFIG_1);
 710         return 0;
 711 }
 712
 713 /*
 714   Set the multicast/promiscuous mode for this adaptor.
 715 */
 716
 717 static void
 718 set_rx_mode(struct net_device *dev)
 719 {
 720         int ioaddr = dev->base_addr;
 721         struct net_local *lp = netdev_priv(dev);
 722         unsigned char mc_filter[8];              /* Multicast hash filter */
 723         unsigned long flags;
 724
 725         if (dev->flags & IFF_PROMISC) {
 726                 memset(mc_filter, 0xff, sizeof(mc_filter));
 727                 outb(3, ioaddr + RX_MODE);      /* Enable promiscuous mode */
 728         } else if (netdev_mc_count(dev) > MC_FILTERBREAK ||
 729                            (dev->flags & IFF_ALLMULTI)) {
 730                 /* Too many to filter perfectly -- accept all multicasts. */
 731                 memset(mc_filter, 0xff, sizeof(mc_filter));
 732                 outb(2, ioaddr + RX_MODE);      /* Use normal mode. */
 733         } else if (netdev_mc_empty(dev)) {
 734                 memset(mc_filter, 0x00, sizeof(mc_filter));
 735                 outb(1, ioaddr + RX_MODE);      /* Ignore almost all multicasts. */
 736         } else {
 737                 struct netdev_hw_addr *ha;
 738
 739                 memset(mc_filter, 0, sizeof(mc_filter));
 740                 netdev_for_each_mc_addr(ha, dev) {
 741                         unsigned int bit =
 742                                 ether_crc_le(ETH_ALEN, ha->addr) >> 26;
 743                         mc_filter[bit >> 3] |= (1 << bit);
 744                 }
 745                 outb(0x02, ioaddr + RX_MODE);   /* Use normal mode. */
 746         }
 747
 748         spin_lock_irqsave (&lp->lock, flags);
 749         if (memcmp(mc_filter, lp->mc_filter, sizeof(mc_filter))) {
 750                 int i;
 751                 int saved_bank = inw(ioaddr + CONFIG_0);
 752                 /* Switch to bank 1 and set the multicast table. */
 753                 outw((saved_bank & ~0x0C00) | 0x0480, ioaddr + CONFIG_0);
 754                 for (i = 0; i < 8; i++)
 755                         outb(mc_filter[i], ioaddr + PORT_OFFSET(8 + i));
 756                 memcpy(lp->mc_filter, mc_filter, sizeof(mc_filter));
 757                 outw(saved_bank, ioaddr + CONFIG_0);
 758         }
 759         spin_unlock_irqrestore (&lp->lock, flags);
 760 }
 761
 762 #ifdef MODULE
 763 static struct net_device *dev_at1700;
 764
 765 module_param(io, int, 0);
 766 module_param(irq, int, 0);
 767 module_param(net_debug, int, 0);
 768 MODULE_PARM_DESC(io, "AT1700/FMV18X I/O base address");
 769 MODULE_PARM_DESC(irq, "AT1700/FMV18X IRQ number");
 770 MODULE_PARM_DESC(net_debug, "AT1700/FMV18X debug level (0-6)");
 771
 772 static int __init at1700_module_init(void)
 773 {
 774         if (io == 0)
 775                 printk("at1700: You should not use auto-probing with insmod!\n");
 776         dev_at1700 = at1700_probe(-1);
 777         if (IS_ERR(dev_at1700))
 778                 return PTR_ERR(dev_at1700);
 779         return 0;
 780 }
 781
 782 static void __exit at1700_module_exit(void)
 783 {
 784         unregister_netdev(dev_at1700);
 785         cleanup_card(dev_at1700);
 786         free_netdev(dev_at1700);
 787 }
 788 module_init(at1700_module_init);
 789 module_exit(at1700_module_exit);
 790 #endif /* MODULE */
 791 MODULE_LICENSE("GPL");