[deliverable/linux.git] / drivers / net / mac89x0.c

/* mac89x0.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 General 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.

  David Huggins-Daines <dhd@debian.org>

  Split this off into mac89x0.c, and gutted it of all parts which are
  not relevant to the existing CS8900 cards on the Macintosh
  (i.e. basically the Daynaport CS and LC cards).  To be precise:

    * Removed all the media-detection stuff, because these cards are
    TP-only.

    * Lobotomized the ISA interrupt bogosity, because these cards use
    a hardwired NuBus interrupt and a magic ISAIRQ value in the card.

    * Basically eliminated everything not relevant to getting the
    cards minimally functioning on the Macintosh.

  I might add that these cards are badly designed even from the Mac
  standpoint, in that Dayna, in their infinite wisdom, used NuBus slot
  I/O space and NuBus interrupts for these cards, but neglected to
  provide anything even remotely resembling a NuBus ROM.  Therefore we
  have to probe for them in a brain-damaged ISA-like fashion.

  Arnaldo Carvalho de Melo <acme@conectiva.com.br> - 11/01/2001
  check kmalloc and release the allocated memory on failure in
  mac89x0_probe and in init_module
  use local_irq_{save,restore}(flags) in net_get_stat, not just
  local_irq_{dis,en}able()
*/

static char *version =
"cs89x0.c:v1.02 11/26/96 Russell Nelson <nelson@crynwr.com>\n";

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

/* use 0 for production, 1 for verification, >2 for debug */
#ifndef NET_DEBUG
#define NET_DEBUG 0
#endif

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


/* Always include 'config.h' first in case the user wants to turn on
   or override something. */
#include <linux/module.h>

#define PRINTK(x) printk x

/*
  Sources:

	Crynwr packet driver epktisa.

	Crystal Semiconductor data sheets.

*/

#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/fcntl.h>
#include <linux/interrupt.h>
#include <linux/ioport.h>
#include <linux/in.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/nubus.h>
#include <linux/errno.h>
#include <linux/init.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/skbuff.h>
#include <linux/delay.h>
#include <linux/bitops.h>

#include <asm/system.h>
#include <asm/io.h>
#include <asm/hwtest.h>
#include <asm/macints.h>

#include "cs89x0.h"

static unsigned int net_debug = NET_DEBUG;

/* Information that need to be kept for each board. */
struct net_local {
	struct net_device_stats stats;
	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 rx_mode;
	int curr_rx_cfg;
        int send_underrun;      /* keep track of how many underruns in a row we get */
	struct sk_buff *skb;
};

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

#if 0
extern void reset_chip(struct net_device *dev);
#endif
static int net_open(struct net_device *dev);
static int net_send_packet(struct sk_buff *skb, struct net_device *dev);
static irqreturn_t net_interrupt(int irq, void *dev_id);
static void set_multicast_list(struct net_device *dev);
static void net_rx(struct net_device *dev);
static int net_close(struct net_device *dev);
static struct net_device_stats *net_get_stats(struct net_device *dev);
static int set_mac_address(struct net_device *dev, void *addr);


/* Example routines you must write ;->. */
#define tx_done(dev) 1

/* For reading/writing registers ISA-style */
static inline int
readreg_io(struct net_device *dev, int portno)
{
	nubus_writew(swab16(portno), dev->base_addr + ADD_PORT);
	return swab16(nubus_readw(dev->base_addr + DATA_PORT));
}

static inline void
writereg_io(struct net_device *dev, int portno, int value)
{
	nubus_writew(swab16(portno), dev->base_addr + ADD_PORT);
	nubus_writew(swab16(value), dev->base_addr + DATA_PORT);
}

/* These are for reading/writing registers in shared memory */
static inline int
readreg(struct net_device *dev, int portno)
{
	return swab16(nubus_readw(dev->mem_start + portno));
}

static inline void
writereg(struct net_device *dev, int portno, int value)
{
	nubus_writew(swab16(value), dev->mem_start + portno);
}

static const struct net_device_ops mac89x0_netdev_ops = {
	.ndo_open		= net_open,
	.ndo_stop		= net_close,
	.ndo_start_xmit		= net_send_packet,
	.ndo_get_stats		= net_get_stats,
	.ndo_set_multicast_list	= set_multicast_list,
	.ndo_set_mac_address	= set_mac_address,
	.ndo_validate_addr	= eth_validate_addr,
	.ndo_change_mtu		= eth_change_mtu,
};

/* Probe for the CS8900 card in slot E.  We won't bother looking
   anywhere else until we have a really good reason to do so. */
struct net_device * __init mac89x0_probe(int unit)
{
	struct net_device *dev;
	static int once_is_enough;
	struct net_local *lp;
	static unsigned version_printed;
	int i, slot;
	unsigned rev_type = 0;
	unsigned long ioaddr;
	unsigned short sig;
	int err = -ENODEV;

	if (!MACH_IS_MAC)
		return ERR_PTR(-ENODEV);

	dev = alloc_etherdev(sizeof(struct net_local));
	if (!dev)
		return ERR_PTR(-ENOMEM);

	if (unit >= 0) {
		sprintf(dev->name, "eth%d", unit);
		netdev_boot_setup_check(dev);
	}

	if (once_is_enough)
		goto out;
	once_is_enough = 1;

	/* We might have to parameterize this later */
	slot = 0xE;
	/* Get out now if there's a real NuBus card in slot E */
	if (nubus_find_slot(slot, NULL) != NULL)
		goto out;

	/* The pseudo-ISA bits always live at offset 0x300 (gee,
           wonder why...) */
	ioaddr = (unsigned long)
		nubus_slot_addr(slot) | (((slot&0xf) << 20) + DEFAULTIOBASE);
	{
		unsigned long flags;
		int card_present;

		local_irq_save(flags);
		card_present = hwreg_present((void*) ioaddr+4)
		  && hwreg_present((void*) ioaddr + DATA_PORT);
		local_irq_restore(flags);

		if (!card_present)
			goto out;
	}

