Subversion Repositories or1k_old

/* cs89x0.c: A Crystal Semiconductor CS89[02]0 driver for linux. */

/*

        Written 1996 by Russell Nelson, with reference to skeleton.c

        written 1993-1994 by Donald Becker.

        This software may be used and distributed according to the terms

        of the GNU Public License, incorporated herein by reference.

        The author may be reached at nelson@crynwr.com, Crynwr

        Software, 11 Grant St., Potsdam, NY 13676

  Changelog:

  Mike Cruse        : mcruse@cti-ltd.com

                    : Changes for Linux 2.0 compatibility.

                    : Added dev_id parameter in net_interrupt(),

                    : request_irq() and free_irq(). Just NULL for now.

  Mike Cruse        : Added MOD_INC_USE_COUNT and MOD_DEC_USE_COUNT macros

                    : in net_open() and net_close() so kerneld would know

                    : that the module is in use and wouldn't eject the

                    : driver prematurely.

  Mike Cruse        : Rewrote init_module() and cleanup_module using 8390.c

                    : as an example. Disabled autoprobing in init_module(),

                    : not a good thing to do to other devices while Linux

                    : is running from all accounts.

  Alan Cox          : Removed 1.2 support, added 2.1 extra counters.

*/

static char *version =

"cs89x0.c:v1.02 11/26/96 Russell Nelson <nelson@crynwr.com>\n"

"etherc.c:v1.00 19/02/99 Ben Dooks <ben@fluff.org>\n";

/* ======================= configure the driver here ======================= */

/* use 0 for production, 1 for verification, >2 for debug */

#ifndef NET_DEBUG

#define NET_DEBUG 1

#endif

/* ======================= end of configuration ======================= */

/* Always include 'config.h' first in case the user wants to turn on

   or override something. */

#ifdef MODULE

#include <linux/module.h>

#include <linux/version.h>

#else

#define MOD_INC_USE_COUNT

#define MOD_DEC_USE_COUNT

#endif

#define PRINTK(x) printk x

/*

  Sources:

        Crynwr packet driver epktisa.

        Crystal Semiconductor data sheets.

*/

#include <linux/kernel.h>

#include <linux/sched.h>

#include <linux/types.h>

#include <linux/fcntl.h>

#include <linux/interrupt.h>

#include <linux/ptrace.h>

#include <linux/ioport.h>

#include <linux/in.h>

#include <linux/malloc.h>

#include <linux/string.h>

#include <asm/system.h>

#include <asm/bitops.h>

#include <asm/io.h>

#include <linux/errno.h>

#if KERNEL_VERSION >= 0x020100

#include <linux/init.h>

#else

#define __initfunc(x) x

#endif

#include <asm/delay.h>

#include <asm/ecard.h>

#include <linux/netdevice.h>

#include <linux/etherdevice.h>

#include <linux/skbuff.h>

#include "etherc.h"

/* First, a few definitions that the brave might change. */

/* A zero-terminated list of I/O addresses to be probed. */

static const card_ids cids[] = { {0x1f,0x2401}, { 0xffff, 0xffff} };

static unsigned int net_debug = NET_DEBUG;

/* The number of low I/O ports used by the ethercard. */

#define NETCARD_IO_EXTENT       16

/* Information that need to be kept for each board. */

struct net_local {

        struct enet_statistics stats;

        struct expansion_card *ec;

        int chip_type;          /* one of: CS8900, CS8920, CS8920M */

        char chip_revision;     /* revision letter of the chip ('A'...) */

        int send_cmd;           /* the propercommand used to send a packet. */

        int auto_neg_cnf;

        int adapter_cnf;

        int isa_config;

        int irq_map;

        int rx_mode;

        int curr_rx_cfg;

        int linectl;

        int send_underrun;      /* keep track of how many underruns in a row we get */

        struct sk_buff *skb;

};

/* Index to functions, as function prototypes. */

