Subversion Repositories or1k

/*------------------------------------------------------------------------

 . smc91111.c

 . This is a driver for SMSC's 91C111 single-chip Ethernet device.

 .

 . Copyright (C) 2001 Standard Microsystems Corporation (SMSC)

 .       Developed by Simple Network Magic Corporation (SNMC)

 . Copyright (C) 1996 by Erik Stahlman (ES)

 .

 . This program is free software; you can redistribute it and/or modify

 . it under the terms of the GNU General Public License as published by

 . the Free Software Foundation; either version 2 of the License, or

 . (at your option) any later version.

 .

 . This program is distributed in the hope that it will be useful,

 . but WITHOUT ANY WARRANTY; without even the implied warranty of

 . MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 . GNU General Public License for more details.

 .

 . You should have received a copy of the GNU General Public License

 . along with this program; if not, write to the Free Software

 . Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 .

 . Information contained in this file was obtained from the LAN91C111

 . manual from SMC.  To get a copy, if you really want one, you can find

 . information under www.smsc.com.

 .

 .

 . "Features" of the SMC chip:

 .   Integrated PHY/MAC for 10/100BaseT Operation

 .   Supports internal and external MII

 .   Integrated 8K packet memory

 .   EEPROM interface for configuration

 .

 . Arguments:

 .      io      = for the base address

 .      irq     = for the IRQ

 .      nowait  = 0 for normal wait states, 1 eliminates additional wait states

 .

 . author:

 .      Erik Stahlman                           ( erik@vt.edu )

 .      Daris A Nevil                           ( dnevil@snmc.com )

 .      Kendrick Hamilton                       ( hamilton@sedsystems.ca )

 .

 .

 . Hardware multicast code from Peter Cammaert ( pc@denkart.be )

 .

 . Sources:

 .    o   SMSC LAN91C111 databook (www.smsc.com)

 .    o   smc9194.c by Erik Stahlman

 .    o   skeleton.c by Donald Becker ( becker@cesdis.gsfc.nasa.gov )

 .

 . History:

 .      04/25/01  Daris A Nevil  Initial public release through SMSC

 .      03/16/01  Daris A Nevil  Modified smc9194.c for use with LAN91C111

 .      03/06/02  Greg Ungerer   Code to support ColdFire (M5249C3 board)

 ----------------------------------------------------------------------------*/

// Use power-down feature of the chip

#define POWER_DOWN   0

#define NO_AUTOPROBE 1

//Should be part of the automatic configuration

#define CONFIG_SMC91C111_EXTRA_DELAY 1

// Do you want to use 32 bit xfers?  This should work on all chips, as

// the chipset is designed to accommodate them.

/*OpenRISC 1200 uses 16 bits*/

#undef CONFIG_SMC91C111_32_BIT 

#if defined(CONFIG_SMC91C111_EXTRA_DELAY)

#define SMC91C111_EXTRA_DELAY 20

#endif

static const char version[] =

    "smc91111.c:v1.2 01/29/02 by ???\n";

#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/bitops.h>

#include <asm/io.h>

#include <asm/irq.h>

#include <linux/errno.h>

#include <linux/delay.h>

#include <linux/netdevice.h>

#include <linux/etherdevice.h>

#include <linux/skbuff.h>

//#define CONFIG_SYSCTL 1

#ifdef SMC_DEBUG

#undef SMC_DEBUG

#endif

#ifdef CONFIG_SYSCTL

#include <linux/proc_fs.h>

#include <linux/sysctl.h>

#endif

#include "smc91111.h"

//------------------------------------------------------------------------

//

// Configuration options, for the experienced user to change.

//

//------------------------------------------------------------------------

/*

 .the LAN91C111 can be at any of the following port addresses.  To change,

 .for a slightly different card, you can add it to the array.  Keep in

 .mind that the array must end in zero.

*/

static unsigned long int smc_portlist[] =

   { 0x92000000, 0};

