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