extern int etherc_probe(struct device *dev);

static int cs89x0_probe1(struct device *dev, int ioaddr,

                         struct expansion_card *ec);

static int net_open(struct device *dev);

static int      net_send_packet(struct sk_buff *skb, struct device *dev);

static void net_interrupt(int irq, void *dev_id, struct pt_regs *regs);

static void set_multicast_list(struct device *dev);

static void net_rx(struct device *dev);

static int net_close(struct device *dev);

static struct enet_statistics *net_get_stats(struct device *dev);

static void reset_chip(struct device *dev);

static int get_eeprom_data(struct device *dev, int off, int len, int *buffer);

static int get_eeprom_cksum(int off, int len, int *buffer);

static int set_mac_address(struct device *dev, void *addr);

/* Example routines you must write ;->. */

#define tx_done(dev) 1

/* Check for a network adaptor of this type, and return '0' iff one exists.

   If dev->base_addr == 0, probe all likely locations.

   If dev->base_addr == 1, always return failure.

   If dev->base_addr == 2, allocate space for the device and return success

   (detachable devices only).

   */

__initfunc(int

etherc_probe(struct device *dev))

{

        unsigned long ioaddr;

        struct expansion_card *ec;

        ecard_startfind();

        do {

          if ((ec = ecard_find(0, cids)) == NULL)

            break;

          ioaddr = ecard_address(ec, ECARD_EASI, 0);

          dev->irq = ec->irq;

          if (cs89x0_probe1(dev, ioaddr, ec) == 0)

            return 0;

        } while(0==0);

        return ENODEV;

}

static int inline

readreg(struct device *dev, int portno)

{

        outw(portno, dev->base_addr + (ADD_PORT << ECARD_SHIFT));

        return inw(dev->base_addr + (DATA_PORT << ECARD_SHIFT));

}

static void inline

writereg(struct device *dev, int portno, int value)

{

        outw(portno, dev->base_addr + (ADD_PORT << ECARD_SHIFT));

        outw(value, dev->base_addr + (DATA_PORT << ECARD_SHIFT));

}

static int inline

readword(struct device *dev, int portno)

{

        return inw(dev->base_addr + (portno << ECARD_SHIFT));

}

static void inline

writeword(struct device *dev, int portno, int value)

{

        outw(value, dev->base_addr + (portno << ECARD_SHIFT));

}

__initfunc(static int

wait_eeprom_ready(struct device *dev))

{

        int timeout = jiffies;

        /* check to see if the EEPROM is ready, a timeout is used -

           just in case EEPROM is ready when SI_BUSY in the

           PP_SelfST is clear */

        while(readreg(dev, PP_SelfST) & SI_BUSY)

                if (jiffies - timeout >= 40)

                        return -1;

        return 0;

}

__initfunc(static int

get_eeprom_data(struct device *dev, int off, int len, int *buffer))

{

        int i;

        if (net_debug > 3) printk("EEPROM data from %x for %x:\n",off,len);

        for (i = 0; i < len; i++) {

                if (wait_eeprom_ready(dev) < 0) return -1;

                /* Now send the EEPROM read command and EEPROM location to read */

                writereg(dev, PP_EECMD, (off + i) | EEPROM_READ_CMD);

                if (wait_eeprom_ready(dev) < 0) return -1;

                buffer[i] = readreg(dev, PP_EEData);

                if (net_debug > 3) printk("%04x ", buffer[i]);

        }

        if (net_debug > 3) printk("\n");

        return 0;

}

__initfunc(static int

get_eeprom_cksum(int off, int len, int *buffer))

{

        int i, cksum;

        cksum = 0;

        for (i = 0; i < len; i++)

                cksum += buffer[i];

        cksum &= 0xffff;

        if (cksum == 0)

                return 0;

        return -1;

}

/* This is the real probe routine.  Linux has a history of friendly device

   probes on the ISA bus.  A good device probes avoids doing writes, and

   verifies that the correct device exists and functions.  */