#define SWAP16(x)  ((((x) & 0x00ff) << 8) | ( (x) >> 8))

/*

 . Wait time for memory to be free.  This probably shouldn't be

 . tuned that much, as waiting for this means nothing else happens

 . in the system

*/

#define MEMORY_WAIT_TIME 16

/*

 . DEBUGGING LEVELS

 .

 . 0 for normal operation

 . 1 for slightly more details

 . >2 for various levels of increasingly useless information

 .    2 for interrupt tracking, status flags

 .    3 for packet info

 .    4 for complete packet dumps

*/

#define SMC_DEBUG 0 // Must be defined in makefile

#if (SMC_DEBUG > 2 )

#define PRINTK3(args...) printk(args)

#else

#define PRINTK3(args...)

#endif

#if SMC_DEBUG > 1

#define PRINTK2(args...) printk(args)

#else

#define PRINTK2(args...)

#endif

#ifdef SMC_DEBUG

#define PRINTK(args...) printk(args)

#else

#define PRINTK(args...)

#endif

/*------------------------------------------------------------------------

 .

 . The internal workings of the driver.  If you are changing anything

 . here with the SMC stuff, you should have the datasheet and know

 . what you are doing.

 .

 -------------------------------------------------------------------------*/

#define CARDNAME "LAN91C111"

// Memory sizing constant

#define LAN91C111_MEMORY_MULTIPLIER     (1024*2)

/* store this information for the driver.. */

struct smc_local {

        // these are things that the kernel wants me to keep, so users

        // can find out semi-useless statistics of how well the card is

        // performing

        //struct net_device_stats stats;

        struct enet_statistics stats;

        // If I have to wait until memory is available to send

        // a packet, I will store the skbuff here, until I get the

        // desired memory.  Then, I'll send it out and free it.

        struct sk_buff * saved_skb;

        // This keeps track of how many packets that I have

        // sent out.  When an TX_EMPTY interrupt comes, I know

        // that all of these have been sent.

        int     packets_waiting;

        // Set to true during the auto-negotiation sequence

        int     autoneg_active;

        // Address of our PHY port

        word    phyaddr;

        // Type of PHY

        word    phytype;

        // Last contents of PHY Register 18

        word    lastPhy18;

        // Contains the current active transmission mode

        word    tcr_cur_mode;

        // Contains the current active receive mode

        word    rcr_cur_mode;

        // Contains the current active receive/phy mode

        word    rpc_cur_mode;

#ifdef CONFIG_SYSCTL

        // Root directory /proc/sys/dev

        // Second entry must be null to terminate the table

        ctl_table root_table[2];

        // Directory for this device /proc/sys/dev/ethX

        // Again the second entry must be zero to terminate

        ctl_table eth_table[2];

        // This is the parameters (file) table

        ctl_table param_table[CTL_SMC_LAST_ENTRY];

        // Saves the sysctl header returned by register_sysctl_table()

        // we send this to unregister_sysctl_table()

        struct ctl_table_header *sysctl_header;

        // Parameter variables (files) go here

        char ctl_info[1024];

        int ctl_swfdup;

        int ctl_ephloop;

        int ctl_miiop;

        int ctl_autoneg;

        int ctl_rfduplx;

        int ctl_rspeed;

        int ctl_afduplx;

        int ctl_aspeed;

        int ctl_lnkfail;

        int ctl_forcol;

        int ctl_filtcar;

        int ctl_freemem;

        int ctl_totmem;

        int ctl_leda;

        int ctl_ledb;

        int ctl_chiprev;

#ifdef SMC_DEBUG

        int ctl_reg_bsr;

        int ctl_reg_tcr;

        int ctl_reg_esr;

        int ctl_reg_rcr;

        int ctl_reg_ctrr;

        int ctl_reg_mir;

        int ctl_reg_rpcr;

        int ctl_reg_cfgr;

        int ctl_reg_bar;

        int ctl_reg_iar0;

        int ctl_reg_iar1;