	nubus_writew(0, ioaddr + ADD_PORT);
	sig = nubus_readw(ioaddr + DATA_PORT);
	if (sig != swab16(CHIP_EISA_ID_SIG))
		goto out;

	/* Initialize the net_device structure. */
	lp = netdev_priv(dev);

	/* Fill in the 'dev' fields. */
	dev->base_addr = ioaddr;
	dev->mem_start = (unsigned long)
		nubus_slot_addr(slot) | (((slot&0xf) << 20) + MMIOBASE);
	dev->mem_end = dev->mem_start + 0x1000;

	/* Turn on shared memory */
	writereg_io(dev, PP_BusCTL, MEMORY_ON);

	/* 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(KERN_INFO "%s: cs89%c0%s rev %c found at %#8lx",
	       dev->name,
	       lp->chip_type==CS8900?'0':'2',
	       lp->chip_type==CS8920M?"M":"",
	       lp->chip_revision,
	       dev->base_addr);

	/* Try to read the MAC address */
	if ((readreg(dev, PP_SelfST) & (EEPROM_PRESENT | EEPROM_OK)) == 0) {
		printk("\nmac89x0: No EEPROM, giving up now.\n");
		goto out1;
        } else {
                for (i = 0; i < ETH_ALEN; i += 2) {
			/* Big-endian (why??!) */
			unsigned short s = readreg(dev, PP_IA + i);
                        dev->dev_addr[i] = s >> 8;
                        dev->dev_addr[i+1] = s & 0xff;
                }
        }

	dev->irq = SLOT2IRQ(slot);

	/* print the IRQ and ethernet address. */

	printk(" IRQ %d ADDR %pM\n", dev->irq, dev->dev_addr);

	dev->netdev_ops		= &mac89x0_netdev_ops;

	err = register_netdev(dev);
	if (err)
		goto out1;
	return NULL;
out1:
	nubus_writew(0, dev->base_addr + ADD_PORT);
out:
	free_netdev(dev);
	return ERR_PTR(err);
}

#if 0
/* This is useful for something, but I don't know what yet. */
void __init reset_chip(struct net_device *dev)
{
	int reset_start_time;

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

	/* wait 30 ms */
	msleep_interruptible(30);

	/* Wait until the chip is reset */
	reset_start_time = jiffies;
	while( (readreg(dev, PP_SelfST) & INIT_DONE) == 0 && jiffies - reset_start_time < 2)
		;
}
#endif

/* 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 net_device *dev)
{
	struct net_local *lp = netdev_priv(dev);
	int i;

	/* Disable the interrupt for now */
	writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL) & ~ENABLE_IRQ);

	/* Grab the interrupt */
	if (request_irq(dev->irq, &net_interrupt, 0, "cs89x0", dev))
		return -EAGAIN;

	/* Set up the IRQ - Apparently magic */
	if (lp->chip_type == CS8900)
		writereg(dev, PP_CS8900_ISAINT, 0);
	else
		writereg(dev, PP_CS8920_ISAINT, 0);

	/* set the Ethernet address */
	for (i=0; i < ETH_ALEN/2; i++)
		writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] << 8));

	/* Turn on both receive and transmit operations */
	writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) | SERIAL_RX_ON | SERIAL_TX_ON);

	/* Receive only error free packets addressed to this card */
	lp->rx_mode = 0;
	writereg(dev, PP_RxCTL, DEF_RX_ACCEPT);

	lp->curr_rx_cfg = RX_OK_ENBL | RX_CRC_ERROR_ENBL;

	writereg(dev, PP_RxCFG, lp->curr_rx_cfg);

	writereg(dev, PP_TxCFG, TX_LOST_CRS_ENBL | TX_SQE_ERROR_ENBL | TX_OK_ENBL |
	       TX_LATE_COL_ENBL | TX_JBR_ENBL | TX_ANY_COL_ENBL | TX_16_COL_ENBL);

	writereg(dev, PP_BufCFG, READY_FOR_TX_ENBL | RX_MISS_COUNT_OVRFLOW_ENBL |
		 TX_COL_COUNT_OVRFLOW_ENBL | TX_UNDERRUN_ENBL);

	/* now that we've got our act together, enable everything */
	writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL) | ENABLE_IRQ);
	netif_start_queue(dev);
	return 0;
}

static int
net_send_packet(struct sk_buff *skb, struct net_device *dev)
{
	struct net_local *lp = netdev_priv(dev);
	unsigned long flags;

	if (net_debug > 3)
		printk("%s: sent %d byte packet of type %x\n",
		       dev->name, skb->len,
		       (skb->data[ETH_ALEN+ETH_ALEN] << 8)
		       | skb->data[ETH_ALEN+ETH_ALEN+1]);

	/* keep the upload from being interrupted, since we
	   ask the chip to start transmitting before the
	   whole packet has been completely uploaded. */
	local_irq_save(flags);
	netif_stop_queue(dev);

	/* initiate a transmit sequence */
	writereg(dev, PP_TxCMD, lp->send_cmd);
	writereg(dev, PP_TxLength, skb->len);

	/* Test to see if the chip has allocated memory for the packet */
	if ((readreg(dev, PP_BusST) & READY_FOR_TX_NOW) == 0) {
		/* Gasp!  It hasn't.  But that shouldn't happen since
		   we're waiting for TxOk, so return 1 and requeue this packet. */
		local_irq_restore(flags);
		return 1;
	}

	/* Write the contents of the packet */
	skb_copy_from_linear_data(skb, (void *)(dev->mem_start + PP_TxFrame),
				  skb->len+1);

	local_irq_restore(flags);
	dev->trans_start = jiffies;
	dev_kfree_skb (skb);

	return 0;
}

