[deliverable/linux.git] / drivers / net / ethernet / cirrus / 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>

/*
  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/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 <linux/gfp.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 {
	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_rx_mode	= 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 NETDEV_TX_BUSY;
	}

	/* 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_kfree_skb (skb);

	return NETDEV_TX_OK;
}

/* 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:
			dev->stats.tx_packets++;
			netif_wake_queue(dev);
			if ((status & TX_OK) == 0)
				dev->stats.tx_errors++;
			if (status & TX_LOST_CRS)
				dev->stats.tx_carrier_errors++;
			if (status & TX_SQE_ERROR)
				dev->stats.tx_heartbeat_errors++;
			if (status & TX_LATE_COL)
				dev->stats.tx_window_errors++;
			if (status & TX_16_COL)
				dev->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:
			dev->stats.rx_missed_errors += (status >> 6);
			break;
		case ISQ_TX_COL_EVENT:
			dev->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 sk_buff *skb;
	int status, length;

	status = readreg(dev, PP_RxStatus);
	if ((status & RX_OK) == 0) {
		dev->stats.rx_errors++;
		if (status & RX_RUNT)
				dev->stats.rx_length_errors++;
		if (status & RX_EXTRA_DATA)
				dev->stats.rx_length_errors++;
		if ((status & RX_CRC_ERROR) &&
		    !(status & (RX_EXTRA_DATA|RX_RUNT)))
			/* per str 172 */
			dev->stats.rx_crc_errors++;
		if (status & RX_DRIBBLE)
				dev->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);
		dev->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->stats.rx_packets++;
	dev->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)
{
	unsigned long flags;

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

	return &dev->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) || !netdev_mc_empty(dev)) {
		/* 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)
{
	struct sockaddr *saddr = addr;
	int i;

	if (!is_valid_ether_addr(saddr->sa_data))
		return -EADDRNOTAVAIL;

	memcpy(dev->dev_addr, saddr->sa_data, ETH_ALEN);
	printk("%s: Setting MAC address to %pM\n", dev->name, dev->dev_addr);

	/* 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
1da177e4 LT	76	/*
	77	Sources:
	78
	79	Crynwr packet driver epktisa.
	80
	81	Crystal Semiconductor data sheets.
	82
	83	*/
	84
	85	#include <linux/kernel.h>
	86	#include <linux/types.h>
	87	#include <linux/fcntl.h>
	88	#include <linux/interrupt.h>
	89	#include <linux/ioport.h>
	90	#include <linux/in.h>
1da177e4 LT	91	#include <linux/string.h>
	92	#include <linux/nubus.h>
	93	#include <linux/errno.h>
	94	#include <linux/init.h>
	95	#include <linux/netdevice.h>
	96	#include <linux/etherdevice.h>
	97	#include <linux/skbuff.h>
	98	#include <linux/delay.h>
1977f032	99	#include <linux/bitops.h>
5a0e3ad6	100	#include <linux/gfp.h>
1da177e4	101
1da177e4 LT	102	#include <asm/io.h>
	103	#include <asm/hwtest.h>
	104	#include <asm/macints.h>
	105
	106	#include "cs89x0.h"
	107
	108	static unsigned int net_debug = NET_DEBUG;
	109
	110	/* Information that need to be kept for each board. */
	111	struct net_local {
1da177e4 LT	112	int chip_type; /* one of: CS8900, CS8920, CS8920M */
	113	char chip_revision; /* revision letter of the chip ('A'...) */
	114	int send_cmd; /* the propercommand used to send a packet. */
	115	int rx_mode;
	116	int curr_rx_cfg;
	117	int send_underrun; /* keep track of how many underruns in a row we get */
	118	struct sk_buff *skb;
	119	};
	120
	121	/* Index to functions, as function prototypes. */
	122
	123	#if 0
	124	extern void reset_chip(struct net_device *dev);
	125	#endif
	126	static int net_open(struct net_device *dev);
39ad2cb3	127	static int net_send_packet(struct sk_buff skb, struct net_device dev);
7d12e780	128	static irqreturn_t net_interrupt(int irq, void *dev_id);
1da177e4 LT	129	static void set_multicast_list(struct net_device *dev);
	130	static void net_rx(struct net_device *dev);
	131	static int net_close(struct net_device *dev);
	132	static struct net_device_stats net_get_stats(struct net_device dev);
	133	static int set_mac_address(struct net_device dev, void addr);
	134
	135
	136	/* Example routines you must write ;->. */
	137	#define tx_done(dev) 1
	138
	139	/* For reading/writing registers ISA-style */
	140	static inline int
	141	readreg_io(struct net_device *dev, int portno)
	142	{
	143	nubus_writew(swab16(portno), dev->base_addr + ADD_PORT);
	144	return swab16(nubus_readw(dev->base_addr + DATA_PORT));
	145	}
	146
	147	static inline void
	148	writereg_io(struct net_device *dev, int portno, int value)
	149	{
	150	nubus_writew(swab16(portno), dev->base_addr + ADD_PORT);
	151	nubus_writew(swab16(value), dev->base_addr + DATA_PORT);
	152	}
	153
	154	/* These are for reading/writing registers in shared memory */
	155	static inline int
	156	readreg(struct net_device *dev, int portno)
	157	{
	158	return swab16(nubus_readw(dev->mem_start + portno));
	159	}
	160
	161	static inline void
	162	writereg(struct net_device *dev, int portno, int value)
	163	{
	164	nubus_writew(swab16(value), dev->mem_start + portno);
	165	}
	166
d0174aea AB	167	static const struct net_device_ops mac89x0_netdev_ops = {
	168	.ndo_open = net_open,
	169	.ndo_stop = net_close,
	170	.ndo_start_xmit = net_send_packet,
	171	.ndo_get_stats = net_get_stats,
afc4b13d	172	.ndo_set_rx_mode = set_multicast_list,
d0174aea AB	173	.ndo_set_mac_address = set_mac_address,
	174	.ndo_validate_addr = eth_validate_addr,
	175	.ndo_change_mtu = eth_change_mtu,
	176	};
	177
1da177e4 LT	178	/* Probe for the CS8900 card in slot E. We won't bother looking
	179	anywhere else until we have a really good reason to do so. */
	180	struct net_device * __init mac89x0_probe(int unit)
	181	{
	182	struct net_device *dev;
	183	static int once_is_enough;
	184	struct net_local *lp;
	185	static unsigned version_printed;
	186	int i, slot;
	187	unsigned rev_type = 0;
	188	unsigned long ioaddr;
	189	unsigned short sig;
	190	int err = -ENODEV;
	191
0f734484 GU	192	if (!MACH_IS_MAC)
	193	return ERR_PTR(-ENODEV);
	194
1da177e4 LT	195	dev = alloc_etherdev(sizeof(struct net_local));
	196	if (!dev)
	197	return ERR_PTR(-ENOMEM);
	198
	199	if (unit >= 0) {
	200	sprintf(dev->name, "eth%d", unit);
	201	netdev_boot_setup_check(dev);
	202	}
	203
1da177e4 LT	204	if (once_is_enough)
	205	goto out;
	206	once_is_enough = 1;
	207
	208	/* We might have to parameterize this later */
	209	slot = 0xE;
	210	/* Get out now if there's a real NuBus card in slot E */
	211	if (nubus_find_slot(slot, NULL) != NULL)
	212	goto out;
	213
	214	/* The pseudo-ISA bits always live at offset 0x300 (gee,
	215	wonder why...) */
	216	ioaddr = (unsigned long)
	217	nubus_slot_addr(slot) \| (((slot&0xf) << 20) + DEFAULTIOBASE);
	218	{
	219	unsigned long flags;
	220	int card_present;
6aa20a22	221
1da177e4	222	local_irq_save(flags);
8e95a202 JP	223	card_present = (hwreg_present((void*) ioaddr+4) &&
8e95a202 JP	224	hwreg_present((void*) ioaddr + DATA_PORT));
1da177e4 LT	225	local_irq_restore(flags);
	226
	227	if (!card_present)
	228	goto out;
	229	}
	230
	231	nubus_writew(0, ioaddr + ADD_PORT);
	232	sig = nubus_readw(ioaddr + DATA_PORT);
	233	if (sig != swab16(CHIP_EISA_ID_SIG))
	234	goto out;
	235
	236	/* Initialize the net_device structure. */
	237	lp = netdev_priv(dev);
	238
	239	/* Fill in the 'dev' fields. */
	240	dev->base_addr = ioaddr;
6aa20a22	241	dev->mem_start = (unsigned long)
1da177e4 LT	242	nubus_slot_addr(slot) \| (((slot&0xf) << 20) + MMIOBASE);
	243	dev->mem_end = dev->mem_start + 0x1000;
	244
	245	/* Turn on shared memory */
	246	writereg_io(dev, PP_BusCTL, MEMORY_ON);
	247
	248	/* get the chip type */
	249	rev_type = readreg(dev, PRODUCT_ID_ADD);
	250	lp->chip_type = rev_type &~ REVISON_BITS;
	251	lp->chip_revision = ((rev_type & REVISON_BITS) >> 8) + 'A';
	252
	253	/* Check the chip type and revision in order to set the correct send command
	254	CS8920 revision C and CS8900 revision F can use the faster send. */
	255	lp->send_cmd = TX_AFTER_381;
	256	if (lp->chip_type == CS8900 && lp->chip_revision >= 'F')
	257	lp->send_cmd = TX_NOW;
	258	if (lp->chip_type != CS8900 && lp->chip_revision >= 'C')
	259	lp->send_cmd = TX_NOW;
	260
	261	if (net_debug && version_printed++ == 0)
	262	printk(version);
	263
	264	printk(KERN_INFO "%s: cs89%c0%s rev %c found at %#8lx",
	265	dev->name,
	266	lp->chip_type==CS8900?'0':'2',
	267	lp->chip_type==CS8920M?"M":"",
	268	lp->chip_revision,
	269	dev->base_addr);
	270
	271	/* Try to read the MAC address */
	272	if ((readreg(dev, PP_SelfST) & (EEPROM_PRESENT \| EEPROM_OK)) == 0) {
	273	printk("\nmac89x0: No EEPROM, giving up now.\n");
	274	goto out1;
	275	} else {
	276	for (i = 0; i < ETH_ALEN; i += 2) {
	277	/* Big-endian (why??!) */
	278	unsigned short s = readreg(dev, PP_IA + i);
	279	dev->dev_addr[i] = s >> 8;
	280	dev->dev_addr[i+1] = s & 0xff;
	281	}
	282	}
	283
	284	dev->irq = SLOT2IRQ(slot);
1da177e4	285
0795af57 JP	286	/* print the IRQ and ethernet address. */
0795af57 JP	287
e174961c	288	printk(" IRQ %d ADDR %pM\n", dev->irq, dev->dev_addr);
1da177e4	289
d0174aea	290	dev->netdev_ops = &mac89x0_netdev_ops;
1da177e4 LT	291
	292	err = register_netdev(dev);
	293	if (err)
	294	goto out1;
79ea13ce	295	return NULL;
1da177e4 LT	296	out1:
	297	nubus_writew(0, dev->base_addr + ADD_PORT);
	298	out:
	299	free_netdev(dev);
	300	return ERR_PTR(err);
	301	}
	302
	303	#if 0
	304	/* This is useful for something, but I don't know what yet. */
	305	void __init reset_chip(struct net_device *dev)
	306	{
	307	int reset_start_time;
	308
	309	writereg(dev, PP_SelfCTL, readreg(dev, PP_SelfCTL) \| POWER_ON_RESET);
	310
	311	/* wait 30 ms */
	312	msleep_interruptible(30);
	313
	314	/* Wait until the chip is reset */
	315	reset_start_time = jiffies;
	316	while( (readreg(dev, PP_SelfST) & INIT_DONE) == 0 && jiffies - reset_start_time < 2)
	317	;
	318	}
	319	#endif
	320
	321	/* Open/initialize the board. This is called (in the current kernel)
	322	sometime after booting when the 'ifconfig' program is run.
	323
	324	This routine should set everything up anew at each open, even
	325	registers that "should" only need to be set once at boot, so that
	326	there is non-reboot way to recover if something goes wrong.
	327	*/
	328	static int
	329	net_open(struct net_device *dev)
	330	{
	331	struct net_local *lp = netdev_priv(dev);
	332	int i;
	333
	334	/* Disable the interrupt for now */
	335	writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL) & ~ENABLE_IRQ);
	336
	337	/* Grab the interrupt */