        int ctl_reg_iar2;

        int ctl_reg_gpr;

        int ctl_reg_ctlr;

        int ctl_reg_mcr;

        int ctl_reg_pnr;

        int ctl_reg_fpr;

        int ctl_reg_ptr;

        int ctl_reg_dr;

        int ctl_reg_isr;

        int ctl_reg_mtr1;

        int ctl_reg_mtr2;

        int ctl_reg_mtr3;

        int ctl_reg_mtr4;

        int ctl_reg_miir;

        int ctl_reg_revr;

        int ctl_reg_ercvr;

        int ctl_reg_extr;

        int ctl_phy_ctrl;

        int ctl_phy_stat;

        int ctl_phy_id1;

        int ctl_phy_id2;

        int ctl_phy_adc;

        int ctl_phy_remc;

        int ctl_phy_cfg1;

        int ctl_phy_cfg2;

        int ctl_phy_int;

        int ctl_phy_mask;

#endif // SMC_DEBUG

#endif // CONFIG_SYSCTL

};

/*-----------------------------------------------------------------

 .

 .  The driver can be entered at any of the following entry points.

 .

 .------------------------------------------------------------------  */

/*

 . This is called by  register_netdev().  It is responsible for

 . checking the portlist for the SMC9000 series chipset.  If it finds

 . one, then it will initialize the device, find the hardware information,

 . and sets up the appropriate device parameters.

 . NOTE: Interrupts are *OFF* when this procedure is called.

 .

 . NB:This shouldn't be static since it is referred to externally.

*/

int smc_init_91C111(struct device *dev);

/*

 . This is called by  unregister_netdev().  It is responsible for

 . cleaning up before the driver is finally unregistered and discarded.

*/

void smc_91C111_destructor(struct device *dev);

/*

 . The kernel calls this function when someone wants to use the device,

 . typically 'ifconfig ethX up'.

*/

static int smc_open(struct device *dev);

/*

 . This is called by the kernel to send a packet out into the net.  it's

 . responsible for doing a best-effort send, but if it's simply not possible

 . to send it, the packet gets dropped.

*/

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

/*

 . This is called by the kernel in response to 'ifconfig ethX down'.  It

 . is responsible for cleaning up everything that the open routine

 . does, and maybe putting the card into a powerdown state.

*/

static int smc_close(struct device *dev);

/*

 . This routine allows the proc file system to query the driver's

 . statistics.

*/

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

/*

 . Finally, a call to set promiscuous mode ( for TCPDUMP and related

 . programs ) and multicast modes.

*/

static void smc_set_multicast_list(struct device *dev);

/*

 . Configures the PHY through the MII Management interface

*/

static void smc_phy_configure(struct device* dev);

void smc_register_dump(const struct device *dev);

/*---------------------------------------------------------------

 .

 . Interrupt level calls..

 .

 ----------------------------------------------------------------*/

/*

 . Handles the actual interrupt

*/

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

/*

 . This is a separate procedure to handle the receipt of a packet, to

 . leave the interrupt code looking slightly cleaner

*/

inline static void smc_rcv( struct device *dev );

/*

 . This handles a TX interrupt, which is only called when an error

 . relating to a packet is sent.

*/

inline static void smc_tx( struct device * dev );

/*

 . This handles interrupts generated from PHY register 18

*/

static void smc_phy_interrupt(struct device* dev);

/*

 ------------------------------------------------------------

 .

 . Internal routines

 .

 ------------------------------------------------------------

*/

/*

 . Test if a given location contains a chip, trying to cause as

 . little damage as possible if it's not a SMC chip.

*/

static int smc_probe( unsigned long ioaddr );

/*

 . this routine initializes the cards hardware, prints out the configuration

 . to the system log as well as the vanity message, and handles the setup

 . of a device parameter.

 . It will give an error if it can't initialize the card.

*/

static int smc_initcard( struct device *, unsigned long ioaddr );

