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
 269         if (!request_region(ioaddr, AT1700_IO_EXTENT, DRV_NAME))
 270                 return -EBUSY;
 271
 272         /* Resetting the chip doesn't reset the ISA interface, so don't bother.
 273            That means we have to be careful with the register values we probe
 274            for.
 275          */
 276 #ifdef notdef
 277         printk("at1700 probe at %#x, eeprom is %4.4x %4.4x %4.4x ctrl %4.4x.\n",
 278                    ioaddr, read_eeprom(ioaddr, 4), read_eeprom(ioaddr, 5),
 279                    read_eeprom(ioaddr, 6), inw(ioaddr + EEPROM_Ctrl));
 280 #endif
 281
 282 #ifdef CONFIG_MCA_LEGACY
 283         /* rEnE (rene@bss.lu): got this from 3c509 driver source , adapted for AT1720 */
 284
 285     /* Based on Erik Nygren's (nygren@mit.edu) 3c529 patch, heavily
 286         modified by Chris Beauregard (cpbeaure@csclub.uwaterloo.ca)
 287         to support standard MCA probing. */
 288
 289         /* redone for multi-card detection by ZP Gu (zpg@castle.net) */
 290         /* now works as a module */
 291
 292         if (MCA_bus) {
 293                 int j;
 294                 int l_i;
 295                 u_char pos3, pos4;
 296
 297                 for (j = 0; at1720_mca_adapters[j].name != NULL; j ++) {
 298                         slot = 0;
 299                         while (slot != MCA_NOTFOUND) {
 300
 301                                 slot = mca_find_unused_adapter( at1720_mca_adapters[j].id, slot );
 302                                 if (slot == MCA_NOTFOUND) break;
 303
 304                                 /* if we get this far, an adapter has been detected and is
 305                                 enabled */
 306
 307                                 pos3 = mca_read_stored_pos( slot, 3 );
 308                                 pos4 = mca_read_stored_pos( slot, 4 );
 309
 310                                 for (l_i = 0; l_i < 0x09; l_i++)
 311                                         if (( pos3 & 0x07) == at1700_ioaddr_pattern[l_i])
 312                                                 break;
 313                                 ioaddr = at1700_mca_probe_list[l_i];
 314
 315                                 for (irq = 0; irq < 0x10; irq++)
 316                                         if (((((pos4>>4) & 0x0f) | (pos3 & 0xf0)) & 0xff) == at1700_irq_pattern[irq])
 317                                                 break;
 318
 319                                         /* probing for a card at a particular IO/IRQ */
 320                                 if ((dev->irq && dev->irq != irq) ||
 321                                     (dev->base_addr && dev->base_addr != ioaddr)) {
 322                                         slot++;         /* probing next slot */
 323                                         continue;
 324                                 }
 325
 326                                 dev->irq = irq;
 327
 328                                 /* claim the slot */
 329                                 mca_set_adapter_name( slot, at1720_mca_adapters[j].name );
 330                                 mca_mark_as_used(slot);
 331
 332                                 goto found;
 333                         }
 334                 }
 335                 /* if we get here, we didn't find an MCA adapter - try ISA */
 336         }
 337 #endif
 338         slot = -1;
 339         /* We must check for the EEPROM-config boards first, else accessing
 340            IOCONFIG0 will move the board! */
 341         if (at1700_probe_list[inb(ioaddr + IOCONFIG1) & 0x07] == ioaddr
 342                 && read_eeprom(ioaddr, 4) == 0x0000
 343                 && (read_eeprom(ioaddr, 5) & 0xff00) == 0xF400)
 344                 is_at1700 = 1;
 345         else if (inb(ioaddr   + SAPROM    ) == 0x00
 346                 && inb(ioaddr + SAPROM + 1) == 0x00
 347                 && inb(ioaddr + SAPROM + 2) == 0x0e)
 348                 is_fmv18x = 1;
 349         else {
 350                 goto err_out;
 351         }
 352
 353 #ifdef CONFIG_MCA_LEGACY
 354 found:
 355 #endif
 356
 357                 /* Reset the internal state machines. */
 358         outb(0, ioaddr + RESET);
 359
 360         if (is_at1700) {
 361                 irq = at1700_irqmap[(read_eeprom(ioaddr, 12)&0x04)
 362                                                    | (read_eeprom(ioaddr, 0)>>14)];
 363         } else {
 364                 /* Check PnP mode for FMV-183/184/183A/184A. */
 365                 /* This PnP routine is very poor. IO and IRQ should be known. */
 366                 if (inb(ioaddr + CARDSTATUS1) & 0x20) {
 367                         irq = dev->irq;
 368                         for (i = 0; i < 8; i++) {
 369                                 if (irq == fmv_irqmap_pnp[i])
 370                                         break;
 371                         }
 372                         if (i == 8) {
 373                                 goto err_mca;
 374                         }
 375                 } else {
 376                         if (fmv18x_probe_list[inb(ioaddr + IOCONFIG) & 0x07] != ioaddr)
 377                                 goto err_mca;
 378                         irq = fmv_irqmap[(inb(ioaddr + IOCONFIG)>>6) & 0x03];
 379                 }
 380         }
 381
 382         printk("%s: %s found at %#3x, IRQ %d, address ", dev->name,
 383                    is_at1700 ? "AT1700" : "FMV-18X", ioaddr, irq);
 384
 385         dev->base_addr = ioaddr;
 386         dev->irq = irq;
 387
 388         if (is_at1700) {
 389                 for(i = 0; i < 3; i++) {
 390                         unsigned short eeprom_val = read_eeprom(ioaddr, 4+i);
 391                         ((unsigned short *)dev->dev_addr)[i] = ntohs(eeprom_val);
 392                 }
 393         } else {
 394                 for(i = 0; i < 6; i++) {
 395                         unsigned char val = inb(ioaddr + SAPROM + i);
 396                         dev->dev_addr[i] = val;
 397                 }
 398         }
 399         printk("%pM", dev->dev_addr);
 400
 401         /* The EEPROM word 12 bit 0x0400 means use regular 100 ohm 10baseT signals,
 402            rather than 150 ohm shielded twisted pair compensation.
 403            0x0000 == auto-sense the interface
 404            0x0800 == use TP interface
 405            0x1800 == use coax interface
 406            */
 407         {
 408                 const char *porttype[] = {"auto-sense", "10baseT", "auto-sense", "10base2"};
 409                 if (is_at1700) {
 410                         ushort setup_value = read_eeprom(ioaddr, 12);
 411                         dev->if_port = setup_value >> 8;
 412                 } else {
 413                         ushort setup_value = inb(ioaddr + CARDSTATUS);
 414                         switch (setup_value & 0x07) {
 415                         case 0x01: /* 10base5 */
 416                         case 0x02: /* 10base2 */
 417                                 dev->if_port = 0x18; break;
 418                         case 0x04: /* 10baseT */
 419                                 dev->if_port = 0x08; break;
 420                         default:   /* auto-sense */
 421                                 dev->if_port = 0x00; break;
 422                         }
 423                 }
 424                 printk(" %s interface.\n", porttype[(dev->if_port>>3) & 3]);
 425         }
 426
 427         /* Set the configuration register 0 to 32K 100ns. byte-wide memory, 16 bit
 428            bus access, two 4K Tx queues, and disabled Tx and Rx. */
 429         outb(0xda, ioaddr + CONFIG_0);
 430
 431         /* Set the station address in bank zero. */
 432         outb(0x00, ioaddr + CONFIG_1);
 433         for (i = 0; i < 6; i++)
 434                 outb(dev->dev_addr[i], ioaddr + PORT_OFFSET(8 + i));
 435
 436         /* Switch to bank 1 and set the multicast table to accept none. */
 437         outb(0x04, ioaddr + CONFIG_1);
 438         for (i = 0; i < 8; i++)
 439                 outb(0x00, ioaddr + PORT_OFFSET(8 + i));
 440
 441
 442         /* Switch to bank 2 */
 443         /* Lock our I/O address, and set manual processing mode for 16 collisions. */
 444         outb(0x08, ioaddr + CONFIG_1);
 445         outb(dev->if_port, ioaddr + MODE13);
 446         outb(0x00, ioaddr + COL16CNTL);
 447
 448         if (net_debug)
 449                 printk(version);
 450
 451         memset(lp, 0, sizeof(struct net_local));
 452
 453         dev->open               = net_open;
 454         dev->stop               = net_close;
 455         dev->hard_start_xmit = net_send_packet;
 456         dev->set_multicast_list = &set_rx_mode;
 457         dev->tx_timeout = net_tx_timeout;
 458         dev->watchdog_timeo = TX_TIMEOUT;
 459
 460         spin_lock_init(&lp->lock);
 461
 462         lp->jumpered = is_fmv18x;
 463         lp->mca_slot = slot;
 464         /* Snarf the interrupt vector now. */
 465         ret = request_irq(irq, &net_interrupt, 0, DRV_NAME, dev);
 466         if (ret) {
 467                 printk(KERN_ERR "AT1700 at %#3x is unusable due to a "
 468                        "conflict on IRQ %d.\n",
 469                        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->stats.rx_packets++;
 771                         dev->stats.rx_bytes += pkt_len;
 772                 }
 773                 if (--boguscount <= 0)
 774                         break;
 775         }
 776
 777         /* If any worth-while packets have been received, dev_rint()
 778            has done a mark_bh(NET_BH) for us and will work on them
 779            when we get to the bottom-half routine. */
 780         {
 781                 int i;
 782                 for (i = 0; i < 20; i++) {
 783                         if ((inb(ioaddr + RX_MODE) & 0x40) == 0x40)
 784                                 break;
 785                         inw(ioaddr + DATAPORT);                         /* dummy status read */
 786                         outb(0x05, ioaddr + RX_CTRL);
 787                 }
 788
 789                 if (net_debug > 5)
 790                         printk("%s: Exint Rx packet with mode %02x after %d ticks.\n",
 791                                    dev->name, inb(ioaddr + RX_MODE), i);
 792         }
 793         return;
 794 }
 795
 796 /* The inverse routine to net_open(). */
 797 static int net_close(struct net_device *dev)
 798 {
 799         struct net_local *lp = netdev_priv(dev);
 800         int ioaddr = dev->base_addr;
 801
 802         netif_stop_queue(dev);
 803
 804         /* Set configuration register 0 to disable Tx and Rx. */
 805         outb(0xda, ioaddr + CONFIG_0);
 806
 807         /* No statistic counters on the chip to update. */
 808
 809         /* Disable the IRQ on boards of fmv18x where it is feasible. */
 810         if (lp->jumpered) {
 811                 outb(0x00, ioaddr + IOCONFIG1);
 812                 free_irq(dev->irq, dev);
 813         }
 814
 815         /* Power-down the chip.  Green, green, green! */
 816         outb(0x00, ioaddr + CONFIG_1);
 817         return 0;
 818 }
 819
 820 /*
 821   Set the multicast/promiscuous mode for this adaptor.
 822 */
 823
 824 static void
 825 set_rx_mode(struct net_device *dev)
 826 {
 827         int ioaddr = dev->base_addr;
 828         struct net_local *lp = netdev_priv(dev);
 829         unsigned char mc_filter[8];              /* Multicast hash filter */
 830         unsigned long flags;
 831
 832         if (dev->flags & IFF_PROMISC) {
 833                 memset(mc_filter, 0xff, sizeof(mc_filter));
 834                 outb(3, ioaddr + RX_MODE);      /* Enable promiscuous mode */
 835         } else if (dev->mc_count > MC_FILTERBREAK
 836                            ||  (dev->flags & IFF_ALLMULTI)) {
 837                 /* Too many to filter perfectly -- accept all multicasts. */
 838                 memset(mc_filter, 0xff, sizeof(mc_filter));
 839                 outb(2, ioaddr + RX_MODE);      /* Use normal mode. */
 840         } else if (dev->mc_count == 0) {
 841                 memset(mc_filter, 0x00, sizeof(mc_filter));
 842                 outb(1, ioaddr + RX_MODE);      /* Ignore almost all multicasts. */
 843         } else {
 844                 struct dev_mc_list *mclist;
 845                 int i;
 846
 847                 memset(mc_filter, 0, sizeof(mc_filter));
 848                 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
 849                          i++, mclist = mclist->next) {
 850                         unsigned int bit =
 851                                 ether_crc_le(ETH_ALEN, mclist->dmi_addr) >> 26;
 852                         mc_filter[bit >> 3] |= (1 << bit);
 853                 }
 854                 outb(0x02, ioaddr + RX_MODE);   /* Use normal mode. */
 855         }
 856
 857         spin_lock_irqsave (&lp->lock, flags);
 858         if (memcmp(mc_filter, lp->mc_filter, sizeof(mc_filter))) {
 859                 int i;
 860                 int saved_bank = inw(ioaddr + CONFIG_0);
 861                 /* Switch to bank 1 and set the multicast table. */
 862                 outw((saved_bank & ~0x0C00) | 0x0480, ioaddr + CONFIG_0);
 863                 for (i = 0; i < 8; i++)
 864                         outb(mc_filter[i], ioaddr + PORT_OFFSET(8 + i));
 865                 memcpy(lp->mc_filter, mc_filter, sizeof(mc_filter));
 866                 outw(saved_bank, ioaddr + CONFIG_0);
 867         }
 868         spin_unlock_irqrestore (&lp->lock, flags);
 869         return;
 870 }
 871
 872 #ifdef MODULE
 873 static struct net_device *dev_at1700;
 874
 875 module_param(io, int, 0);
 876 module_param(irq, int, 0);
 877 module_param(net_debug, int, 0);
 878 MODULE_PARM_DESC(io, "AT1700/FMV18X I/O base address");
 879 MODULE_PARM_DESC(irq, "AT1700/FMV18X IRQ number");
 880 MODULE_PARM_DESC(net_debug, "AT1700/FMV18X debug level (0-6)");
 881
 882 static int __init at1700_module_init(void)
 883 {
 884         if (io == 0)
 885                 printk("at1700: You should not use auto-probing with insmod!\n");
 886         dev_at1700 = at1700_probe(-1);
 887         if (IS_ERR(dev_at1700))
 888                 return PTR_ERR(dev_at1700);
 889         return 0;
 890 }
 891
 892 static void __exit at1700_module_exit(void)
 893 {
 894         unregister_netdev(dev_at1700);
 895         cleanup_card(dev_at1700);
 896         free_netdev(dev_at1700);
 897 }
 898 module_init(at1700_module_init);
 899 module_exit(at1700_module_exit);
 900 #endif /* MODULE */
 901 MODULE_LICENSE("GPL");