__initfunc(static int cs89x0_probe1(struct device *dev, int io_addr, struct expansion_card *ec))

{

        struct net_local *lp;

        static unsigned version_printed = 0;

        int i;

        unsigned rev_type = 0;

        int eeprom_buff[CHKSUM_LEN];

        io_addr += (0x400600 >> 2);

        if (check_region(io_addr, NETCARD_IO_EXTENT))

            return 1;

        /* Initialize the device structure. */

        if (dev->priv == NULL) {

                dev->priv = kmalloc(sizeof(struct net_local), GFP_KERNEL);

                memset(dev->priv, 0, sizeof(struct net_local));

        }

        lp = (struct net_local *)dev->priv;

        ecard_claim(ec);

        /* if they give us an odd I/O address, then do ONE write to

           the address port, to get it back to address zero, where we

           expect to find the EISA signature word. */

        if (io_addr & 1) {

                io_addr &= ~1;

                if ((inw(io_addr + ADD_PORT) & ADD_MASK) != ADD_SIG)

                        return ENODEV;

                outw(PP_ChipID, io_addr + ADD_PORT);

        }

        outw(PP_ChipID, io_addr + ADD_PORT);

        if (inw(io_addr + DATA_PORT) != CHIP_EISA_ID_SIG)

                return ENODEV;

        /* Fill in the 'dev' fields. */

        dev->base_addr = io_addr;

//      dev->mem_start = io_addr + (0x600000 >> 1);

        dev->mem_start = 0;

        dev->irq = ec->irq;

        lp->ec = ec;

        ec->irqaddr = ioaddr(io_addr + (0x3ffa00 >> 2));

        ec->irqmask = 4;

        /* get the chip type */

        rev_type = readreg(dev, PRODUCT_ID_ADD);

        lp->chip_type = rev_type &~ REVISON_BITS;

        lp->chip_revision = ((rev_type & REVISON_BITS) >> 8) + 'A';

        /* Check the chip type and revision in order to set the correct send command

        CS8920 revision C and CS8900 revision F can use the faster send. */

        lp->send_cmd = TX_AFTER_381;

//      if (lp->chip_type == CS8900 && lp->chip_revision >= 'F')

//              lp->send_cmd = TX_NOW;

//      if (lp->chip_type != CS8900 && lp->chip_revision >= 'C')

//              lp->send_cmd = TX_NOW;

        if (net_debug  &&  version_printed++ == 0)

                printk(version);

        printk("%s: cs89%c0%s rev %c found at %#3lx",

               dev->name,

               lp->chip_type==CS8900?'0':'2',

               lp->chip_type==CS8920M?"M":"",

               lp->chip_revision,

               dev->base_addr);

        reset_chip(dev);

        /* First check to see if an EEPROM is attached*/

        if ((readreg(dev, PP_SelfST) & EEPROM_PRESENT) == 0)

                printk("\ncs89x0: No EEPROM, relying on command line....\n");

        else if (get_eeprom_data(dev, START_EEPROM_DATA,CHKSUM_LEN,eeprom_buff) < 0) {

                printk("\ncs89x0: EEPROM read failed, relying on command line.\n");

        } else if (get_eeprom_cksum(START_EEPROM_DATA,CHKSUM_LEN,eeprom_buff) < 0) {

                printk("\ncs89x0: EEPROM checksum bad, relyong on command line\n");

        } else {

                /* get transmission control word  but keep the autonegotiation bits */

                if (!lp->auto_neg_cnf) lp->auto_neg_cnf = eeprom_buff[AUTO_NEG_CNF_OFFSET/2];

                /* Store adapter configuration */

                if (!lp->adapter_cnf) lp->adapter_cnf = eeprom_buff[ADAPTER_CNF_OFFSET/2];

                /* Store ISA configuration */

                lp->isa_config = eeprom_buff[ISA_CNF_OFFSET/2];

                /* store the initial memory base address */

                dev->mem_start = eeprom_buff[PACKET_PAGE_OFFSET/2] << 8;

                for (i = 0; i < ETH_ALEN/2; i++) {

                        dev->dev_addr[i*2] = eeprom_buff[i];

                        dev->dev_addr[i*2+1] = eeprom_buff[i] >> 8;

                }

        }

        printk(" media %s%s%s",

               (lp->adapter_cnf & A_CNF_10B_T)?"RJ-45,":"",

               (lp->adapter_cnf & A_CNF_AUI)?"AUI,":"",

               (lp->adapter_cnf & A_CNF_10B_2)?"BNC,":"");

        lp->irq_map = 0xffff;

        /* If this is a CS8900 then no pnp soft */

        if (lp->chip_type != CS8900 &&

            /* Check if the ISA IRQ has been set  */

                (i = readreg(dev, PP_CS8920_ISAINT) & 0xff,

                 (i != 0 && i < CS8920_NO_INTS))) {

                if (!dev->irq)

                        dev->irq = i;

        } else {

                i = lp->isa_config & INT_NO_MASK;

                if (lp->chip_type == CS8900) {

                        /* the table that follows is dependent upon how you wired up your cs8900

                         * in your system.  The table is the same as the cs8900 engineering demo

                         * board.  irq_map also depends on the contents of the table.  Also see

                         * write_irq, which is the reverse mapping of the table below. */

                        switch(i) {

                        case 0: i = 10; break;

                        case 1: i = 11; break;

                        case 2: i = 12; break;

                        case 3: i =  5; break;

                        default: printk("\ncs89x0: bug: isa_config is %d\n", i);

                        }

                        lp->irq_map = CS8900_IRQ_MAP; /* fixed IRQ map for CS8900 */

                } else {

                        int irq_map_buff[IRQ_MAP_LEN/2];

                        if (get_eeprom_data(dev, IRQ_MAP_EEPROM_DATA,

                                            IRQ_MAP_LEN/2,

                                            irq_map_buff) >= 0) {

                                if ((irq_map_buff[0] & 0xff) == PNP_IRQ_FRMT)

                                        lp->irq_map = (irq_map_buff[0]>>8) | (irq_map_buff[1] << 8);

                        }

                }

                if (!dev->irq)

                        dev->irq = i;

        }

        printk(" IRQ %d", dev->irq);

        /* print the ethernet address. */

        for (i = 0; i < ETH_ALEN; i++)

                printk(" %2.2x", dev->dev_addr[i]);

        /* Grab the region so we can find another board if autoIRQ fails. */

        request_region(io_addr, NETCARD_IO_EXTENT,"cs89x0");

        dev->open               = net_open;

        dev->stop               = net_close;

        dev->hard_start_xmit = net_send_packet;

        dev->get_stats  = net_get_stats;

        dev->set_multicast_list = &set_multicast_list;

        dev->set_mac_address = &set_mac_address;

        /* Fill in the fields of the device structure with ethernet values. */

        ether_setup(dev);

        printk("\n");

        return 0;

}