static void smc_wait_ms(unsigned int ms);

/*

 . A rather simple routine to print out a packet for debugging purposes.

*/

#if SMC_DEBUG > 2

static void print_packet( byte *, int );

#endif

#define tx_done(dev) 1

/* this is called to actually send the packet to the chip */

static void smc_hardware_send_packet( struct device * dev );

/* Since I am not sure if I will have enough room in the chip's ram

 . to store the packet, I call this routine, which either sends it

 . now, or generates an interrupt when the card is ready for the

 . packet */

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

/* this does a soft reset on the device */

static void smc_reset( struct device* dev );

/* Enable Interrupts, Receive, and Transmit */

static void smc_enable( struct device *dev );

/* this puts the device in an inactive state */

static void smc_shutdown( unsigned long ioaddr );

#ifndef NO_AUTOPROBE

/* This routine will find the IRQ of the driver if one is not

 . specified in the input to the device.  */

static int smc_findirq( unsigned long ioaddr );

#endif

/*

  this routine will set the hardware multicast table to the specified

  values given it by the higher level routines

*/

static void smc_setmulticast( unsigned long ioaddr, int count,

        struct dev_mc_list *  );

static int crc32( char *, int );

/* Routines to Read and Write the PHY Registers across the

   MII Management Interface

*/

static word smc_read_phy_register(unsigned long ioaddr, byte phyaddr,

        byte phyreg);

static void smc_write_phy_register(unsigned long ioaddr,

        byte phyaddr, byte phyreg, word phydata);

#if 0

//Interpret the read data, only understands some registers, more need to be

// added.

static word smc_interpret_phy_register(const struct device *dev,

        byte phyreg, word status);

#endif

/*

  Initilizes our device's sysctl proc filesystem

*/

#ifdef CONFIG_SYSCTL

static void smc_sysctl_register(struct device *dev);

static void smc_sysctl_unregister(struct device *dev);

#endif /* CONFIG_SYSCTL */ 

/*

 . Function: smc_reset( struct device* dev )

 . Purpose:

 .      This sets the SMC91111 chip to its normal state, hopefully from whatever

 .      mess that any other DOS driver has put it in.

 .

 . Maybe I should reset more registers to defaults in here?  SOFTRST  should

 . do that for me.

 .

 . Method:

 .      1.  send a SOFT RESET

 .      2.  wait for it to finish

 .      3.  enable autorelease mode

 .      4.  reset the memory management unit

 .      5.  clear all interrupts

 .

*/

static void smc_reset( struct device* dev )

{

        //struct smc_local *lp  = (struct smc_local *)dev->priv;

        unsigned long   ioaddr = dev->base_addr;

        PRINTK2("%s:smc_reset\n", dev->name);

        /* This resets the registers mostly to defaults, but doesn't

           affect EEPROM.  That seems unnecessary */

        SMC_SELECT_BANK( 0 );

        outw( RCR_SOFTRST, ioaddr + RCR_REG );

        /* Setup the Configuration Register */

        /* This is necessary because the CONFIG_REG is not affected */

        /* by a soft reset */

        SMC_SELECT_BANK( 1 );

        outw( CONFIG_DEFAULT, ioaddr + CONFIG_REG);

        /* Setup for fast accesses if requested */

        /* If the card/system can't handle it then there will */

        /* be no recovery except for a hard reset or power cycle */

        if (dev->dma)

                outw( inw( ioaddr + CONFIG_REG ) | CONFIG_NO_WAIT,

                        ioaddr + CONFIG_REG );

        SMC_SELECT_BANK( 0 );

        /* this should pause enough for the chip to be happy */

        mdelay(10);

        /* Disable transmit and receive functionality */

        outw( RCR_CLEAR, ioaddr + RCR_REG );

        outw( TCR_CLEAR, ioaddr + TCR_REG );

        /* set the control register to automatically

           release successfully transmitted packets, to make the best

           use out of our limited memory */

        SMC_SELECT_BANK( 1 );

        outw( inw( ioaddr + CTL_REG ) | CTL_AUTO_RELEASE , ioaddr + CTL_REG );

        /* Reset the MMU */

        SMC_SELECT_BANK( 2 );

        outw( MC_RESET, ioaddr + MMU_CMD_REG );

        /* Note:  It doesn't seem that waiting for the MMU busy is needed here,

           but this is a place where future chipsets _COULD_ break.  Be wary

           of issuing another MMU command right after this */

        /* Disable all interrupts */

        outb( 0, ioaddr + IM_REG );

}