/* The typical workload of the driver:
   Handle the network interface interrupts. */
static irqreturn_t net_interrupt(int irq, void *dev_id)
{
	struct net_device *dev = dev_id;
	struct net_local *lp;
	int ioaddr, status;

	if (dev == NULL) {
		printk ("net_interrupt(): irq %d for unknown device.\n", irq);
		return IRQ_NONE;
	}

	ioaddr = dev->base_addr;
	lp = netdev_priv(dev);

	/* we MUST read all the events out of the ISQ, otherwise we'll never
           get interrupted again.  As a consequence, we can't have any limit
           on the number of times we loop in the interrupt handler.  The
           hardware guarantees that eventually we'll run out of events.  Of
           course, if you're on a slow machine, and packets are arriving
           faster than you can read them off, you're screwed.  Hasta la
           vista, baby!  */
	while ((status = swab16(nubus_readw(dev->base_addr + ISQ_PORT)))) {
		if (net_debug > 4)printk("%s: event=%04x\n", dev->name, status);
		switch(status & ISQ_EVENT_MASK) {
		case ISQ_RECEIVER_EVENT:
			/* Got a packet(s). */
			net_rx(dev);
			break;
		case ISQ_TRANSMITTER_EVENT:
			lp->stats.tx_packets++;
			netif_wake_queue(dev);
			if ((status & TX_OK) == 0) lp->stats.tx_errors++;
			if (status & TX_LOST_CRS) lp->stats.tx_carrier_errors++;
			if (status & TX_SQE_ERROR) lp->stats.tx_heartbeat_errors++;
			if (status & TX_LATE_COL) lp->stats.tx_window_errors++;
			if (status & TX_16_COL) lp->stats.tx_aborted_errors++;
			break;
		case ISQ_BUFFER_EVENT:
			if (status & READY_FOR_TX) {
				/* we tried to transmit a packet earlier,
                                   but inexplicably ran out of buffers.
                                   That shouldn't happen since we only ever
                                   load one packet.  Shrug.  Do the right
                                   thing anyway. */
				netif_wake_queue(dev);
			}
			if (status & TX_UNDERRUN) {
				if (net_debug > 0) printk("%s: transmit underrun\n", dev->name);
                                lp->send_underrun++;
                                if (lp->send_underrun == 3) lp->send_cmd = TX_AFTER_381;
                                else if (lp->send_underrun == 6) lp->send_cmd = TX_AFTER_ALL;
                        }
			break;
		case ISQ_RX_MISS_EVENT:
			lp->stats.rx_missed_errors += (status >>6);
			break;
		case ISQ_TX_COL_EVENT:
			lp->stats.collisions += (status >>6);
			break;
		}
	}
	return IRQ_HANDLED;
}

/* We have a good packet(s), get it/them out of the buffers. */
static void
net_rx(struct net_device *dev)
{
	struct net_local *lp = netdev_priv(dev);
	struct sk_buff *skb;
	int status, length;

	status = readreg(dev, PP_RxStatus);
	if ((status & RX_OK) == 0) {
		lp->stats.rx_errors++;
		if (status & RX_RUNT) lp->stats.rx_length_errors++;
		if (status & RX_EXTRA_DATA) lp->stats.rx_length_errors++;
		if (status & RX_CRC_ERROR) if (!(status & (RX_EXTRA_DATA|RX_RUNT)))
			/* per str 172 */
			lp->stats.rx_crc_errors++;
		if (status & RX_DRIBBLE) lp->stats.rx_frame_errors++;
		return;
	}

	length = readreg(dev, PP_RxLength);
	/* Malloc up new buffer. */
	skb = alloc_skb(length, GFP_ATOMIC);
	if (skb == NULL) {
		printk("%s: Memory squeeze, dropping packet.\n", dev->name);
		lp->stats.rx_dropped++;
		return;
	}
	skb_put(skb, length);

	skb_copy_to_linear_data(skb, (void *)(dev->mem_start + PP_RxFrame),
				length);

	if (net_debug > 3)printk("%s: received %d byte packet of type %x\n",
                                 dev->name, length,
                                 (skb->data[ETH_ALEN+ETH_ALEN] << 8)
				 | skb->data[ETH_ALEN+ETH_ALEN+1]);

        skb->protocol=eth_type_trans(skb,dev);
	netif_rx(skb);
	lp->stats.rx_packets++;
	lp->stats.rx_bytes += length;
}

/* The inverse routine to net_open(). */
static int
net_close(struct net_device *dev)
{

	writereg(dev, PP_RxCFG, 0);
	writereg(dev, PP_TxCFG, 0);
	writereg(dev, PP_BufCFG, 0);
	writereg(dev, PP_BusCTL, 0);

	netif_stop_queue(dev);

	free_irq(dev->irq, dev);

	/* Update the statistics here. */

	return 0;

}

/* Get the current statistics.	This may be called with the card open or
   closed. */
static struct net_device_stats *
net_get_stats(struct net_device *dev)
{
	struct net_local *lp = netdev_priv(dev);
	unsigned long flags;

	local_irq_save(flags);
	/* Update the statistics from the device registers. */
	lp->stats.rx_missed_errors += (readreg(dev, PP_RxMiss) >> 6);
	lp->stats.collisions += (readreg(dev, PP_TxCol) >> 6);
	local_irq_restore(flags);

	return &lp->stats;
}

