Linux-2.6.12-rc2v2.6.12-rc2

Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.

Let it rip!

1 files changed, 495 insertions, 0 deletions

diff --git a/drivers/net/hp-plus.c b/drivers/net/hp-plus.c
new file mode 100644
index 000000000000..4834314b676d
--- /dev/null
+++ b/drivers/net/hp-plus.c
@@ -0,0 +1,495 @@
+/* hp-plus.c: A HP PCLAN/plus ethernet driver for linux. */
+/*
+        Written 1994 by Donald Becker.
+
+        This driver is for the Hewlett Packard PC LAN (27***) plus ethercards.
+        These cards are sold under several model numbers, usually 2724*.
+
+        This software may be used and distributed according to the terms
+        of the GNU General Public License, incorporated herein by reference.
+
+        The author may be reached as becker@scyld.com, or C/O
+        Scyld Computing Corporation
+        410 Severn Ave., Suite 210
+        Annapolis MD 21403
+
+        As is often the case, a great deal of credit is owed to Russ Nelson.
+        The Crynwr packet driver was my primary source of HP-specific
+        programming information.
+*/
+
+static const char version[] =
+"hp-plus.c:v1.10 9/24/94 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";
+
+#include <linux/module.h>
+
+#include <linux/string.h>               /* Important -- this inlines word moves. */
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/ioport.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+
+#include <asm/system.h>
+#include <asm/io.h>
+
+#include "8390.h"
+
+#define DRV_NAME "hp-plus"
+
+/* A zero-terminated list of I/O addresses to be probed. */
+static unsigned int hpplus_portlist[] __initdata =
+{0x200, 0x240, 0x280, 0x2C0, 0x300, 0x320, 0x340, 0};
+
+/*
+   The HP EtherTwist chip implementation is a fairly routine DP8390
+   implementation.  It allows both shared memory and programmed-I/O buffer
+   access, using a custom interface for both.  The programmed-I/O mode is
+   entirely implemented in the HP EtherTwist chip, bypassing the problem
+   ridden built-in 8390 facilities used on NE2000 designs.  The shared
+   memory mode is likewise special, with an offset register used to make
+   packets appear at the shared memory base.  Both modes use a base and bounds
+   page register to hide the Rx ring buffer wrap -- a packet that spans the
+   end of physical buffer memory appears continuous to the driver. (c.f. the
+   3c503 and Cabletron E2100)
+
+   A special note: the internal buffer of the board is only 8 bits wide.
+   This lays several nasty traps for the unaware:
+   - the 8390 must be programmed for byte-wide operations
+   - all I/O and memory operations must work on whole words (the access
+     latches are serially preloaded and have no byte-swapping ability).
+
+   This board is laid out in I/O space much like the earlier HP boards:
+   the first 16 locations are for the board registers, and the second 16 are
+   for the 8390.  The board is easy to identify, with both a dedicated 16 bit
+   ID register and a constant 0x530* value in the upper bits of the paging
+   register.
+*/
+
+#define HP_ID                   0x00    /* ID register, always 0x4850. */
+#define HP_PAGING               0x02    /* Registers visible @ 8-f, see PageName. */
+#define HPP_OPTION              0x04    /* Bitmapped options, see HP_Option.    */
+#define HPP_OUT_ADDR    0x08    /* I/O output location in Perf_Page.    */
+#define HPP_IN_ADDR             0x0A    /* I/O input location in Perf_Page.             */
+#define HP_DATAPORT             0x0c    /* I/O data transfer in Perf_Page.              */
+#define NIC_OFFSET              0x10    /* Offset to the 8390 registers.                */
+#define HP_IO_EXTENT    32
+
+#define HP_START_PG             0x00    /* First page of TX buffer */
+#define HP_STOP_PG              0x80    /* Last page +1 of RX ring */
+
+/* The register set selected in HP_PAGING. */
+enum PageName {
+        Perf_Page = 0,                          /* Normal operation. */
+        MAC_Page = 1,                           /* The ethernet address (+checksum). */
+        HW_Page = 2,                            /* EEPROM-loaded hardware parameters. */
+        LAN_Page = 4,                           /* Transceiver selection, testing, etc. */
+        ID_Page = 6 };
+
+/* The bit definitions for the HPP_OPTION register. */
+enum HP_Option {
+        NICReset = 1, ChipReset = 2,    /* Active low, really UNreset. */
+        EnableIRQ = 4, FakeIntr = 8, BootROMEnb = 0x10, IOEnb = 0x20,
+        MemEnable = 0x40, ZeroWait = 0x80, MemDisable = 0x1000, };
+
+static int hpp_probe1(struct net_device *dev, int ioaddr);
+
+static void hpp_reset_8390(struct net_device *dev);
+static int hpp_open(struct net_device *dev);
+static int hpp_close(struct net_device *dev);
+static void hpp_mem_block_input(struct net_device *dev, int count,
+                                                  struct sk_buff *skb, int ring_offset);
+static void hpp_mem_block_output(struct net_device *dev, int count,
+                                                        const unsigned char *buf, int start_page);
+static void hpp_mem_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
+                                                  int ring_page);
+static void hpp_io_block_input(struct net_device *dev, int count,
+                                                  struct sk_buff *skb, int ring_offset);
+static void hpp_io_block_output(struct net_device *dev, int count,
+                                                        const unsigned char *buf, int start_page);
+static void hpp_io_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
+                                                  int ring_page);
+
+
+/*      Probe a list of addresses for an HP LAN+ adaptor.
+        This routine is almost boilerplate. */
+
+static int __init do_hpp_probe(struct net_device *dev)
+{
+        int i;
+        int base_addr = dev->base_addr;
+        int irq = dev->irq;
+
+        SET_MODULE_OWNER(dev);
+
+        if (base_addr > 0x1ff)          /* Check a single specified location. */
+                return hpp_probe1(dev, base_addr);
+        else if (base_addr != 0)        /* Don't probe at all. */
+                return -ENXIO;
+
+        for (i = 0; hpplus_portlist[i]; i++) {
+                if (hpp_probe1(dev, hpplus_portlist[i]) == 0)
+                        return 0;
+                dev->irq = irq;
+        }
+
+        return -ENODEV;
+}
+
+static void cleanup_card(struct net_device *dev)
+{
+        /* NB: hpp_close() handles free_irq */
+        release_region(dev->base_addr - NIC_OFFSET, HP_IO_EXTENT);
+}
+
+#ifndef MODULE
+struct net_device * __init hp_plus_probe(int unit)
+{
+        struct net_device *dev = alloc_ei_netdev();
+        int err;
+
+        if (!dev)
+                return ERR_PTR(-ENOMEM);
+
+        sprintf(dev->name, "eth%d", unit);
+        netdev_boot_setup_check(dev);
+
+        err = do_hpp_probe(dev);
+        if (err)
+                goto out;
+        err = register_netdev(dev);
+        if (err)
+                goto out1;
+        return dev;
+out1:
+        cleanup_card(dev);
+out:
+        free_netdev(dev);
+        return ERR_PTR(err);
+}
+#endif
+
+/* Do the interesting part of the probe at a single address. */
+static int __init hpp_probe1(struct net_device *dev, int ioaddr)
+{
+        int i, retval;
+        unsigned char checksum = 0;
+        const char name[] = "HP-PC-LAN+";
+        int mem_start;
+        static unsigned version_printed;
+
+        if (!request_region(ioaddr, HP_IO_EXTENT, DRV_NAME))
+                return -EBUSY;
+
+        /* Check for the HP+ signature, 50 48 0x 53. */
+        if (inw(ioaddr + HP_ID) != 0x4850
+                || (inw(ioaddr + HP_PAGING) & 0xfff0) != 0x5300) {
+                retval = -ENODEV;
+                goto out;
+        }
+
+        if (ei_debug  &&  version_printed++ == 0)
+                printk(version);
+
+        printk("%s: %s at %#3x,", dev->name, name, ioaddr);
+
+        /* Retrieve and checksum the station address. */
+        outw(MAC_Page, ioaddr + HP_PAGING);
+
+        for(i = 0; i < ETHER_ADDR_LEN; i++) {
+                unsigned char inval = inb(ioaddr + 8 + i);
+                dev->dev_addr[i] = inval;
+                checksum += inval;
+                printk(" %2.2x", inval);
+        }
+        checksum += inb(ioaddr + 14);
+
+        if (checksum != 0xff) {
+                printk(" bad checksum %2.2x.\n", checksum);
+                retval = -ENODEV;
+                goto out;
+        } else {
+                /* Point at the Software Configuration Flags. */
+                outw(ID_Page, ioaddr + HP_PAGING);
+                printk(" ID %4.4x", inw(ioaddr + 12));
+        }
+
+        /* Read the IRQ line. */
+        outw(HW_Page, ioaddr + HP_PAGING);
+        {
+                int irq = inb(ioaddr + 13) & 0x0f;
+                int option = inw(ioaddr + HPP_OPTION);
+
+                dev->irq = irq;
+                if (option & MemEnable) {
+                        mem_start = inw(ioaddr + 9) << 8;
+                        printk(", IRQ %d, memory address %#x.\n", irq, mem_start);
+                } else {
+                        mem_start = 0;
+                        printk(", IRQ %d, programmed-I/O mode.\n", irq);
+                }
+        }
+
+        /* Set the wrap registers for string I/O reads.   */
+        outw((HP_START_PG + TX_PAGES/2) | ((HP_STOP_PG - 1) << 8), ioaddr + 14);
+
+        /* Set the base address to point to the NIC, not the "real" base! */
+        dev->base_addr = ioaddr + NIC_OFFSET;
+
+        dev->open = &hpp_open;
+        dev->stop = &hpp_close;
+#ifdef CONFIG_NET_POLL_CONTROLLER
+        dev->poll_controller = ei_poll;
+#endif
+
+        ei_status.name = name;
+        ei_status.word16 = 0;           /* Agggghhhhh! Debug time: 2 days! */
+        ei_status.tx_start_page = HP_START_PG;
+        ei_status.rx_start_page = HP_START_PG + TX_PAGES/2;
+        ei_status.stop_page = HP_STOP_PG;
+
+        ei_status.reset_8390 = &hpp_reset_8390;
+        ei_status.block_input = &hpp_io_block_input;
+        ei_status.block_output = &hpp_io_block_output;
+        ei_status.get_8390_hdr = &hpp_io_get_8390_hdr;
+
+        /* Check if the memory_enable flag is set in the option register. */
+        if (mem_start) {
+                ei_status.block_input = &hpp_mem_block_input;
+                ei_status.block_output = &hpp_mem_block_output;
+                ei_status.get_8390_hdr = &hpp_mem_get_8390_hdr;
+                dev->mem_start = mem_start;
+                ei_status.rmem_start = dev->mem_start + TX_PAGES/2*256;
+                dev->mem_end = ei_status.rmem_end
+                        = dev->mem_start + (HP_STOP_PG - HP_START_PG)*256;
+        }
+
+        outw(Perf_Page, ioaddr + HP_PAGING);
+        NS8390_init(dev, 0);
+        /* Leave the 8390 and HP chip reset. */
+        outw(inw(ioaddr + HPP_OPTION) & ~EnableIRQ, ioaddr + HPP_OPTION);
+
+        return 0;
+out:
+        release_region(ioaddr, HP_IO_EXTENT);
+        return retval;
+}
+
+static int
+hpp_open(struct net_device *dev)
+{
+        int ioaddr = dev->base_addr - NIC_OFFSET;
+        int option_reg;
+        int retval;
+
+        if ((retval = request_irq(dev->irq, ei_interrupt, 0, dev->name, dev))) {
+            return retval;
+        }
+
+        /* Reset the 8390 and HP chip. */
+        option_reg = inw(ioaddr + HPP_OPTION);
+        outw(option_reg & ~(NICReset + ChipReset), ioaddr + HPP_OPTION);
+        udelay(5);
+        /* Unreset the board and enable interrupts. */
+        outw(option_reg | (EnableIRQ + NICReset + ChipReset), ioaddr + HPP_OPTION);
+
+        /* Set the wrap registers for programmed-I/O operation.   */
+        outw(HW_Page, ioaddr + HP_PAGING);
+        outw((HP_START_PG + TX_PAGES/2) | ((HP_STOP_PG - 1) << 8), ioaddr + 14);
+
+        /* Select the operational page. */
+        outw(Perf_Page, ioaddr + HP_PAGING);
+
+        ei_open(dev);
+        return 0;
+}
+
+static int
+hpp_close(struct net_device *dev)
+{
+        int ioaddr = dev->base_addr - NIC_OFFSET;
+        int option_reg = inw(ioaddr + HPP_OPTION);
+
+        free_irq(dev->irq, dev);
+        ei_close(dev);
+        outw((option_reg & ~EnableIRQ) | MemDisable | NICReset | ChipReset,
+                 ioaddr + HPP_OPTION);
+
+        return 0;
+}
+
+static void
+hpp_reset_8390(struct net_device *dev)
+{
+        int ioaddr = dev->base_addr - NIC_OFFSET;
+        int option_reg = inw(ioaddr + HPP_OPTION);
+
+        if (ei_debug > 1) printk("resetting the 8390 time=%ld...", jiffies);
+
+        outw(option_reg & ~(NICReset + ChipReset), ioaddr + HPP_OPTION);
+        /* Pause a few cycles for the hardware reset to take place. */
+        udelay(5);
+        ei_status.txing = 0;
+        outw(option_reg | (EnableIRQ + NICReset + ChipReset), ioaddr + HPP_OPTION);
+
+        udelay(5);
+
+
+        if ((inb_p(ioaddr+NIC_OFFSET+EN0_ISR) & ENISR_RESET) == 0)
+                printk("%s: hp_reset_8390() did not complete.\n", dev->name);
+
+        if (ei_debug > 1) printk("8390 reset done (%ld).", jiffies);
+        return;
+}
+
+/* The programmed-I/O version of reading the 4 byte 8390 specific header.
+   Note that transfer with the EtherTwist+ must be on word boundaries. */
+
+static void
+hpp_io_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
+{
+        int ioaddr = dev->base_addr - NIC_OFFSET;
+
+        outw((ring_page<<8), ioaddr + HPP_IN_ADDR);
+        insw(ioaddr + HP_DATAPORT, hdr, sizeof(struct e8390_pkt_hdr)>>1);
+}
+
+/* Block input and output, similar to the Crynwr packet driver. */
+
+static void
+hpp_io_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
+{
+        int ioaddr = dev->base_addr - NIC_OFFSET;
+        char *buf = skb->data;
+
+        outw(ring_offset, ioaddr + HPP_IN_ADDR);
+        insw(ioaddr + HP_DATAPORT, buf, count>>1);
+        if (count & 0x01)
+        buf[count-1] = inw(ioaddr + HP_DATAPORT);
+}
+
+/* The corresponding shared memory versions of the above 2 functions. */
+
+static void
+hpp_mem_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
+{
+        int ioaddr = dev->base_addr - NIC_OFFSET;
+        int option_reg = inw(ioaddr + HPP_OPTION);
+
+        outw((ring_page<<8), ioaddr + HPP_IN_ADDR);
+        outw(option_reg & ~(MemDisable + BootROMEnb), ioaddr + HPP_OPTION);
+        isa_memcpy_fromio(hdr, dev->mem_start, sizeof(struct e8390_pkt_hdr));
+        outw(option_reg, ioaddr + HPP_OPTION);
+        hdr->count = (le16_to_cpu(hdr->count) + 3) & ~3;        /* Round up allocation. */
+}
+
+static void
+hpp_mem_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
+{
+        int ioaddr = dev->base_addr - NIC_OFFSET;
+        int option_reg = inw(ioaddr + HPP_OPTION);
+
+        outw(ring_offset, ioaddr + HPP_IN_ADDR);
+
+        outw(option_reg & ~(MemDisable + BootROMEnb), ioaddr + HPP_OPTION);
+
+        /* Caution: this relies on get_8390_hdr() rounding up count!
+           Also note that we *can't* use eth_io_copy_and_sum() because
+           it will not always copy "count" bytes (e.g. padded IP).  */
+
+        isa_memcpy_fromio(skb->data, dev->mem_start, count);
+        outw(option_reg, ioaddr + HPP_OPTION);
+}
+
+/* A special note: we *must* always transfer >=16 bit words.
+   It's always safe to round up, so we do. */
+static void
+hpp_io_block_output(struct net_device *dev, int count,
+                                        const unsigned char *buf, int start_page)
+{
+        int ioaddr = dev->base_addr - NIC_OFFSET;
+        outw(start_page << 8, ioaddr + HPP_OUT_ADDR);
+        outsl(ioaddr + HP_DATAPORT, buf, (count+3)>>2);
+        return;
+}
+
+static void
+hpp_mem_block_output(struct net_device *dev, int count,
+                                const unsigned char *buf, int start_page)
+{
+        int ioaddr = dev->base_addr - NIC_OFFSET;
+        int option_reg = inw(ioaddr + HPP_OPTION);
+
+        outw(start_page << 8, ioaddr + HPP_OUT_ADDR);
+        outw(option_reg & ~(MemDisable + BootROMEnb), ioaddr + HPP_OPTION);
+        isa_memcpy_toio(dev->mem_start, buf, (count + 3) & ~3);
+        outw(option_reg, ioaddr + HPP_OPTION);
+
+        return;
+}
+
+
+#ifdef MODULE
+#define MAX_HPP_CARDS   4       /* Max number of HPP cards per module */
+static struct net_device *dev_hpp[MAX_HPP_CARDS];
+static int io[MAX_HPP_CARDS];
+static int irq[MAX_HPP_CARDS];
+
+module_param_array(io, int, NULL, 0);
+module_param_array(irq, int, NULL, 0);
+MODULE_PARM_DESC(io, "I/O port address(es)");
+MODULE_PARM_DESC(irq, "IRQ number(s); ignored if properly detected");
+MODULE_DESCRIPTION("HP PC-LAN+ ISA ethernet driver");
+MODULE_LICENSE("GPL");
+
+/* This is set up so that only a single autoprobe takes place per call.
+ISA device autoprobes on a running machine are not recommended. */
+int
+init_module(void)
+{
+        struct net_device *dev;
+        int this_dev, found = 0;
+
+        for (this_dev = 0; this_dev < MAX_HPP_CARDS; this_dev++) {
+                if (io[this_dev] == 0)  {
+                        if (this_dev != 0) break; /* only autoprobe 1st one */
+                        printk(KERN_NOTICE "hp-plus.c: Presently autoprobing (not recommended) for a single card.\n");
+                }
+                dev = alloc_ei_netdev();
+                if (!dev)
+                        break;
+                dev->irq = irq[this_dev];
+                dev->base_addr = io[this_dev];
+                if (do_hpp_probe(dev) == 0) {
+                        if (register_netdev(dev) == 0) {
+                                dev_hpp[found++] = dev;
+                                continue;
+                        }
+                        cleanup_card(dev);
+                }
+                free_netdev(dev);
+                printk(KERN_WARNING "hp-plus.c: No HP-Plus card found (i/o = 0x%x).\n", io[this_dev]);
+                break;
+        }
+        if (found)
+                return 0;
+        return -ENXIO;
+}
+
+void
+cleanup_module(void)
+{
+        int this_dev;
+
+        for (this_dev = 0; this_dev < MAX_HPP_CARDS; this_dev++) {
+                struct net_device *dev = dev_hpp[this_dev];
+                if (dev) {
+                        unregister_netdev(dev);
+                        cleanup_card(dev);
+                        free_netdev(dev);
+                }
+        }
+}
+#endif /* MODULE */