[net-next-2.6.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);
}

/* 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->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;

	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);
	dev->last_rx = jiffies;
	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 */

/*
 * Local variables:
 *  compile-command: "m68k-linux-gcc -D__KERNEL__ -I../../include -Wall -Wstrict-prototypes -O2 -fomit-frame-pointer -pipe -fno-strength-reduce -ffixed-a2 -DMODULE -DMODVERSIONS -include ../../include/linux/modversions.h   -c -o mac89x0.o mac89x0.c"
 *  version-control: t
 *  kept-new-versions: 5
 *  c-indent-level: 8
 *  tab-width: 8
 * End:
 *
 */
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
	171	/* Probe for the CS8900 card in slot E. We won't bother looking
	172	anywhere else until we have a really good reason to do so. */
	173	struct net_device * __init mac89x0_probe(int unit)
	174	{
	175	struct net_device *dev;
	176	static int once_is_enough;
	177	struct net_local *lp;
	178	static unsigned version_printed;
	179	int i, slot;
	180	unsigned rev_type = 0;
	181	unsigned long ioaddr;
	182	unsigned short sig;
	183	int err = -ENODEV;
	184
0f734484 GU	185	if (!MACH_IS_MAC)
	186	return ERR_PTR(-ENODEV);
	187
1da177e4 LT	188	dev = alloc_etherdev(sizeof(struct net_local));
	189	if (!dev)
	190	return ERR_PTR(-ENOMEM);
	191
	192	if (unit >= 0) {
	193	sprintf(dev->name, "eth%d", unit);
	194	netdev_boot_setup_check(dev);
	195	}
	196
1da177e4 LT	197	if (once_is_enough)
	198	goto out;
	199	once_is_enough = 1;
	200
	201	/* We might have to parameterize this later */
	202	slot = 0xE;
	203	/* Get out now if there's a real NuBus card in slot E */
	204	if (nubus_find_slot(slot, NULL) != NULL)
	205	goto out;
	206
	207	/* The pseudo-ISA bits always live at offset 0x300 (gee,
	208	wonder why...) */
	209	ioaddr = (unsigned long)
	210	nubus_slot_addr(slot) \| (((slot&0xf) << 20) + DEFAULTIOBASE);
	211	{
	212	unsigned long flags;
	213	int card_present;
6aa20a22	214
1da177e4 LT	215	local_irq_save(flags);
	216	card_present = hwreg_present((void*) ioaddr+4)
	217	&& hwreg_present((void*) ioaddr + DATA_PORT);
	218	local_irq_restore(flags);
	219
	220	if (!card_present)
	221	goto out;
	222	}
	223
	224	nubus_writew(0, ioaddr + ADD_PORT);
	225	sig = nubus_readw(ioaddr + DATA_PORT);
	226	if (sig != swab16(CHIP_EISA_ID_SIG))
	227	goto out;
	228
	229	/* Initialize the net_device structure. */
	230	lp = netdev_priv(dev);
	231
	232	/* Fill in the 'dev' fields. */
	233	dev->base_addr = ioaddr;
6aa20a22	234	dev->mem_start = (unsigned long)
1da177e4 LT	235	nubus_slot_addr(slot) \| (((slot&0xf) << 20) + MMIOBASE);
	236	dev->mem_end = dev->mem_start + 0x1000;
	237
	238	/* Turn on shared memory */
	239	writereg_io(dev, PP_BusCTL, MEMORY_ON);
	240
	241	/* get the chip type */
	242	rev_type = readreg(dev, PRODUCT_ID_ADD);
	243	lp->chip_type = rev_type &~ REVISON_BITS;
	244	lp->chip_revision = ((rev_type & REVISON_BITS) >> 8) + 'A';
	245
	246	/* Check the chip type and revision in order to set the correct send command
	247	CS8920 revision C and CS8900 revision F can use the faster send. */
	248	lp->send_cmd = TX_AFTER_381;
	249	if (lp->chip_type == CS8900 && lp->chip_revision >= 'F')
	250	lp->send_cmd = TX_NOW;
	251	if (lp->chip_type != CS8900 && lp->chip_revision >= 'C')
	252	lp->send_cmd = TX_NOW;
	253
	254	if (net_debug && version_printed++ == 0)
	255	printk(version);
	256
	257	printk(KERN_INFO "%s: cs89%c0%s rev %c found at %#8lx",
	258	dev->name,
	259	lp->chip_type==CS8900?'0':'2',
	260	lp->chip_type==CS8920M?"M":"",
	261	lp->chip_revision,
	262	dev->base_addr);
	263
	264	/* Try to read the MAC address */
	265	if ((readreg(dev, PP_SelfST) & (EEPROM_PRESENT \| EEPROM_OK)) == 0) {
	266	printk("\nmac89x0: No EEPROM, giving up now.\n");
	267	goto out1;
	268	} else {
	269	for (i = 0; i < ETH_ALEN; i += 2) {
	270	/* Big-endian (why??!) */
	271	unsigned short s = readreg(dev, PP_IA + i);
	272	dev->dev_addr[i] = s >> 8;
	273	dev->dev_addr[i+1] = s & 0xff;
	274	}
	275	}
	276
	277	dev->irq = SLOT2IRQ(slot);
1da177e4	278
0795af57 JP	279	/* print the IRQ and ethernet address. */
0795af57 JP	280
e174961c	281	printk(" IRQ %d ADDR %pM\n", dev->irq, dev->dev_addr);
1da177e4 LT	282
	283	dev->open = net_open;
	284	dev->stop = net_close;
	285	dev->hard_start_xmit = net_send_packet;
	286	dev->get_stats = net_get_stats;
	287	dev->set_multicast_list = &set_multicast_list;
	288	dev->set_mac_address = &set_mac_address;
	289
	290	err = register_netdev(dev);
	291	if (err)
	292	goto out1;
79ea13ce	293	return NULL;
1da177e4 LT	294	out1:
	295	nubus_writew(0, dev->base_addr + ADD_PORT);
	296	out:
	297	free_netdev(dev);
	298	return ERR_PTR(err);
	299	}
	300
	301	#if 0
	302	/* This is useful for something, but I don't know what yet. */
	303	void __init reset_chip(struct net_device *dev)
	304	{
	305	int reset_start_time;
	306
	307	writereg(dev, PP_SelfCTL, readreg(dev, PP_SelfCTL) \| POWER_ON_RESET);
	308
	309	/* wait 30 ms */
	310	msleep_interruptible(30);
	311
	312	/* Wait until the chip is reset */
	313	reset_start_time = jiffies;
	314	while( (readreg(dev, PP_SelfST) & INIT_DONE) == 0 && jiffies - reset_start_time < 2)
	315	;
	316	}
	317	#endif
	318
	319	/* Open/initialize the board. This is called (in the current kernel)
	320	sometime after booting when the 'ifconfig' program is run.
	321
	322	This routine should set everything up anew at each open, even
	323	registers that "should" only need to be set once at boot, so that
	324	there is non-reboot way to recover if something goes wrong.
	325	*/
	326	static int
	327	net_open(struct net_device *dev)
	328	{
	329	struct net_local *lp = netdev_priv(dev);
	330	int i;
	331
	332	/* Disable the interrupt for now */
	333	writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL) & ~ENABLE_IRQ);
	334
	335	/* Grab the interrupt */
	336	if (request_irq(dev->irq, &net_interrupt, 0, "cs89x0", dev))
	337	return -EAGAIN;
	338
	339	/* Set up the IRQ - Apparently magic */
	340	if (lp->chip_type == CS8900)
	341	writereg(dev, PP_CS8900_ISAINT, 0);
	342	else
	343	writereg(dev, PP_CS8920_ISAINT, 0);
	344
	345	/* set the Ethernet address */
	346	for (i=0; i < ETH_ALEN/2; i++)
	347	writereg(dev, PP_IA+i2, dev->dev_addr[i2] \| (dev->dev_addr[i*2+1] << 8));
	348
	349	/* Turn on both receive and transmit operations */
	350	writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) \| SERIAL_RX_ON \| SERIAL_TX_ON);
	351
	352	/* Receive only error free packets addressed to this card */
	353	lp->rx_mode = 0;
	354	writereg(dev, PP_RxCTL, DEF_RX_ACCEPT);
	355
	356	lp->curr_rx_cfg = RX_OK_ENBL \| RX_CRC_ERROR_ENBL;
	357