/*

 . Function: smc_enable

 . Purpose: let the chip talk to the outside work

 . Method:

 .      1.  Enable the transmitter

 .      2.  Enable the receiver

 .      3.  Enable interrupts

*/

static void smc_enable( struct device *dev )

{

        unsigned long ioaddr    = dev->base_addr;

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

        PRINTK2("%s:smc_enable\n", dev->name);

        SMC_SELECT_BANK( 0 );

        /* see the header file for options in TCR/RCR DEFAULT*/

        outw( lp->tcr_cur_mode, ioaddr + TCR_REG );

        outw( lp->rcr_cur_mode, ioaddr + RCR_REG );

        /* now, enable interrupts */

        SMC_SELECT_BANK( 2 );

        outb( SMC_INTERRUPT_MASK, ioaddr + IM_REG );

}

/*

 . Function: smc_shutdown

 . Purpose:  closes down the SMC91xxx chip.

 . Method:

 .      1. zero the interrupt mask

 .      2. clear the enable receive flag

 .      3. clear the enable xmit flags

 .

 . TODO:

 .   (1) maybe utilize power down mode.

 .      Why not yet?  Because while the chip will go into power down mode,

 .      the manual says that it will wake up in response to any I/O requests

 .      in the register space.   Empirical results do not show this working.

*/

static void smc_shutdown( unsigned long ioaddr )

{

        PRINTK2(CARDNAME":smc_shutdown\n");

        /* no more interrupts for me */

        SMC_SELECT_BANK( 2 );

        outb( 0, ioaddr + IM_REG );

        /* and tell the card to stay away from that nasty outside world */

        SMC_SELECT_BANK( 0 );

        outb( RCR_CLEAR, ioaddr + RCR_REG );

        outb( TCR_CLEAR, ioaddr + TCR_REG );

#ifdef POWER_DOWN

        /* finally, shut the chip down */

        SMC_SELECT_BANK( 1 );

        outw( inw( ioaddr + CONFIG_REG ) & ~CONFIG_EPH_POWER_EN,

                ioaddr + CONFIG_REG  );

#endif

}

/*

 . Function: smc_setmulticast( int ioaddr, int count, dev_mc_list * adds )

 . Purpose:

 .    This sets the internal hardware table to filter out unwanted multicast

 .    packets before they take up memory.

 .

 .    The SMC chip uses a hash table where the high 6 bits of the CRC of

 .    address are the offset into the table.  If that bit is 1, then the

 .    multicast packet is accepted.  Otherwise, it's dropped silently.

 .

 .    To use the 6 bits as an offset into the table, the high 3 bits are the

 .    number of the 8 bit register, while the low 3 bits are the bit within

 .    that register.

 .

 . This routine is based very heavily on the one provided by Peter Cammaert.

*/

static void smc_setmulticast( unsigned long ioaddr, int count,

        struct dev_mc_list * addrs )

{

        int                     i;

        unsigned char           multicast_table[ 8 ];

        struct dev_mc_list      * cur_addr;

        /* table for flipping the order of 3 bits */

        unsigned char invert3[] = { 0, 4, 2, 6, 1, 5, 3, 7 };

        PRINTK2(CARDNAME":smc_setmulticast\n");

        /* start with a table of all zeros: reject all */

        memset( multicast_table, 0, sizeof( multicast_table ) );

        cur_addr = addrs;