__initfunc(void

reset_chip(struct device *dev))

{

        struct net_local *lp = (struct net_local *)dev->priv;

        int ioaddr = dev->base_addr;

        int reset_start_time;

        writereg(dev, PP_SelfCTL, readreg(dev, PP_SelfCTL) | POWER_ON_RESET);

        /* wait 30 ms */

        current->state = TASK_INTERRUPTIBLE;

        current->timeout = jiffies + 30*HZ/1000;

        schedule();

        if (lp->chip_type != CS8900) {

                /* Hardware problem requires PNP registers to be reconfigured after a reset */

                outw(PP_CS8920_ISAINT, ioaddr + ADD_PORT);

                outb(dev->irq, ioaddr + DATA_PORT);

                outb(0,      ioaddr + DATA_PORT + 1);

                outw(PP_CS8920_ISAMemB, ioaddr + ADD_PORT);

                outb((dev->mem_start >> 8) & 0xff, ioaddr + DATA_PORT);

                outb((dev->mem_start >> 24) & 0xff,   ioaddr + DATA_PORT + 1);

        }

        /* Wait until the chip is reset */

        reset_start_time = jiffies;

        while( (readreg(dev, PP_SelfST) & INIT_DONE) == 0 && jiffies - reset_start_time < 2)

                ;

}