static void set_multicast_list(struct net_device *dev)
{
	struct net_local *lp = netdev_priv(dev);

	if(dev->flags&IFF_PROMISC)
	{
		lp->rx_mode = RX_ALL_ACCEPT;
	}
	else if((dev->flags&IFF_ALLMULTI)||dev->mc_list)
	{
		/* The multicast-accept list is initialized to accept-all, and we
		   rely on higher-level filtering for now. */
		lp->rx_mode = RX_MULTCAST_ACCEPT;
	}
	else
		lp->rx_mode = 0;

	writereg(dev, PP_RxCTL, DEF_RX_ACCEPT | lp->rx_mode);

	/* in promiscuous mode, we accept errored packets, so we have to enable interrupts on them also */
	writereg(dev, PP_RxCFG, lp->curr_rx_cfg |
	     (lp->rx_mode == RX_ALL_ACCEPT? (RX_CRC_ERROR_ENBL|RX_RUNT_ENBL|RX_EXTRA_DATA_ENBL) : 0));
}


static int set_mac_address(struct net_device *dev, void *addr)
{
	int i;
	printk("%s: Setting MAC address to ", dev->name);
	for (i = 0; i < 6; i++)
		printk(" %2.2x", dev->dev_addr[i] = ((unsigned char *)addr)[i]);
	printk(".\n");
	/* set the Ethernet address */
	for (i=0; i < ETH_ALEN/2; i++)
		writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] << 8));

	return 0;
}

#ifdef MODULE

static struct net_device *dev_cs89x0;
static int debug;

module_param(debug, int, 0);
MODULE_PARM_DESC(debug, "CS89[02]0 debug level (0-5)");
MODULE_LICENSE("GPL");

int __init
init_module(void)
{
	net_debug = debug;
        dev_cs89x0 = mac89x0_probe(-1);
	if (IS_ERR(dev_cs89x0)) {
                printk(KERN_WARNING "mac89x0.c: No card found\n");
		return PTR_ERR(dev_cs89x0);
	}
	return 0;
}

void
cleanup_module(void)
{
	unregister_netdev(dev_cs89x0);
	nubus_writew(0, dev_cs89x0->base_addr + ADD_PORT);
	free_netdev(dev_cs89x0);
}
#endif /* MODULE */
Commit	Line	Data
1da177e4 LT	1	/* mac89x0.c: A Crystal Semiconductor CS89[02]0 driver for linux. */
	2	/*
	3	Written 1996 by Russell Nelson, with reference to skeleton.c
	4	written 1993-1994 by Donald Becker.
	5
	6	This software may be used and distributed according to the terms
	7	of the GNU General Public License, incorporated herein by reference.
	8
	9	The author may be reached at nelson@crynwr.com, Crynwr
	10	Software, 11 Grant St., Potsdam, NY 13676
	11
	12	Changelog:
	13
	14	Mike Cruse : mcruse@cti-ltd.com
6aa20a22	15	: Changes for Linux 2.0 compatibility.
1da177e4 LT	16	: Added dev_id parameter in net_interrupt(),
	17	: request_irq() and free_irq(). Just NULL for now.
	18
	19	Mike Cruse : Added MOD_INC_USE_COUNT and MOD_DEC_USE_COUNT macros
	20	: in net_open() and net_close() so kerneld would know
6aa20a22	21	: that the module is in use and wouldn't eject the
1da177e4 LT	22	: driver prematurely.
	23
	24	Mike Cruse : Rewrote init_module() and cleanup_module using 8390.c
	25	: as an example. Disabled autoprobing in init_module(),
	26	: not a good thing to do to other devices while Linux
	27	: is running from all accounts.
6aa20a22	28
1da177e4 LT	29	Alan Cox : Removed 1.2 support, added 2.1 extra counters.
	30
	31	David Huggins-Daines <dhd@debian.org>
6aa20a22	32
1da177e4 LT	33	Split this off into mac89x0.c, and gutted it of all parts which are
	34	not relevant to the existing CS8900 cards on the Macintosh
	35	(i.e. basically the Daynaport CS and LC cards). To be precise:
	36
	37	* Removed all the media-detection stuff, because these cards are
	38	TP-only.
	39
	40	* Lobotomized the ISA interrupt bogosity, because these cards use
	41	a hardwired NuBus interrupt and a magic ISAIRQ value in the card.
	42
	43	* Basically eliminated everything not relevant to getting the
	44	cards minimally functioning on the Macintosh.
	45
	46	I might add that these cards are badly designed even from the Mac
	47	standpoint, in that Dayna, in their infinite wisdom, used NuBus slot
	48	I/O space and NuBus interrupts for these cards, but neglected to
	49	provide anything even remotely resembling a NuBus ROM. Therefore we
	50	have to probe for them in a brain-damaged ISA-like fashion.
	51
	52	Arnaldo Carvalho de Melo <acme@conectiva.com.br> - 11/01/2001
	53	check kmalloc and release the allocated memory on failure in
	54	mac89x0_probe and in init_module
	55	use local_irq_{save,restore}(flags) in net_get_stat, not just
	56	local_irq_{dis,en}able()
	57	*/
	58
	59	static char *version =
	60	"cs89x0.c:v1.02 11/26/96 Russell Nelson <nelson@crynwr.com>\n";
	61
	62	/* ======================= configure the driver here ======================= */
	63
	64	/* use 0 for production, 1 for verification, >2 for debug */
	65	#ifndef NET_DEBUG
	66	#define NET_DEBUG 0
	67	#endif
	68
	69	/* ======================= end of configuration ======================= */
	70
	71
	72	/* Always include 'config.h' first in case the user wants to turn on
	73	or override something. */
	74	#include <linux/module.h>
	75
	76	#define PRINTK(x) printk x
	77
	78	/*
	79	Sources:
	80
	81	Crynwr packet driver epktisa.
	82
	83	Crystal Semiconductor data sheets.
	84
	85	*/
	86
	87	#include <linux/kernel.h>
	88	#include <linux/types.h>
	89	#include <linux/fcntl.h>
	90	#include <linux/interrupt.h>
	91	#include <linux/ioport.h>
	92	#include <linux/in.h>
	93	#include <linux/slab.h>
	94	#include <linux/string.h>
	95	#include <linux/nubus.h>
	96	#include <linux/errno.h>