        for ( i = 0; i < count ; i ++, cur_addr = cur_addr->next  ) {

                int position;

                /* do we have a pointer here? */

                if ( !cur_addr )

                        break;

                /* make sure this is a multicast address - shouldn't this

                   be a given if we have it here ? */

                if ( !( *cur_addr->dmi_addr & 1 ) )

                        continue;

                /* only use the low order bits */

                position = crc32( cur_addr->dmi_addr, 6 ) & 0x3f;

                /* do some messy swapping to put the bit in the right spot */

                multicast_table[invert3[position&7]] |=

                                        (1<<invert3[(position>>3)&7]);

        }

        /* now, the table can be loaded into the chipset */

        SMC_SELECT_BANK( 3 );

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

                outb( multicast_table[i], ioaddr + MCAST_REG1 + i );

        }

}

/*

  Finds the CRC32 of a set of bytes.

  Again, from Peter Cammaert's code.

*/

static int crc32( char * s, int length ) {

        /* indices */

        int perByte;

        int perBit;

        /* crc polynomial for Ethernet */

        const unsigned long poly = 0xedb88320;

        /* crc value - preinitialized to all 1's */

        unsigned long crc_value = 0xffffffff;

        for ( perByte = 0; perByte < length; perByte ++ ) {

                unsigned char   c;

                c = *(s++);

                for ( perBit = 0; perBit < 8; perBit++ ) {

                        crc_value = (crc_value>>1)^

                                (((crc_value^c)&0x01)?poly:0);

                        c >>= 1;

                }

        }

        return  crc_value;

}

/*

 . Function: smc_wait_to_send_packet( struct sk_buff * skb, struct device * )

 . Purpose:

 .    Attempt to allocate memory for a packet, if chip-memory is not

 .    available, then tell the card to generate an interrupt when it

 .    is available.

 .

 . Algorithm:

 .

 . o    if the saved_skb is not currently null, then drop this packet

 .      on the floor.  This should never happen, because of TBUSY.

 . o    if the saved_skb is null, then replace it with the current packet,

 . o    See if I can sending it now.

 . o    (NO): Enable interrupts and let the interrupt handler deal with it.

 . o    (YES):Send it now.

*/

static int smc_wait_to_send_packet( struct sk_buff * skb, struct device * dev )

{

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

    unsigned long   ioaddr          = dev->base_addr;

    word            length;

    unsigned short  numPages;

    word            time_out;

    word            status;

    PRINTK3("%s:smc_wait_to_send_packet\n", dev->name);

    if (lp->saved_skb)

    {

        // THIS SHOULD NEVER HAPPEN.

        lp->stats.tx_aborted_errors++;

        printk("%s: Bad Craziness - sent packet while busy.\n", dev->name);

        return 1;

    }

    lp->saved_skb = skb;

    length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;

    //

    // The MMU wants the number of pages to be the number of 256 bytes

    // 'pages', minus 1 ( since a packet can't ever have 0 pages :) )

    //

    // The 91C111 ignores the size bits, but the code is left intact

    // for backwards and future compatibility.

    //

    // Pkt size for allocating is data length +6 (for additional status

    // words, length and ctl!)

    //

    // If odd size then last byte is included in this header.

    //

    numPages =   ((length & 0xfffe) + 6);

    numPages >>= 8; // Divide by 256

    if (numPages > 7 )

    {

        printk("%s: Far too big packet error. \n", dev->name);

        // freeing the packet is a good thing here... but should

        // . any packets of this size get down here?

        dev_kfree_skb (skb,FREE_WRITE);

        lp->saved_skb = NULL;

        // this IS an error, but, i don't want the skb saved

        return 0;

    }

        // either way, a packet is waiting now

    lp->packets_waiting++;

    // now, try to allocate the memory

    SMC_SELECT_BANK( 2 );

    outw( MC_ALLOC | numPages, ioaddr + MMU_CMD_REG );

    //

    // Performance Hack