358	writereg(dev, PP_RxCFG, lp->curr_rx_cfg);
359
360	writereg(dev, PP_TxCFG, TX_LOST_CRS_ENBL \| TX_SQE_ERROR_ENBL \| TX_OK_ENBL \|
361	TX_LATE_COL_ENBL \| TX_JBR_ENBL \| TX_ANY_COL_ENBL \| TX_16_COL_ENBL);
362
363	writereg(dev, PP_BufCFG, READY_FOR_TX_ENBL \| RX_MISS_COUNT_OVRFLOW_ENBL \|
364	TX_COL_COUNT_OVRFLOW_ENBL \| TX_UNDERRUN_ENBL);
365
366	/* now that we've got our act together, enable everything */
367	writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL) \| ENABLE_IRQ);
368	netif_start_queue(dev);
369	return 0;
370	}
371
372	static int
373	net_send_packet(struct sk_buff skb, struct net_device dev)
374	{
39ad2cb3 MU	375	struct net_local *lp = netdev_priv(dev);
39ad2cb3 MU	376	unsigned long flags;
1da177e4	377
39ad2cb3 MU	378	if (net_debug > 3)
	379	printk("%s: sent %d byte packet of type %x\n",
	380	dev->name, skb->len,
	381	(skb->data[ETH_ALEN+ETH_ALEN] << 8)
	382	\| skb->data[ETH_ALEN+ETH_ALEN+1]);
1da177e4	383
39ad2cb3 MU	384	/* keep the upload from being interrupted, since we
	385	ask the chip to start transmitting before the
	386	whole packet has been completely uploaded. */
	387	local_irq_save(flags);
	388	netif_stop_queue(dev);
1da177e4	389
39ad2cb3 MU	390	/* initiate a transmit sequence */
	391	writereg(dev, PP_TxCMD, lp->send_cmd);
	392	writereg(dev, PP_TxLength, skb->len);
1da177e4	393
39ad2cb3 MU	394	/* Test to see if the chip has allocated memory for the packet */
	395	if ((readreg(dev, PP_BusST) & READY_FOR_TX_NOW) == 0) {
	396	/* Gasp! It hasn't. But that shouldn't happen since
	397	we're waiting for TxOk, so return 1 and requeue this packet. */
1da177e4	398	local_irq_restore(flags);
39ad2cb3	399	return 1;
1da177e4	400	}
39ad2cb3 MU	401
	402	/* Write the contents of the packet */
	403	skb_copy_from_linear_data(skb, (void *)(dev->mem_start + PP_TxFrame),
	404	skb->len+1);
	405
	406	local_irq_restore(flags);
	407	dev->trans_start = jiffies;
1da177e4 LT	408	dev_kfree_skb (skb);
	409
	410	return 0;
	411	}