static void

control_dc_dc(struct device *dev, int on_not_off)

{

        struct net_local *lp = (struct net_local *)dev->priv;

        unsigned int selfcontrol;

        int timenow = jiffies;

        /* control the DC to DC convertor in the SelfControl register.  */

        selfcontrol = HCB1_ENBL; /* Enable the HCB1 bit as an output */

        if (((lp->adapter_cnf & A_CNF_DC_DC_POLARITY) != 0) ^ on_not_off)

                selfcontrol |= HCB1;

        else

                selfcontrol &= ~HCB1;

        writereg(dev, PP_SelfCTL, selfcontrol);

        /* Wait for the DC/DC converter to power up - 500ms */

        while (jiffies - timenow < 100)

                ;

}

static int

detect_tp(struct device *dev)

{

        struct net_local *lp = (struct net_local *)dev->priv;

        int timenow = jiffies;

        if (net_debug > 1) printk("%s: Attempting TP\n", dev->name);

        /* If connected to another full duplex capable 10-Base-T card the link pulses

           seem to be lost when the auto detect bit in the LineCTL is set.

           To overcome this the auto detect bit will be cleared whilst testing the

           10-Base-T interface.  This would not be necessary for the sparrow chip but

           is simpler to do it anyway. */

        writereg(dev, PP_LineCTL, lp->linectl &~ AUI_ONLY);

        control_dc_dc(dev, 0);

        /* Delay for the hardware to work out if the TP cable is present - 150ms */

        for (timenow = jiffies; jiffies - timenow < 15; )

                ;

        if ((readreg(dev, PP_LineST) & LINK_OK) == 0)

                return 0;

        if (lp->chip_type != CS8900) {

                writereg(dev, PP_AutoNegCTL, lp->auto_neg_cnf & AUTO_NEG_MASK);

                if ((lp->auto_neg_cnf & AUTO_NEG_BITS) == AUTO_NEG_ENABLE) {

                        printk("%s: negotiating duplex...\n",dev->name);

                        while (readreg(dev, PP_AutoNegST) & AUTO_NEG_BUSY) {

                                if (jiffies - timenow > 4000) {

                                        printk("**** Full / half duplex auto-negotiation timed out ****\n");

                                        break;

                                }

                        }

                }

                if (readreg(dev, PP_AutoNegST) & FDX_ACTIVE)

                        printk("%s: using full duplex\n", dev->name);

                else

                        printk("%s: using half duplex\n", dev->name);

        }

        return A_CNF_MEDIA_10B_T;

}

/* send a test packet - return true if carrier bits are ok */

static int

send_test_pkt(struct device *dev)