97	#include <linux/init.h>
98	#include <linux/netdevice.h>
99	#include <linux/etherdevice.h>
100	#include <linux/skbuff.h>
101	#include <linux/delay.h>
1977f032	102	#include <linux/bitops.h>
1da177e4 LT	103
1da177e4 LT	104	#include <asm/system.h>
1da177e4 LT	105	#include <asm/io.h>
	106	#include <asm/hwtest.h>
	107	#include <asm/macints.h>
	108
	109	#include "cs89x0.h"
	110
	111	static unsigned int net_debug = NET_DEBUG;
	112
	113	/* Information that need to be kept for each board. */
	114	struct net_local {
	115	struct net_device_stats stats;
	116	int chip_type; /* one of: CS8900, CS8920, CS8920M */
	117	char chip_revision; /* revision letter of the chip ('A'...) */
	118	int send_cmd; /* the propercommand used to send a packet. */
	119	int rx_mode;
	120	int curr_rx_cfg;
	121	int send_underrun; /* keep track of how many underruns in a row we get */
	122	struct sk_buff *skb;
	123	};
	124
	125	/* Index to functions, as function prototypes. */
	126
	127	#if 0
	128	extern void reset_chip(struct net_device *dev);
	129	#endif
	130	static int net_open(struct net_device *dev);
39ad2cb3	131	static int net_send_packet(struct sk_buff skb, struct net_device dev);
7d12e780	132	static irqreturn_t net_interrupt(int irq, void *dev_id);
1da177e4 LT	133	static void set_multicast_list(struct net_device *dev);
	134	static void net_rx(struct net_device *dev);
	135	static int net_close(struct net_device *dev);
	136	static struct net_device_stats net_get_stats(struct net_device dev);
	137	static int set_mac_address(struct net_device dev, void addr);
	138
	139
	140	/* Example routines you must write ;->. */
	141	#define tx_done(dev) 1
	142
	143	/* For reading/writing registers ISA-style */
	144	static inline int
	145	readreg_io(struct net_device *dev, int portno)
	146	{
	147	nubus_writew(swab16(portno), dev->base_addr + ADD_PORT);
	148	return swab16(nubus_readw(dev->base_addr + DATA_PORT));
	149	}
	150
	151	static inline void
	152	writereg_io(struct net_device *dev, int portno, int value)
	153	{
	154	nubus_writew(swab16(portno), dev->base_addr + ADD_PORT);
	155	nubus_writew(swab16(value), dev->base_addr + DATA_PORT);
	156	}
	157
	158	/* These are for reading/writing registers in shared memory */
	159	static inline int
	160	readreg(struct net_device *dev, int portno)
	161	{
	162	return swab16(nubus_readw(dev->mem_start + portno));
	163	}
	164
	165	static inline void
	166	writereg(struct net_device *dev, int portno, int value)
	167	{
	168	nubus_writew(swab16(value), dev->mem_start + portno);
	169	}
	170
d0174aea AB	171	static const struct net_device_ops mac89x0_netdev_ops = {
	172	.ndo_open = net_open,
	173	.ndo_stop = net_close,
	174	.ndo_start_xmit = net_send_packet,
	175	.ndo_get_stats = net_get_stats,
	176	.ndo_set_multicast_list = set_multicast_list,
	177	.ndo_set_mac_address = set_mac_address,
	178	.ndo_validate_addr = eth_validate_addr,
	179	.ndo_change_mtu = eth_change_mtu,
	180	};
	181
