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 >= 0)
 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_mca;
 448                         }
 449                 } else {
 450                         if (fmv18x_probe_list[inb(ioaddr + IOCONFIG) & 0x07] != ioaddr)
 451                                 goto err_mca;
 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_mca;
 550         }
 551
 552         return 0;
 553
 554 err_mca:
 555 #ifdef CONFIG_MCA
 556         if (slot >= 0)
 557                 mca_mark_as_unused(slot);
 558 #endif
 559 err_out:
 560 #ifndef CONFIG_X86_PC9800
 561         release_region(ioaddr, AT1700_IO_EXTENT);
 562 #else
 563         for (i = 0; i < 0x2000; i += 0x0200)
 564                 release_region(ioaddr + i, 2);
 565 #endif
 566         return ret;
 567 }
 568
 569 \f
 570 /*  EEPROM_Ctrl bits. */
 571 #define EE_SHIFT_CLK    0x40    /* EEPROM shift clock, in reg. 16. */
 572 #define EE_CS                   0x20    /* EEPROM chip select, in reg. 16. */
 573 #define EE_DATA_WRITE   0x80    /* EEPROM chip data in, in reg. 17. */
 574 #define EE_DATA_READ    0x80    /* EEPROM chip data out, in reg. 17. */
 575
 576 /* Delay between EEPROM clock transitions. */
 577 #ifndef CONFIG_X86_PC9800
 578 #define eeprom_delay()  do { } while (0)
 579 #else
 580 #define eeprom_delay()  __asm__ ("out%B0 %%al,%0" :: "N"(0x5f))
 581 #endif
 582
 583 /* The EEPROM commands include the alway-set leading bit. */
 584 #define EE_WRITE_CMD    (5 << 6)
 585 #define EE_READ_CMD             (6 << 6)
 586 #define EE_ERASE_CMD    (7 << 6)
 587
 588 static int __init read_eeprom(long ioaddr, int location)
 589 {
 590         int i;
 591         unsigned short retval = 0;
 592         long ee_addr = ioaddr + EEPROM_Ctrl;
 593         long ee_daddr = ioaddr + EEPROM_Data;
 594         int read_cmd = location | EE_READ_CMD;
 595
 596         /* Shift the read command bits out. */
 597         for (i = 9; i >= 0; i--) {
 598                 short dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
 599                 outb(EE_CS, ee_addr);
 600                 outb(dataval, ee_daddr);
 601                 eeprom_delay();
 602                 outb(EE_CS | EE_SHIFT_CLK, ee_addr);    /* EEPROM clock tick. */
 603                 eeprom_delay();
 604         }
 605         outb(EE_DATA_WRITE, ee_daddr);
 606         for (i = 16; i > 0; i--) {
 607                 outb(EE_CS, ee_addr);
 608                 eeprom_delay();
 609                 outb(EE_CS | EE_SHIFT_CLK, ee_addr);
 610                 eeprom_delay();
 611                 retval = (retval << 1) | ((inb(ee_daddr) & EE_DATA_READ) ? 1 : 0);
 612         }
 613
 614         /* Terminate the EEPROM access. */
 615         outb(EE_CS, ee_addr);
 616         eeprom_delay();
 617         outb(EE_SHIFT_CLK, ee_addr);
 618         outb(0, ee_addr);
 619         return retval;
 620 }
 621
 622 \f
 623
 624 static int net_open(struct net_device *dev)
 625 {
 626         struct net_local *lp = netdev_priv(dev);
 627         int ioaddr = dev->base_addr;
 628
 629         /* Set the configuration register 0 to 32K 100ns. byte-wide memory, 16 bit
 630            bus access, and two 4K Tx queues. */
 631         outb(0x5a, ioaddr + CONFIG_0);
 632
 633         /* Powerup, switch to register bank 2, and enable the Rx and Tx. */
 634         outb(0xe8, ioaddr + CONFIG_1);
 635
 636         lp->tx_started = 0;
 637         lp->tx_queue_ready = 1;
 638         lp->rx_started = 0;
 639         lp->tx_queue = 0;
 640         lp->tx_queue_len = 0;
 641
 642         /* Turn on hardware Tx and Rx interrupts. */
 643         outb(0x82, ioaddr + TX_INTR);
 644         outb(0x81, ioaddr + RX_INTR);
 645
 646         /* Enable the IRQ on boards of fmv18x it is feasible. */
 647         if (lp->jumpered) {
 648                 outb(0x80, ioaddr + IOCONFIG1);
 649         }
 650
 651         netif_start_queue(dev);
 652         return 0;
 653 }
 654
 655 static void net_tx_timeout (struct net_device *dev)
 656 {
 657         struct net_local *lp = netdev_priv(dev);
 658         int ioaddr = dev->base_addr;
 659
 660         printk ("%s: transmit timed out with status %04x, %s?\n", dev->name,
 661                 inw (ioaddr + STATUS), inb (ioaddr + TX_STATUS) & 0x80
 662                 ? "IRQ conflict" : "network cable problem");
 663         printk ("%s: timeout registers: %04x %04x %04x %04x %04x %04x %04x %04x.\n",
 664          dev->name, inw(ioaddr + TX_STATUS), inw(ioaddr + TX_INTR), inw(ioaddr + TX_MODE),
 665                 inw(ioaddr + CONFIG_0), inw(ioaddr + DATAPORT), inw(ioaddr + TX_START),
 666                 inw(ioaddr + MODE13 - 1), inw(ioaddr + RX_CTRL));
 667         lp->stats.tx_errors++;
 668         /* ToDo: We should try to restart the adaptor... */
 669         outw(0xffff, ioaddr + MODE24);
 670         outw (0xffff, ioaddr + TX_STATUS);
 671         outb (0x5a, ioaddr + CONFIG_0);
 672         outb (0xe8, ioaddr + CONFIG_1);
 673         outw (0x8182, ioaddr + TX_INTR);
 674         outb (0x00, ioaddr + TX_START);
 675         outb (0x03, ioaddr + COL16CNTL);
 676
 677         dev->trans_start = jiffies;
 678
 679         lp->tx_started = 0;
 680         lp->tx_queue_ready = 1;
 681         lp->rx_started = 0;
 682         lp->tx_queue = 0;
 683         lp->tx_queue_len = 0;
 684
 685         netif_wake_queue(dev);
 686 }
 687
 688
 689 static int net_send_packet (struct sk_buff *skb, struct net_device *dev)
 690 {
 691         struct net_local *lp = netdev_priv(dev);
 692         int ioaddr = dev->base_addr;
 693         short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
 694         short len = skb->len;
 695         unsigned char *buf = skb->data;
 696         static u8 pad[ETH_ZLEN];
 697
 698         netif_stop_queue (dev);
 699
 700         /* We may not start transmitting unless we finish transferring
 701            a packet into the Tx queue. During executing the following
 702            codes we possibly catch a Tx interrupt. Thus we flag off
 703            tx_queue_ready, so that we prevent the interrupt routine
 704            (net_interrupt) to start transmitting. */
 705         lp->tx_queue_ready = 0;
 706         {
 707                 outw (length, ioaddr + DATAPORT);
 708                 /* Packet data */
 709                 outsw (ioaddr + DATAPORT, buf, len >> 1);
 710                 /* Check for dribble byte */
 711                 if (len & 1) {
 712                         outw(skb->data[skb->len-1], ioaddr + DATAPORT);
 713                         len++;
 714                 }
 715                 /* Check for packet padding */
 716                 if (length != skb->len)
 717                         outsw(ioaddr + DATAPORT, pad, (length - len + 1) >> 1);
 718
 719                 lp->tx_queue++;
 720                 lp->tx_queue_len += length + 2;
 721         }
 722         lp->tx_queue_ready = 1;
 723
 724         if (lp->tx_started == 0) {
 725                 /* If the Tx is idle, always trigger a transmit. */
 726                 outb (0x80 | lp->tx_queue, ioaddr + TX_START);
 727                 lp->tx_queue = 0;
 728                 lp->tx_queue_len = 0;
 729                 dev->trans_start = jiffies;
 730                 lp->tx_started = 1;
 731                 netif_start_queue (dev);
 732         } else if (lp->tx_queue_len < 4096 - 1502)
 733                 /* Yes, there is room for one more packet. */
 734                 netif_start_queue (dev);
 735         dev_kfree_skb (skb);
 736
 737         return 0;
 738 }
 739 \f
 740 /* The typical workload of the driver:
 741    Handle the network interface interrupts. */
 742 static irqreturn_t
 743 net_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 744 {
 745         struct net_device *dev = dev_id;
 746         struct net_local *lp;
 747         int ioaddr, status;
 748         int handled = 0;
 749
 750         if (dev == NULL) {
 751                 printk ("at1700_interrupt(): irq %d for unknown device.\n", irq);
 752                 return IRQ_NONE;
 753         }
 754
 755         ioaddr = dev->base_addr;
 756         lp = netdev_priv(dev);
 757
 758         spin_lock (&lp->lock);
 759
 760         status = inw(ioaddr + TX_STATUS);
 761         outw(status, ioaddr + TX_STATUS);
 762
 763         if (net_debug > 4)
 764                 printk("%s: Interrupt with status %04x.\n", dev->name, status);
 765         if (lp->rx_started == 0 &&
 766             (status & 0xff00 || (inb(ioaddr + RX_MODE) & 0x40) == 0)) {
 767                 /* Got a packet(s).
 768                    We cannot execute net_rx more than once at the same time for
 769                    the same device. During executing net_rx, we possibly catch a
 770                    Tx interrupt. Thus we flag on rx_started, so that we prevent
 771                    the interrupt routine (net_interrupt) to dive into net_rx
 772                    again. */
 773                 handled = 1;
 774                 lp->rx_started = 1;
 775                 outb(0x00, ioaddr + RX_INTR);   /* Disable RX intr. */
 776                 net_rx(dev);
 777                 outb(0x81, ioaddr + RX_INTR);   /* Enable  RX intr. */
 778                 lp->rx_started = 0;
 779         }
 780         if (status & 0x00ff) {
 781                 handled = 1;
 782                 if (status & 0x02) {
 783                         /* More than 16 collisions occurred */
 784                         if (net_debug > 4)
 785                                 printk("%s: 16 Collision occur during Txing.\n", dev->name);
 786                         /* Cancel sending a packet. */
 787                         outb(0x03, ioaddr + COL16CNTL);
 788                         lp->stats.collisions++;
 789                 }
 790                 if (status & 0x82) {
 791                         lp->stats.tx_packets++;
 792                         /* The Tx queue has any packets and is not being
 793                            transferred a packet from the host, start
 794                            transmitting. */
 795                         if (lp->tx_queue && lp->tx_queue_ready) {
 796                                 outb(0x80 | lp->tx_queue, ioaddr + TX_START);
 797                                 lp->tx_queue = 0;
 798                                 lp->tx_queue_len = 0;
 799                                 dev->trans_start = jiffies;
 800                                 netif_wake_queue (dev);
 801                         } else {
 802                                 lp->tx_started = 0;
 803                                 netif_wake_queue (dev);
 804                         }
 805                 }
 806         }
 807
 808         spin_unlock (&lp->lock);
 809         return IRQ_RETVAL(handled);
 810 }
 811
 812 /* We have a good packet(s), get it/them out of the buffers. */
 813 static void
 814 net_rx(struct net_device *dev)
 815 {
 816         struct net_local *lp = netdev_priv(dev);
 817         int ioaddr = dev->base_addr;
 818         int boguscount = 5;
 819
 820         while ((inb(ioaddr + RX_MODE) & 0x40) == 0) {
 821                 ushort status = inw(ioaddr + DATAPORT);
 822                 ushort pkt_len = inw(ioaddr + DATAPORT);
 823
 824                 if (net_debug > 4)
 825                         printk("%s: Rxing packet mode %02x status %04x.\n",
 826                                    dev->name, inb(ioaddr + RX_MODE), status);
 827 #ifndef final_version
 828                 if (status == 0) {
 829                         outb(0x05, ioaddr + RX_CTRL);
 830                         break;
 831                 }
 832 #endif
 833
 834                 if ((status & 0xF0) != 0x20) {  /* There was an error. */
 835                         lp->stats.rx_errors++;
 836                         if (status & 0x08) lp->stats.rx_length_errors++;
 837                         if (status & 0x04) lp->stats.rx_frame_errors++;
 838                         if (status & 0x02) lp->stats.rx_crc_errors++;
 839                         if (status & 0x01) lp->stats.rx_over_errors++;
 840                 } else {
 841                         /* Malloc up new buffer. */
 842                         struct sk_buff *skb;
 843
 844                         if (pkt_len > 1550) {
 845                                 printk("%s: The AT1700 claimed a very large packet, size %d.\n",
 846                                            dev->name, pkt_len);
 847                                 /* Prime the FIFO and then flush the packet. */
 848                                 inw(ioaddr + DATAPORT); inw(ioaddr + DATAPORT);
 849                                 outb(0x05, ioaddr + RX_CTRL);
 850                                 lp->stats.rx_errors++;
 851                                 break;
 852                         }
 853                         skb = dev_alloc_skb(pkt_len+3);
 854                         if (skb == NULL) {
 855                                 printk("%s: Memory squeeze, dropping packet (len %d).\n",
 856                                            dev->name, pkt_len);
 857                                 /* Prime the FIFO and then flush the packet. */
 858                                 inw(ioaddr + DATAPORT); inw(ioaddr + DATAPORT);
 859                                 outb(0x05, ioaddr + RX_CTRL);
 860                                 lp->stats.rx_dropped++;
 861                                 break;
 862                         }
 863                         skb->dev = dev;
 864                         skb_reserve(skb,2);
 865
 866                         insw(ioaddr + DATAPORT, skb_put(skb,pkt_len), (pkt_len + 1) >> 1);
 867                         skb->protocol=eth_type_trans(skb, dev);
 868                         netif_rx(skb);
 869                         dev->last_rx = jiffies;
 870                         lp->stats.rx_packets++;
 871                         lp->stats.rx_bytes += pkt_len;
 872                 }
 873                 if (--boguscount <= 0)
 874                         break;
 875         }
 876
 877         /* If any worth-while packets have been received, dev_rint()
 878            has done a mark_bh(NET_BH) for us and will work on them
 879            when we get to the bottom-half routine. */
 880         {
 881                 int i;
 882                 for (i = 0; i < 20; i++) {
 883                         if ((inb(ioaddr + RX_MODE) & 0x40) == 0x40)
 884                                 break;
 885                         inw(ioaddr + DATAPORT);                         /* dummy status read */
 886                         outb(0x05, ioaddr + RX_CTRL);
 887                 }
 888
 889                 if (net_debug > 5)
 890                         printk("%s: Exint Rx packet with mode %02x after %d ticks.\n",
 891                                    dev->name, inb(ioaddr + RX_MODE), i);
 892         }
 893         return;
 894 }
 895
 896 /* The inverse routine to net_open(). */
 897 static int net_close(struct net_device *dev)
 898 {
 899         struct net_local *lp = netdev_priv(dev);
 900         int ioaddr = dev->base_addr;
 901
 902         netif_stop_queue(dev);
 903
 904         /* Set configuration register 0 to disable Tx and Rx. */
 905         outb(0xda, ioaddr + CONFIG_0);
 906
 907         /* No statistic counters on the chip to update. */
 908
 909         /* Disable the IRQ on boards of fmv18x where it is feasible. */
 910         if (lp->jumpered) {
 911                 outb(0x00, ioaddr + IOCONFIG1);
 912                 free_irq(dev->irq, dev);
 913         }
 914
 915         /* Power-down the chip.  Green, green, green! */
 916         outb(0x00, ioaddr + CONFIG_1);
 917         return 0;
 918 }
 919
 920 /* Get the current statistics.
 921    This may be called with the card open or closed.
 922    There are no on-chip counters, so this function is trivial.
 923 */
 924 static struct net_device_stats *
 925 net_get_stats(struct net_device *dev)
 926 {
 927         struct net_local *lp = netdev_priv(dev);
 928         return &lp->stats;
 929 }
 930
 931 /*
 932   Set the multicast/promiscuous mode for this adaptor.
 933 */
 934
 935 static void
 936 set_rx_mode(struct net_device *dev)
 937 {
 938         int ioaddr = dev->base_addr;
 939         struct net_local *lp = netdev_priv(dev);
 940         unsigned char mc_filter[8];              /* Multicast hash filter */
 941         unsigned long flags;
 942         int i;
 943
 944         if (dev->flags & IFF_PROMISC) {
 945                 /* Unconditionally log net taps. */
 946                 printk("%s: Promiscuous mode enabled.\n", dev->name);
 947                 memset(mc_filter, 0xff, sizeof(mc_filter));
 948                 outb(3, ioaddr + RX_MODE);      /* Enable promiscuous mode */
 949         } else if (dev->mc_count > MC_FILTERBREAK
 950                            ||  (dev->flags & IFF_ALLMULTI)) {
 951                 /* Too many to filter perfectly -- accept all multicasts. */
 952                 memset(mc_filter, 0xff, sizeof(mc_filter));
 953                 outb(2, ioaddr + RX_MODE);      /* Use normal mode. */
 954         } else if (dev->mc_count == 0) {
 955                 memset(mc_filter, 0x00, sizeof(mc_filter));
 956                 outb(1, ioaddr + RX_MODE);      /* Ignore almost all multicasts. */
 957         } else {
 958                 struct dev_mc_list *mclist;
 959                 int i;
 960
 961                 memset(mc_filter, 0, sizeof(mc_filter));
 962                 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
 963                          i++, mclist = mclist->next) {
 964                         unsigned int bit =
 965                                 ether_crc_le(ETH_ALEN, mclist->dmi_addr) >> 26;
 966                         mc_filter[bit >> 3] |= (1 << bit);
 967                 }
 968                 outb(0x02, ioaddr + RX_MODE);   /* Use normal mode. */
 969         }
 970
 971         spin_lock_irqsave (&lp->lock, flags);
 972         if (memcmp(mc_filter, lp->mc_filter, sizeof(mc_filter))) {
 973                 int saved_bank = inw(ioaddr + CONFIG_0);
 974                 /* Switch to bank 1 and set the multicast table. */
 975                 outw((saved_bank & ~0x0C00) | 0x0480, ioaddr + CONFIG_0);
 976                 for (i = 0; i < 8; i++)
 977                         outb(mc_filter[i], ioaddr + PORT_OFFSET(8 + i));
 978                 memcpy(lp->mc_filter, mc_filter, sizeof(mc_filter));
 979                 outw(saved_bank, ioaddr + CONFIG_0);
 980         }
 981         spin_unlock_irqrestore (&lp->lock, flags);
 982         return;
 983 }
 984
 985 #ifdef MODULE
 986 static struct net_device *dev_at1700;
 987
 988 MODULE_PARM(io, "i");
 989 MODULE_PARM(irq, "i");
 990 MODULE_PARM(net_debug, "i");
 991 MODULE_PARM_DESC(io, "AT1700/FMV18X I/O base address");
 992 MODULE_PARM_DESC(irq, "AT1700/FMV18X IRQ number");
 993 MODULE_PARM_DESC(net_debug, "AT1700/FMV18X debug level (0-6)");
 994
 995 int init_module(void)
 996 {
 997         if (io == 0)
 998                 printk("at1700: You should not use auto-probing with insmod!\n");
 999         dev_at1700 = at1700_probe(-1);
1000         if (IS_ERR(dev_at1700))
1001                 return PTR_ERR(dev_at1700);
1002         return 0;
1003 }
1004
1005 void
1006 cleanup_module(void)
1007 {
1008         unregister_netdev(dev_at1700);
1009         cleanup_card(dev_at1700);
1010         free_netdev(dev_at1700);
1011 }
1012 #endif /* MODULE */
1013 MODULE_LICENSE("GPL");
1014
1015 \f
1016 /*
1017  * Local variables:
1018  *  compile-command: "gcc -DMODULE -D__KERNEL__ -Wall -Wstrict-prototypes -O6 -c at1700.c"
1019  *  alt-compile-command: "gcc -DMODVERSIONS -DMODULE -D__KERNEL__ -Wall -Wstrict-prototypes -O6 -c at1700.c"
1020  *  tab-width: 4
1021  *  c-basic-offset: 4
1022  *  c-indent-level: 4
1023  * End:
1024  */
1025