{

        int ioaddr = dev->base_addr;

        char test_packet[] = { 0,0,0,0,0,0, 0,0,0,0,0,0,

                                 0, 46, /* A 46 in network order */

                                 0, 0, /* DSAP=0 & SSAP=0 fields */

                                 0xf3, 0 /* Control (Test Req + P bit set) */ };

        long timenow = jiffies;

        writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) | SERIAL_TX_ON);

        memcpy(test_packet,          dev->dev_addr, ETH_ALEN);

        memcpy(test_packet+ETH_ALEN, dev->dev_addr, ETH_ALEN);

        outw(TX_AFTER_ALL, ioaddr + (TX_CMD_PORT << ECARD_SHIFT));

        outw(ETH_ZLEN, ioaddr + (TX_LEN_PORT << ECARD_SHIFT));

        /* Test to see if the chip has allocated memory for the packet */

        while (jiffies - timenow < 5)

                if (readreg(dev, PP_BusST) & READY_FOR_TX_NOW)

                        break;

        if (jiffies - timenow >= 5)

                return 0;        /* this shouldn't happen */

        /* Write the contents of the packet */

        if (dev->mem_start) {

                memcpy((void *)dev->mem_start + PP_TxFrame, test_packet, ETH_ZLEN);

        } else {

                outsw(ioaddr + (TX_FRAME_PORT << ECARD_SHIFT),

                      test_packet,(ETH_ZLEN+1) >>1);

        }

        if (net_debug > 1) printk("Sending test packet ");

        /* wait a couple of jiffies for packet to be received */

        for (timenow = jiffies; jiffies - timenow < 3; )

                ;

        if ((readreg(dev, PP_TxEvent) & TX_SEND_OK_BITS) == TX_OK) {

                if (net_debug > 1) printk("succeeded\n");

                return 1;

        }

        if (net_debug > 1) printk("failed\n");

        return 0;

}

static int

detect_aui(struct device *dev)

{

        struct net_local *lp = (struct net_local *)dev->priv;

        if (net_debug > 1) printk("%s: Attempting AUI\n", dev->name);

        control_dc_dc(dev, 0);

        writereg(dev, PP_LineCTL, (lp->linectl &~ AUTO_AUI_10BASET) | AUI_ONLY);

        if (send_test_pkt(dev))

                return A_CNF_MEDIA_AUI;

        else

                return 0;

}

static int

detect_bnc(struct device *dev)

{

        struct net_local *lp = (struct net_local *)dev->priv;

        if (net_debug > 1) printk("%s: Attempting BNC\n", dev->name);

        control_dc_dc(dev, 1);

        writereg(dev, PP_LineCTL, (lp->linectl &~ AUTO_AUI_10BASET) | AUI_ONLY);

        if (send_test_pkt(dev))

                return A_CNF_MEDIA_10B_2;

        else

                return 0;

}

static void

write_irq(struct device *dev, int chip_type, int irq)

{

        int i;

        // we always write 0, as that is what the card is hardwired to

        if (chip_type == CS8900) {

                switch(irq) {

                case 10: i = 0; break;

                case 11: i = 1; break;

                case 12: i = 2; break;

                case 5: i =  3; break;

                default: i = 3; break;

                }

                writereg(dev, PP_CS8900_ISAINT, 0x0);

        } else {

                writereg(dev, PP_CS8920_ISAINT, 0x0);

        }

}

/* Open/initialize the board.  This is called (in the current kernel)

   sometime after booting when the 'ifconfig' program is run.

   This routine should set everything up anew at each open, even

   registers that "should" only need to be set once at boot, so that

   there is non-reboot way to recover if something goes wrong.

   */

static int

net_open(struct device *dev)

{

        struct net_local *lp = (struct net_local *)dev->priv;

        int result = 0;

        int i;

        if (dev->irq < 2) {

                /* Allow interrupts to be generated by the chip */

                writereg(dev, PP_BusCTL, ENABLE_IRQ | MEMORY_ON);

                for (i = 2; i < CS8920_NO_INTS; i++) if ((1 << dev->irq) & lp->irq_map) {

                        if (request_irq (i, NULL, 0, "cs8920", dev) != -EBUSY) {

                                write_irq(dev, lp->chip_type, i);

                                writereg(dev, PP_BufCFG, GENERATE_SW_INTERRUPT);

                                if (request_irq (dev->irq = i, &net_interrupt, 0, "cs89x0", dev) == 0)

                                        break;

                        }

                }

                if (i >= CS8920_NO_INTS) {

                        writereg(dev, PP_BusCTL, 0);     /* disable interrupts. */

                        return -EAGAIN;

                }

        } else {