1da177e4 LT	182	/* Probe for the CS8900 card in slot E. We won't bother looking
	183	anywhere else until we have a really good reason to do so. */
	184	struct net_device * __init mac89x0_probe(int unit)
	185	{
	186	struct net_device *dev;
	187	static int once_is_enough;
	188	struct net_local *lp;
	189	static unsigned version_printed;
	190	int i, slot;
	191	unsigned rev_type = 0;
	192	unsigned long ioaddr;
	193	unsigned short sig;
	194	int err = -ENODEV;
	195
0f734484 GU	196	if (!MACH_IS_MAC)
	197	return ERR_PTR(-ENODEV);
	198
1da177e4 LT	199	dev = alloc_etherdev(sizeof(struct net_local));
	200	if (!dev)
	201	return ERR_PTR(-ENOMEM);
	202
	203	if (unit >= 0) {
	204	sprintf(dev->name, "eth%d", unit);
	205	netdev_boot_setup_check(dev);
	206	}
	207
1da177e4 LT	208	if (once_is_enough)
	209	goto out;
	210	once_is_enough = 1;
	211
	212	/* We might have to parameterize this later */
	213	slot = 0xE;
	214	/* Get out now if there's a real NuBus card in slot E */
	215	if (nubus_find_slot(slot, NULL) != NULL)
	216	goto out;
	217
	218	/* The pseudo-ISA bits always live at offset 0x300 (gee,
	219	wonder why...) */
	220	ioaddr = (unsigned long)
	221	nubus_slot_addr(slot) \| (((slot&0xf) << 20) + DEFAULTIOBASE);
	222	{
	223	unsigned long flags;
	224	int card_present;
6aa20a22	225
1da177e4 LT	226	local_irq_save(flags);
	227	card_present = hwreg_present((void*) ioaddr+4)
	228	&& hwreg_present((void*) ioaddr + DATA_PORT);
	229	local_irq_restore(flags);
	230
	231	if (!card_present)
	232	goto out;
	233	}
	234
	235	nubus_writew(0, ioaddr + ADD_PORT);
	236	sig = nubus_readw(ioaddr + DATA_PORT);
	237	if (sig != swab16(CHIP_EISA_ID_SIG))
	238	goto out;
	239
	240	/* Initialize the net_device structure. */
	241	lp = netdev_priv(dev);
	242
	243	/* Fill in the 'dev' fields. */
	244	dev->base_addr = ioaddr;
6aa20a22	245	dev->mem_start = (unsigned long)
1da177e4 LT	246	nubus_slot_addr(slot) \| (((slot&0xf) << 20) + MMIOBASE);
	247	dev->mem_end = dev->mem_start + 0x1000;
	248
	249	/* Turn on shared memory */
	250	writereg_io(dev, PP_BusCTL, MEMORY_ON);
	251
	252	/* get the chip type */
	253	rev_type = readreg(dev, PRODUCT_ID_ADD);
	254	lp->chip_type = rev_type &~ REVISON_BITS;
	255	lp->chip_revision = ((rev_type & REVISON_BITS) >> 8) + 'A';
	256
	257	/* Check the chip type and revision in order to set the correct send command
	258	CS8920 revision C and CS8900 revision F can use the faster send. */
	259	lp->send_cmd = TX_AFTER_381;
	260	if (lp->chip_type == CS8900 && lp->chip_revision >= 'F')
	261	lp->send_cmd = TX_NOW;
	262	if (lp->chip_type != CS8900 && lp->chip_revision >= 'C')
	263	lp->send_cmd = TX_NOW;
	264
	265	if (net_debug && version_printed++ == 0)
	266	printk(version);
	267
	268	printk(KERN_INFO "%s: cs89%c0%s rev %c found at %#8lx",
	269	dev->name,
	270	lp->chip_type==CS8900?'0':'2',
	271	lp->chip_type==CS8920M?"M":"",
	272	lp->chip_revision,
	273	dev->base_addr);
	274
	275	/* Try to read the MAC address */
	276	if ((readreg(dev, PP_SelfST) & (EEPROM_PRESENT \| EEPROM_OK)) == 0) {
	277	printk("\nmac89x0: No EEPROM, giving up now.\n");
	278	goto out1;
	279	} else {
	280	for (i = 0; i < ETH_ALEN; i += 2) {
	281	/* Big-endian (why??!) */
	282	unsigned short s = readreg(dev, PP_IA + i);
	283	dev->dev_addr[i] = s >> 8;
	284	dev->dev_addr[i+1] = s & 0xff;
	285	}
	286	}
	287
	288	dev->irq = SLOT2IRQ(slot);
1da177e4	289
0795af57 JP	290	/* print the IRQ and ethernet address. */
0795af57 JP	291
e174961c	292	printk(" IRQ %d ADDR %pM\n", dev->irq, dev->dev_addr);
1da177e4	293
d0174aea	294	dev->netdev_ops = &mac89x0_netdev_ops;
1da177e4 LT	295
	296	err = register_netdev(dev);
	297	if (err)
	298	goto out1;
79ea13ce	299	return NULL;
1da177e4 LT	300	out1:
	301	nubus_writew(0, dev->base_addr + ADD_PORT);
	302	out:
	303	free_netdev(dev);
	304	return ERR_PTR(err);
	305	}
	306
	307	#if 0
	308	/* This is useful for something, but I don't know what yet. */
	309	void __init reset_chip(struct net_device *dev)
	310	{
	311	int reset_start_time;
	312
	313	writereg(dev, PP_SelfCTL, readreg(dev, PP_SelfCTL) \| POWER_ON_RESET);
	314
	315	/* wait 30 ms */
	316	msleep_interruptible(30);
	317
	318	/* Wait until the chip is reset */
	319	reset_start_time = jiffies;
	320	while( (readreg(dev, PP_SelfST) & INIT_DONE) == 0 && jiffies - reset_start_time < 2)
	321	;
	322	}
	323	#endif
	324
	325	/* Open/initialize the board. This is called (in the current kernel)
	326	sometime after booting when the 'ifconfig' program is run.
	327
	328	This routine should set everything up anew at each open, even
	329	registers that "should" only need to be set once at boot, so that
	330	there is non-reboot way to recover if something goes wrong.
	331	*/
	332	static int
	333	net_open(struct net_device *dev)
	334	{
	335	struct net_local *lp = netdev_priv(dev);
	336	int i;
	337
	338	/* Disable the interrupt for now */
	339	writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL) & ~ENABLE_IRQ);
	340
	341	/* Grab the interrupt */
	342	if (request_irq(dev->irq, &net_interrupt, 0, "cs89x0", dev))
	343	return -EAGAIN;
	344
	345	/* Set up the IRQ - Apparently magic */
	346	if (lp->chip_type == CS8900)
	347	writereg(dev, PP_CS8900_ISAINT, 0);
	348	else
	349	writereg(dev, PP_CS8920_ISAINT, 0);
	350
	351	/* set the Ethernet address */
	352	for (i=0; i < ETH_ALEN/2; i++)
	353	writereg(dev, PP_IA+i2, dev->dev_addr[i2] \| (dev->dev_addr[i*2+1] << 8));
	354
	355	/* Turn on both receive and transmit operations */
	356	writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) \| SERIAL_RX_ON \| SERIAL_TX_ON);
	357
	358	/* Receive only error free packets addressed to this card */
	359	lp->rx_mode = 0;
	360	writereg(dev, PP_RxCTL, DEF_RX_ACCEPT);
	361
	362	lp->curr_rx_cfg = RX_OK_ENBL \| RX_CRC_ERROR_ENBL;
	363