6aa20a22	412
1da177e4 LT	413	/* The typical workload of the driver:
1da177e4 LT	414	Handle the network interface interrupts. */
7d12e780	415	static irqreturn_t net_interrupt(int irq, void *dev_id)
1da177e4 LT	416	{
	417	struct net_device *dev = dev_id;
	418	struct net_local *lp;
	419	int ioaddr, status;
	420
	421	if (dev == NULL) {
	422	printk ("net_interrupt(): irq %d for unknown device.\n", irq);
	423	return IRQ_NONE;
	424	}
1da177e4 LT	425
	426	ioaddr = dev->base_addr;
	427	lp = netdev_priv(dev);
	428
	429	/* we MUST read all the events out of the ISQ, otherwise we'll never
	430	get interrupted again. As a consequence, we can't have any limit
	431	on the number of times we loop in the interrupt handler. The
	432	hardware guarantees that eventually we'll run out of events. Of
	433	course, if you're on a slow machine, and packets are arriving
	434	faster than you can read them off, you're screwed. Hasta la
	435	vista, baby! */
	436	while ((status = swab16(nubus_readw(dev->base_addr + ISQ_PORT)))) {
	437	if (net_debug > 4)printk("%s: event=%04x\n", dev->name, status);
	438	switch(status & ISQ_EVENT_MASK) {
	439	case ISQ_RECEIVER_EVENT:
	440	/* Got a packet(s). */
	441	net_rx(dev);
	442	break;
	443	case ISQ_TRANSMITTER_EVENT:
	444	lp->stats.tx_packets++;
39ad2cb3	445	netif_wake_queue(dev);
1da177e4 LT	446	if ((status & TX_OK) == 0) lp->stats.tx_errors++;
	447	if (status & TX_LOST_CRS) lp->stats.tx_carrier_errors++;
	448	if (status & TX_SQE_ERROR) lp->stats.tx_heartbeat_errors++;
	449	if (status & TX_LATE_COL) lp->stats.tx_window_errors++;
	450	if (status & TX_16_COL) lp->stats.tx_aborted_errors++;
	451	break;
	452	case ISQ_BUFFER_EVENT:
	453	if (status & READY_FOR_TX) {
	454	/* we tried to transmit a packet earlier,
	455	but inexplicably ran out of buffers.
	456	That shouldn't happen since we only ever
	457	load one packet. Shrug. Do the right
	458	thing anyway. */
39ad2cb3	459	netif_wake_queue(dev);
1da177e4 LT	460	}
	461	if (status & TX_UNDERRUN) {
	462	if (net_debug > 0) printk("%s: transmit underrun\n", dev->name);
	463	lp->send_underrun++;
	464	if (lp->send_underrun == 3) lp->send_cmd = TX_AFTER_381;
	465	else if (lp->send_underrun == 6) lp->send_cmd = TX_AFTER_ALL;
	466	}
	467	break;
	468	case ISQ_RX_MISS_EVENT:
	469	lp->stats.rx_missed_errors += (status >>6);
	470	break;
	471	case ISQ_TX_COL_EVENT:
	472	lp->stats.collisions += (status >>6);
	473	break;
	474	}
	475	}
1da177e4 LT	476	return IRQ_HANDLED;
	477	}
	478
	479	/* We have a good packet(s), get it/them out of the buffers. */
	480	static void
	481	net_rx(struct net_device *dev)
	482	{
	483	struct net_local *lp = netdev_priv(dev);
	484	struct sk_buff *skb;
	485	int status, length;
	486
	487	status = readreg(dev, PP_RxStatus);
	488	if ((status & RX_OK) == 0) {
	489	lp->stats.rx_errors++;
	490	if (status & RX_RUNT) lp->stats.rx_length_errors++;
	491	if (status & RX_EXTRA_DATA) lp->stats.rx_length_errors++;
	492	if (status & RX_CRC_ERROR) if (!(status & (RX_EXTRA_DATA\|RX_RUNT)))
	493	/* per str 172 */
	494	lp->stats.rx_crc_errors++;
	495	if (status & RX_DRIBBLE) lp->stats.rx_frame_errors++;
	496	return;
	497	}
	498
	499	length = readreg(dev, PP_RxLength);
	500	/* Malloc up new buffer. */
	501	skb = alloc_skb(length, GFP_ATOMIC);
	502	if (skb == NULL) {
	503	printk("%s: Memory squeeze, dropping packet.\n", dev->name);
	504	lp->stats.rx_dropped++;
	505	return;
	506	}
	507	skb_put(skb, length);
1da177e4	508
39ad2cb3 MU	509	skb_copy_to_linear_data(skb, (void *)(dev->mem_start + PP_RxFrame),
39ad2cb3 MU	510	length);
1da177e4 LT	511
	512	if (net_debug > 3)printk("%s: received %d byte packet of type %x\n",
	513	dev->name, length,
	514	(skb->data[ETH_ALEN+ETH_ALEN] << 8)
	515	\| skb->data[ETH_ALEN+ETH_ALEN+1]);
	516
	517	skb->protocol=eth_type_trans(skb,dev);
	518	netif_rx(skb);
	519	dev->last_rx = jiffies;
	520	lp->stats.rx_packets++;
	521	lp->stats.rx_bytes += length;
	522	}
	523
	524	/* The inverse routine to net_open(). */
	525	static int
	526	net_close(struct net_device *dev)
	527	{
	528
	529	writereg(dev, PP_RxCFG, 0);
	530	writereg(dev, PP_TxCFG, 0);
	531	writereg(dev, PP_BufCFG, 0);
	532	writereg(dev, PP_BusCTL, 0);
	533
	534	netif_stop_queue(dev);
	535
	536	free_irq(dev->irq, dev);
	537
	538	/* Update the statistics here. */
	539
	540	return 0;
	541
	542	}
	543
	544	/* Get the current statistics. This may be called with the card open or
	545	closed. */
	546	static struct net_device_stats *
	547	net_get_stats(struct net_device *dev)
	548	{
	549	struct net_local *lp = netdev_priv(dev);
	550	unsigned long flags;
	551
	552	local_irq_save(flags);
	553	/* Update the statistics from the device registers. */
	554	lp->stats.rx_missed_errors += (readreg(dev, PP_RxMiss) >> 6);
	555	lp->stats.collisions += (readreg(dev, PP_TxCol) >> 6);
	556	local_irq_restore(flags);
	557
	558	return &lp->stats;
	559	}
	560
	561	static void set_multicast_list(struct net_device *dev)
	562	{
	563	struct net_local *lp = netdev_priv(dev);
	564
	565	if(dev->flags&IFF_PROMISC)
	566	{
	567	lp->rx_mode = RX_ALL_ACCEPT;
	568	}
	569	else if((dev->flags&IFF_ALLMULTI)\|\|dev->mc_list)
	570	{
	571	/* The multicast-accept list is initialized to accept-all, and we
	572	rely on higher-level filtering for now. */
	573	lp->rx_mode = RX_MULTCAST_ACCEPT;
6aa20a22	574	}
1da177e4 LT	575	else
	576	lp->rx_mode = 0;
	577
	578	writereg(dev, PP_RxCTL, DEF_RX_ACCEPT \| lp->rx_mode);
	579
	580	/* in promiscuous mode, we accept errored packets, so we have to enable interrupts on them also */
	581	writereg(dev, PP_RxCFG, lp->curr_rx_cfg \|
	582	(lp->rx_mode == RX_ALL_ACCEPT? (RX_CRC_ERROR_ENBL\|RX_RUNT_ENBL\|RX_EXTRA_DATA_ENBL) : 0));
	583	}
	584
	585
	586	static int set_mac_address(struct net_device dev, void addr)
	587	{
	588	int i;
1da177e4 LT	589	printk("%s: Setting MAC address to ", dev->name);
	590	for (i = 0; i < 6; i++)
	591	printk(" %2.2x", dev->dev_addr[i] = ((unsigned char *)addr)[i]);
	592	printk(".\n");
	593	/* set the Ethernet address */
	594	for (i=0; i < ETH_ALEN/2; i++)
	595	writereg(dev, PP_IA+i2, dev->dev_addr[i2] \| (dev->dev_addr[i*2+1] << 8));
	596
	597	return 0;
	598	}
	599
	600	#ifdef MODULE
	601
	602	static struct net_device *dev_cs89x0;
	603	static int debug;
	604
