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