364	writereg(dev, PP_RxCFG, lp->curr_rx_cfg);
365
366	writereg(dev, PP_TxCFG, TX_LOST_CRS_ENBL \| TX_SQE_ERROR_ENBL \| TX_OK_ENBL \|
367	TX_LATE_COL_ENBL \| TX_JBR_ENBL \| TX_ANY_COL_ENBL \| TX_16_COL_ENBL);
368
369	writereg(dev, PP_BufCFG, READY_FOR_TX_ENBL \| RX_MISS_COUNT_OVRFLOW_ENBL \|
370	TX_COL_COUNT_OVRFLOW_ENBL \| TX_UNDERRUN_ENBL);
371
372	/* now that we've got our act together, enable everything */
373	writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL) \| ENABLE_IRQ);
374	netif_start_queue(dev);
375	return 0;
376	}
377
378	static int
379	net_send_packet(struct sk_buff skb, struct net_device dev)
380	{
39ad2cb3 MU	381	struct net_local *lp = netdev_priv(dev);
39ad2cb3 MU	382	unsigned long flags;
1da177e4	383
39ad2cb3 MU	384	if (net_debug > 3)
	385	printk("%s: sent %d byte packet of type %x\n",
	386	dev->name, skb->len,
	387	(skb->data[ETH_ALEN+ETH_ALEN] << 8)
	388	\| skb->data[ETH_ALEN+ETH_ALEN+1]);
1da177e4	389
39ad2cb3 MU	390	/* keep the upload from being interrupted, since we
	391	ask the chip to start transmitting before the
	392	whole packet has been completely uploaded. */
	393	local_irq_save(flags);
	394	netif_stop_queue(dev);
1da177e4	395
39ad2cb3 MU	396	/* initiate a transmit sequence */
	397	writereg(dev, PP_TxCMD, lp->send_cmd);
	398	writereg(dev, PP_TxLength, skb->len);
1da177e4	399
39ad2cb3 MU	400	/* Test to see if the chip has allocated memory for the packet */
	401	if ((readreg(dev, PP_BusST) & READY_FOR_TX_NOW) == 0) {
	402	/* Gasp! It hasn't. But that shouldn't happen since
	403	we're waiting for TxOk, so return 1 and requeue this packet. */
1da177e4	404	local_irq_restore(flags);
39ad2cb3	405	return 1;
1da177e4	406	}
39ad2cb3 MU	407
	408	/* Write the contents of the packet */
	409	skb_copy_from_linear_data(skb, (void *)(dev->mem_start + PP_TxFrame),
	410	skb->len+1);
	411
	412	local_irq_restore(flags);
	413	dev->trans_start = jiffies;
1da177e4 LT	414	dev_kfree_skb (skb);
	415
	416	return 0;
	417	}
