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