8d3b33f6	605	module_param(debug, int, 0);
1da177e4 LT	606	MODULE_PARM_DESC(debug, "CS89[02]0 debug level (0-5)");
	607	MODULE_LICENSE("GPL");
	608
446df4c1	609	int __init
1da177e4 LT	610	init_module(void)
	611	{
	612	net_debug = debug;
	613	dev_cs89x0 = mac89x0_probe(-1);
	614	if (IS_ERR(dev_cs89x0)) {
	615	printk(KERN_WARNING "mac89x0.c: No card found\n");
	616	return PTR_ERR(dev_cs89x0);
	617	}
	618	return 0;
	619	}
	620
	621	void
	622	cleanup_module(void)
	623	{
	624	unregister_netdev(dev_cs89x0);
	625	nubus_writew(0, dev_cs89x0->base_addr + ADD_PORT);
	626	free_netdev(dev_cs89x0);
	627	}
	628	#endif /* MODULE */
6aa20a22	629
1da177e4 LT	630	/*
	631	* Local variables:
	632	* compile-command: "m68k-linux-gcc -D__KERNEL__ -I../../include -Wall -Wstrict-prototypes -O2 -fomit-frame-pointer -pipe -fno-strength-reduce -ffixed-a2 -DMODULE -DMODVERSIONS -include ../../include/linux/modversions.h -c -o mac89x0.o mac89x0.c"
	633	* version-control: t
	634	* kept-new-versions: 5
	635	* c-indent-level: 8
	636	* tab-width: 8
	637	* End:
	638	*
	639	*/