6aa20a22	418
1da177e4 LT	419	/* The typical workload of the driver:
1da177e4 LT	420	Handle the network interface interrupts. */
7d12e780	421	static irqreturn_t net_interrupt(int irq, void *dev_id)
1da177e4 LT	422	{
	423	struct net_device *dev = dev_id;
	424	struct net_local *lp;
	425	int ioaddr, status;
	426
	427	if (dev == NULL) {
	428	printk ("net_interrupt(): irq %d for unknown device.\n", irq);
	429	return IRQ_NONE;
	430	}
1da177e4 LT	431
	432	ioaddr = dev->base_addr;
	433	lp = netdev_priv(dev);
	434
	435	/* we MUST read all the events out of the ISQ, otherwise we'll never
	436	get interrupted again. As a consequence, we can't have any limit
	437	on the number of times we loop in the interrupt handler. The
	438	hardware guarantees that eventually we'll run out of events. Of
	439	course, if you're on a slow machine, and packets are arriving
	440	faster than you can read them off, you're screwed. Hasta la
	441	vista, baby! */
	442	while ((status = swab16(nubus_readw(dev->base_addr + ISQ_PORT)))) {
	443	if (net_debug > 4)printk("%s: event=%04x\n", dev->name, status);
	444	switch(status & ISQ_EVENT_MASK) {
	445	case ISQ_RECEIVER_EVENT:
	446	/* Got a packet(s). */
	447	net_rx(dev);
	448	break;
	449	case ISQ_TRANSMITTER_EVENT:
	450	lp->stats.tx_packets++;
39ad2cb3	451	netif_wake_queue(dev);
1da177e4 LT	452	if ((status & TX_OK) == 0) lp->stats.tx_errors++;
	453	if (status & TX_LOST_CRS) lp->stats.tx_carrier_errors++;
	454	if (status & TX_SQE_ERROR) lp->stats.tx_heartbeat_errors++;
	455	if (status & TX_LATE_COL) lp->stats.tx_window_errors++;
	456	if (status & TX_16_COL) lp->stats.tx_aborted_errors++;
	457	break;
	458	case ISQ_BUFFER_EVENT:
	459	if (status & READY_FOR_TX) {
	460	/* we tried to transmit a packet earlier,
	461	but inexplicably ran out of buffers.
	462	That shouldn't happen since we only ever
	463	load one packet. Shrug. Do the right
	464	thing anyway. */
39ad2cb3	465	netif_wake_queue(dev);
1da177e4 LT	466	}
	467	if (status & TX_UNDERRUN) {
	468	if (net_debug > 0) printk("%s: transmit underrun\n", dev->name);
	469	lp->send_underrun++;
	470	if (lp->send_underrun == 3) lp->send_cmd = TX_AFTER_381;
	471	else if (lp->send_underrun == 6) lp->send_cmd = TX_AFTER_ALL;
	472	}
	473	break;
	474	case ISQ_RX_MISS_EVENT:
	475	lp->stats.rx_missed_errors += (status >>6);
	476	break;
	477	case ISQ_TX_COL_EVENT:
	478	lp->stats.collisions += (status >>6);
	479	break;
	480	}
	481	}
1da177e4 LT	482	return IRQ_HANDLED;
	483	}
	484
	485	/* We have a good packet(s), get it/them out of the buffers. */
	486	static void
	487	net_rx(struct net_device *dev)
	488	{
	489	struct net_local *lp = netdev_priv(dev);
	490	struct sk_buff *skb;
	491	int status, length;
	492
	493	status = readreg(dev, PP_RxStatus);
	494	if ((status & RX_OK) == 0) {
	495	lp->stats.rx_errors++;
	496	if (status & RX_RUNT) lp->stats.rx_length_errors++;
	497	if (status & RX_EXTRA_DATA) lp->stats.rx_length_errors++;
	498	if (status & RX_CRC_ERROR) if (!(status & (RX_EXTRA_DATA\|RX_RUNT)))
	499	/* per str 172 */
	500	lp->stats.rx_crc_errors++;
	501	if (status & RX_DRIBBLE) lp->stats.rx_frame_errors++;
	502	return;
	503	}
	504
	505	length = readreg(dev, PP_RxLength);
	506	/* Malloc up new buffer. */
	507	skb = alloc_skb(length, GFP_ATOMIC);
	508	if (skb == NULL) {
	509	printk("%s: Memory squeeze, dropping packet.\n", dev->name);
	510	lp->stats.rx_dropped++;
	511	return;
	512	}
	513	skb_put(skb, length);
1da177e4	514
39ad2cb3 MU	515	skb_copy_to_linear_data(skb, (void *)(dev->mem_start + PP_RxFrame),
39ad2cb3 MU	516	length);
1da177e4 LT	517
	518	if (net_debug > 3)printk("%s: received %d byte packet of type %x\n",
	519	dev->name, length,
	520	(skb->data[ETH_ALEN+ETH_ALEN] << 8)
	521	\| skb->data[ETH_ALEN+ETH_ALEN+1]);
	522
	523	skb->protocol=eth_type_trans(skb,dev);
	524	netif_rx(skb);
1da177e4 LT	525	lp->stats.rx_packets++;
	526	lp->stats.rx_bytes += length;
	527	}
	528
	529	/* The inverse routine to net_open(). */
	530	static int
	531	net_close(struct net_device *dev)
	532	{
	533
	534	writereg(dev, PP_RxCFG, 0);
	535	writereg(dev, PP_TxCFG, 0);
	536	writereg(dev, PP_BufCFG, 0);
	537	writereg(dev, PP_BusCTL, 0);
	538
	539	netif_stop_queue(dev);
	540
	541	free_irq(dev->irq, dev);
	542
	543	/* Update the statistics here. */
	544
	545	return 0;
	546
	547	}
	548
	549	/* Get the current statistics. This may be called with the card open or
	550	closed. */
	551	static struct net_device_stats *
	552	net_get_stats(struct net_device *dev)
	553	{
	554	struct net_local *lp = netdev_priv(dev);
	555	unsigned long flags;
	556
	557	local_irq_save(flags);
	558	/* Update the statistics from the device registers. */
	559	lp->stats.rx_missed_errors += (readreg(dev, PP_RxMiss) >> 6);
	560	lp->stats.collisions += (readreg(dev, PP_TxCol) >> 6);
	561	local_irq_restore(flags);
	562
	563	return &lp->stats;
	564	}
	565
	566	static void set_multicast_list(struct net_device *dev)
	567	{
	568	struct net_local *lp = netdev_priv(dev);
	569
	570	if(dev->flags&IFF_PROMISC)
	571	{
	572	lp->rx_mode = RX_ALL_ACCEPT;
	573	}
	574	else if((dev->flags&IFF_ALLMULTI)\|\|dev->mc_list)
	575	{
	576	/* The multicast-accept list is initialized to accept-all, and we
	577	rely on higher-level filtering for now. */
	578	lp->rx_mode = RX_MULTCAST_ACCEPT;
6aa20a22	579	}
1da177e4 LT	580	else
	581	lp->rx_mode = 0;
	582
	583	writereg(dev, PP_RxCTL, DEF_RX_ACCEPT \| lp->rx_mode);
	584
	585	/* in promiscuous mode, we accept errored packets, so we have to enable interrupts on them also */
	586	writereg(dev, PP_RxCFG, lp->curr_rx_cfg \|
	587	(lp->rx_mode == RX_ALL_ACCEPT? (RX_CRC_ERROR_ENBL\|RX_RUNT_ENBL\|RX_EXTRA_DATA_ENBL) : 0));
	588	}
	589
	590
	591	static int set_mac_address(struct net_device dev, void addr)
	592	{
	593	int i;
1da177e4 LT	594	printk("%s: Setting MAC address to ", dev->name);
	595	for (i = 0; i < 6; i++)
	596	printk(" %2.2x", dev->dev_addr[i] = ((unsigned char *)addr)[i]);
	597	printk(".\n");
	598	/* set the Ethernet address */
	599	for (i=0; i < ETH_ALEN/2; i++)
	600	writereg(dev, PP_IA+i2, dev->dev_addr[i2] \| (dev->dev_addr[i*2+1] << 8));
	601
	602	return 0;
	603	}
	604
	605	#ifdef MODULE
	606
	607	static struct net_device *dev_cs89x0;
	608	static int debug;
	609
8d3b33f6	610	module_param(debug, int, 0);
1da177e4 LT	611	MODULE_PARM_DESC(debug, "CS89[02]0 debug level (0-5)");
	612	MODULE_LICENSE("GPL");
	613
446df4c1	614	int __init
1da177e4 LT	615	init_module(void)
	616	{
	617	net_debug = debug;
	618	dev_cs89x0 = mac89x0_probe(-1);
	619	if (IS_ERR(dev_cs89x0)) {
	620	printk(KERN_WARNING "mac89x0.c: No card found\n");
	621	return PTR_ERR(dev_cs89x0);
	622	}
	623	return 0;
	624	}
	625
	626	void
	627	cleanup_module(void)
	628	{
	629	unregister_netdev(dev_cs89x0);
	630	nubus_writew(0, dev_cs89x0->base_addr + ADD_PORT);
	631	free_netdev(dev_cs89x0);
	632	}
	633	#endif /* MODULE */