a0607fd3	338	if (request_irq(dev->irq, net_interrupt, 0, "cs89x0", dev))
1da177e4 LT	339	return -EAGAIN;
	340
	341	/* Set up the IRQ - Apparently magic */
	342	if (lp->chip_type == CS8900)
	343	writereg(dev, PP_CS8900_ISAINT, 0);
	344	else
	345	writereg(dev, PP_CS8920_ISAINT, 0);
	346
	347	/* set the Ethernet address */
	348	for (i=0; i < ETH_ALEN/2; i++)
	349	writereg(dev, PP_IA+i2, dev->dev_addr[i2] \| (dev->dev_addr[i*2+1] << 8));
	350
	351	/* Turn on both receive and transmit operations */
	352	writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) \| SERIAL_RX_ON \| SERIAL_TX_ON);
	353
	354	/* Receive only error free packets addressed to this card */
	355	lp->rx_mode = 0;
	356	writereg(dev, PP_RxCTL, DEF_RX_ACCEPT);
	357
	358	lp->curr_rx_cfg = RX_OK_ENBL \| RX_CRC_ERROR_ENBL;
	359
	360	writereg(dev, PP_RxCFG, lp->curr_rx_cfg);
	361
	362	writereg(dev, PP_TxCFG, TX_LOST_CRS_ENBL \| TX_SQE_ERROR_ENBL \| TX_OK_ENBL \|
	363	TX_LATE_COL_ENBL \| TX_JBR_ENBL \| TX_ANY_COL_ENBL \| TX_16_COL_ENBL);
	364
	365	writereg(dev, PP_BufCFG, READY_FOR_TX_ENBL \| RX_MISS_COUNT_OVRFLOW_ENBL \|
	366	TX_COL_COUNT_OVRFLOW_ENBL \| TX_UNDERRUN_ENBL);
	367
	368	/* now that we've got our act together, enable everything */
	369	writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL) \| ENABLE_IRQ);
	370	netif_start_queue(dev);
	371	return 0;
	372	}
	373
	374	static int
	375	net_send_packet(struct sk_buff skb, struct net_device dev)
	376	{
39ad2cb3 MU	377	struct net_local *lp = netdev_priv(dev);
39ad2cb3 MU	378	unsigned long flags;
1da177e4	379
39ad2cb3 MU	380	if (net_debug > 3)
	381	printk("%s: sent %d byte packet of type %x\n",
	382	dev->name, skb->len,
	383	(skb->data[ETH_ALEN+ETH_ALEN] << 8)
	384	\| skb->data[ETH_ALEN+ETH_ALEN+1]);
1da177e4	385
39ad2cb3 MU	386	/* keep the upload from being interrupted, since we
	387	ask the chip to start transmitting before the
	388	whole packet has been completely uploaded. */
	389	local_irq_save(flags);
	390	netif_stop_queue(dev);
1da177e4	391
39ad2cb3 MU	392	/* initiate a transmit sequence */
	393	writereg(dev, PP_TxCMD, lp->send_cmd);
	394	writereg(dev, PP_TxLength, skb->len);
1da177e4	395
39ad2cb3 MU	396	/* Test to see if the chip has allocated memory for the packet */
	397	if ((readreg(dev, PP_BusST) & READY_FOR_TX_NOW) == 0) {
	398	/* Gasp! It hasn't. But that shouldn't happen since
	399	we're waiting for TxOk, so return 1 and requeue this packet. */
1da177e4	400	local_irq_restore(flags);
5b548140	401	return NETDEV_TX_BUSY;
1da177e4	402	}
39ad2cb3 MU	403
	404	/* Write the contents of the packet */
	405	skb_copy_from_linear_data(skb, (void *)(dev->mem_start + PP_TxFrame),
	406	skb->len+1);
	407
	408	local_irq_restore(flags);
1da177e4 LT	409	dev_kfree_skb (skb);
1da177e4 LT	410
6ed10654	411	return NETDEV_TX_OK;
1da177e4	412	}
6aa20a22	413
1da177e4 LT	414	/* The typical workload of the driver:
1da177e4 LT	415	Handle the network interface interrupts. */
7d12e780	416	static irqreturn_t net_interrupt(int irq, void *dev_id)
1da177e4 LT	417	{
	418	struct net_device *dev = dev_id;
	419	struct net_local *lp;
	420	int ioaddr, status;
	421
	422	if (dev == NULL) {
	423	printk ("net_interrupt(): irq %d for unknown device.\n", irq);
	424	return IRQ_NONE;
	425	}
1da177e4 LT	426
	427	ioaddr = dev->base_addr;
	428	lp = netdev_priv(dev);
	429
	430	/* we MUST read all the events out of the ISQ, otherwise we'll never
	431	get interrupted again. As a consequence, we can't have any limit
	432	on the number of times we loop in the interrupt handler. The
	433	hardware guarantees that eventually we'll run out of events. Of
	434	course, if you're on a slow machine, and packets are arriving
	435	faster than you can read them off, you're screwed. Hasta la
	436	vista, baby! */
	437	while ((status = swab16(nubus_readw(dev->base_addr + ISQ_PORT)))) {
	438	if (net_debug > 4)printk("%s: event=%04x\n", dev->name, status);
	439	switch(status & ISQ_EVENT_MASK) {
	440	case ISQ_RECEIVER_EVENT:
	441	/* Got a packet(s). */
	442	net_rx(dev);
	443	break;
	444	case ISQ_TRANSMITTER_EVENT:
174afef4	445	dev->stats.tx_packets++;
39ad2cb3	446	netif_wake_queue(dev);
174afef4 KV	447	if ((status & TX_OK) == 0)
	448	dev->stats.tx_errors++;
	449	if (status & TX_LOST_CRS)
	450	dev->stats.tx_carrier_errors++;
	451	if (status & TX_SQE_ERROR)
	452	dev->stats.tx_heartbeat_errors++;
	453	if (status & TX_LATE_COL)
	454	dev->stats.tx_window_errors++;
	455	if (status & TX_16_COL)
	456	dev->stats.tx_aborted_errors++;
1da177e4 LT	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:
174afef4	475	dev->stats.rx_missed_errors += (status >> 6);
1da177e4 LT	476	break;
1da177e4 LT	477	case ISQ_TX_COL_EVENT:
174afef4	478	dev->stats.collisions += (status >> 6);
1da177e4 LT	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	{
1da177e4 LT	489	struct sk_buff *skb;
	490	int status, length;
	491
	492	status = readreg(dev, PP_RxStatus);
	493	if ((status & RX_OK) == 0) {
174afef4 KV	494	dev->stats.rx_errors++;
	495	if (status & RX_RUNT)
	496	dev->stats.rx_length_errors++;
	497	if (status & RX_EXTRA_DATA)
	498	dev->stats.rx_length_errors++;
	499	if ((status & RX_CRC_ERROR) &&
	500	!(status & (RX_EXTRA_DATA\|RX_RUNT)))
1da177e4	501	/* per str 172 */
174afef4 KV	502	dev->stats.rx_crc_errors++;
	503	if (status & RX_DRIBBLE)
	504	dev->stats.rx_frame_errors++;
1da177e4 LT	505	return;
	506	}
	507
	508	length = readreg(dev, PP_RxLength);
	509	/* Malloc up new buffer. */
	510	skb = alloc_skb(length, GFP_ATOMIC);
	511	if (skb == NULL) {
	512	printk("%s: Memory squeeze, dropping packet.\n", dev->name);
174afef4	513	dev->stats.rx_dropped++;
1da177e4 LT	514	return;
	515	}
	516	skb_put(skb, length);
1da177e4	517
39ad2cb3 MU	518	skb_copy_to_linear_data(skb, (void *)(dev->mem_start + PP_RxFrame),
39ad2cb3 MU	519	length);
1da177e4 LT	520
	521	if (net_debug > 3)printk("%s: received %d byte packet of type %x\n",
	522	dev->name, length,
	523	(skb->data[ETH_ALEN+ETH_ALEN] << 8)
	524	\| skb->data[ETH_ALEN+ETH_ALEN+1]);
	525
	526	skb->protocol=eth_type_trans(skb,dev);
	527	netif_rx(skb);
174afef4 KV	528	dev->stats.rx_packets++;
174afef4 KV	529	dev->stats.rx_bytes += length;
1da177e4 LT	530	}
	531
	532	/* The inverse routine to net_open(). */
	533	static int
	534	net_close(struct net_device *dev)
	535	{
	536
	537	writereg(dev, PP_RxCFG, 0);
	538	writereg(dev, PP_TxCFG, 0);
	539	writereg(dev, PP_BufCFG, 0);
	540	writereg(dev, PP_BusCTL, 0);
	541
	542	netif_stop_queue(dev);
	543
	544	free_irq(dev->irq, dev);
	545
	546	/* Update the statistics here. */
	547
	548	return 0;
	549
	550	}
	551
	552	/* Get the current statistics. This may be called with the card open or
	553	closed. */
	554	static struct net_device_stats *
	555	net_get_stats(struct net_device *dev)
	556	{
1da177e4 LT	557	unsigned long flags;
	558
	559	local_irq_save(flags);
	560	/* Update the statistics from the device registers. */
174afef4 KV	561	dev->stats.rx_missed_errors += (readreg(dev, PP_RxMiss) >> 6);
174afef4 KV	562	dev->stats.collisions += (readreg(dev, PP_TxCol) >> 6);
1da177e4 LT	563	local_irq_restore(flags);
1da177e4 LT	564
174afef4	565	return &dev->stats;
1da177e4 LT	566	}
	567
	568	static void set_multicast_list(struct net_device *dev)
	569	{
	570	struct net_local *lp = netdev_priv(dev);
	571
	572	if(dev->flags&IFF_PROMISC)
	573	{
	574	lp->rx_mode = RX_ALL_ACCEPT;
f9dcbcc9	575	} else if ((dev->flags & IFF_ALLMULTI) \|\| !netdev_mc_empty(dev)) {
1da177e4 LT	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	{
66dc92ed	593	struct sockaddr *saddr = addr;
9100eb01	594	int i;
66dc92ed	595
9100eb01	596	if (!is_valid_ether_addr(saddr->sa_data))
66dc92ed DK	597	return -EADDRNOTAVAIL;
66dc92ed DK	598
9100eb01	599	memcpy(dev->dev_addr, saddr->sa_data, ETH_ALEN);
66dc92ed DK	600	printk("%s: Setting MAC address to %pM\n", dev->name, dev->dev_addr);
66dc92ed DK	601
1da177e4 LT	602	/* set the Ethernet address */
	603	for (i=0; i < ETH_ALEN/2; i++)
	604	writereg(dev, PP_IA+i2, dev->dev_addr[i2] \| (dev->dev_addr[i*2+1] << 8));
	605
	606	return 0;
	607	}
	608
	609	#ifdef MODULE
	610
	611	static struct net_device *dev_cs89x0;
	612	static int debug;
	613
8d3b33f6	614	module_param(debug, int, 0);
1da177e4 LT	615	MODULE_PARM_DESC(debug, "CS89[02]0 debug level (0-5)");
	616	MODULE_LICENSE("GPL");
	617
446df4c1	618	int __init
1da177e4 LT	619	init_module(void)
	620	{
	621	net_debug = debug;
	622	dev_cs89x0 = mac89x0_probe(-1);
	623	if (IS_ERR(dev_cs89x0)) {
	624	printk(KERN_WARNING "mac89x0.c: No card found\n");
	625	return PTR_ERR(dev_cs89x0);
	626	}
	627	return 0;
	628	}
	629
	630	void
	631	cleanup_module(void)
	632	{
	633	unregister_netdev(dev_cs89x0);
	634	nubus_writew(0, dev_cs89x0->base_addr + ADD_PORT);
	635	free_netdev(dev_cs89x0);
	636	}
	637	#endif /* MODULE */