Skip to content

L
linux
Commit 6fba180e authored by Joe Perches's avatar Joe Perches Committed by David S. Miller
Browse files
Options

cirrus: cs89x0: Remove function prototypes and reorder declarations 

Move blocks of code around to avoid function prototypes.
Signed-off-by: default avatarJoe Perches <joe@perches.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent 808e9a77
Hide whitespace changes
Inline Side-by-side
Showing with 947 additions and 972 deletions
drivers/net/ethernet/cirrus/cs89x0.c
View file @ 6fba180e
...@@ -174,28 +174,6 @@ struct net_local { ...@@ -174,28 +174,6 @@ struct net_local {
#endif #endif
}; };
/* Index to functions, as function prototypes. */
static int net_open(struct net_device *dev);
static netdev_tx_t 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_timeout(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 void reset_chip(struct net_device *dev);
static int get_eeprom_data(struct net_device *dev, int off, int len, int *buffer);
static int get_eeprom_cksum(int off, int len, int *buffer);
static int set_mac_address(struct net_device *dev, void *addr);
static void count_rx_errors(int status, struct net_device *dev);
#ifdef CONFIG_NET_POLL_CONTROLLER
static void net_poll_controller(struct net_device *dev);
#endif
#if ALLOW_DMA
static void get_dma_channel(struct net_device *dev);
static void release_dma_buff(struct net_local *lp);
#endif
/* Example routines you must write ;->. */ /* Example routines you must write ;->. */
#define tx_done(dev) 1 #define tx_done(dev) 1
...@@ -321,7 +299,7 @@ get_eeprom_data(struct net_device *dev, int off, int len, int *buffer) ...@@ -321,7 +299,7 @@ get_eeprom_data(struct net_device *dev, int off, int len, int *buffer)
{ {
int i; int i;
cs89_dbg(3, info, "EEPROM data from %x for %x:\n", off, len); cs89_dbg(3, info, "EEPROM data from %x for %x:", off, len);
for (i = 0; i < len; i++) { for (i = 0; i < len; i++) {
if (wait_eeprom_ready(dev) < 0) if (wait_eeprom_ready(dev) < 0)
return -1; return -1;
...@@ -330,7 +308,7 @@ get_eeprom_data(struct net_device *dev, int off, int len, int *buffer) ...@@ -330,7 +308,7 @@ get_eeprom_data(struct net_device *dev, int off, int len, int *buffer)
if (wait_eeprom_ready(dev) < 0) if (wait_eeprom_ready(dev) < 0)
return -1; return -1;
buffer[i] = readreg(dev, PP_EEData); buffer[i] = readreg(dev, PP_EEData);
cs89_dbg(3, cont, "%04x ", buffer[i]); cs89_dbg(3, cont, " %04x", buffer[i]);
} }
cs89_dbg(3, cont, "\n"); cs89_dbg(3, cont, "\n");
return 0; return 0;
...@@ -350,564 +328,425 @@ get_eeprom_cksum(int off, int len, int *buffer) ...@@ -350,564 +328,425 @@ get_eeprom_cksum(int off, int len, int *buffer)
return -1; return -1;
} }
#ifdef CONFIG_NET_POLL_CONTROLLER static void
/* write_irq(struct net_device *dev, int chip_type, int irq)
* Polling receive - used by netconsole and other diagnostic tools
* to allow network i/o with interrupts disabled.
*/
static void net_poll_controller(struct net_device *dev)
{ {
disable_irq(dev->irq); int i;
net_interrupt(dev->irq, dev);
enable_irq(dev->irq);
}
#endif
static const struct net_device_ops net_ops = { if (chip_type == CS8900) {
.ndo_open = net_open, #ifndef CONFIG_CS89x0_PLATFORM
.ndo_stop = net_close, /* Search the mapping table for the corresponding IRQ pin. */
.ndo_tx_timeout = net_timeout, for (i = 0; i != ARRAY_SIZE(cs8900_irq_map); i++)
.ndo_start_xmit = net_send_packet, if (cs8900_irq_map[i] == irq)
.ndo_get_stats = net_get_stats, break;
.ndo_set_rx_mode = set_multicast_list, /* Not found */
.ndo_set_mac_address = set_mac_address, if (i == ARRAY_SIZE(cs8900_irq_map))
#ifdef CONFIG_NET_POLL_CONTROLLER i = 3;
.ndo_poll_controller = net_poll_controller, #else
/* INTRQ0 pin is used for interrupt generation. */
i = 0;
#endif #endif
.ndo_change_mtu = eth_change_mtu, writereg(dev, PP_CS8900_ISAINT, i);
.ndo_validate_addr = eth_validate_addr, } else {
}; writereg(dev, PP_CS8920_ISAINT, irq);
}
}
/* This is the real probe routine. static void
* Linux has a history of friendly device probes on the ISA bus. count_rx_errors(int status, struct net_device *dev)
* A good device probes avoids doing writes, and
* verifies that the correct device exists and functions.
* Return 0 on success.
*/
static int __init
cs89x0_probe1(struct net_device *dev, void __iomem *ioaddr, int modular)
{ {
struct net_local *lp = netdev_priv(dev); dev->stats.rx_errors++;
int i; if (status & RX_RUNT)
int tmp; dev->stats.rx_length_errors++;
unsigned rev_type = 0; if (status & RX_EXTRA_DATA)
int eeprom_buff[CHKSUM_LEN]; dev->stats.rx_length_errors++;
int retval; 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++;
}
/*********************************
* This page contains DMA routines
*********************************/
/* Initialize the device structure. */
if (!modular) {
memset(lp, 0, sizeof(*lp));
spin_lock_init(&lp->lock);
#ifndef MODULE
#if ALLOW_DMA #if ALLOW_DMA
if (g_cs89x0_dma) {
lp->use_dma = 1; #define dma_page_eq(ptr1, ptr2) ((long)(ptr1) >> 17 == (long)(ptr2) >> 17)
lp->dma = g_cs89x0_dma;
lp->dmasize = 16; /* Could make this an option... */ static void
get_dma_channel(struct net_device *dev)
{
struct net_local *lp = netdev_priv(dev);
if (lp->dma) {
dev->dma = lp->dma;
lp->isa_config |= ISA_RxDMA;
} else {
if ((lp->isa_config & ANY_ISA_DMA) == 0)
return;
dev->dma = lp->isa_config & DMA_NO_MASK;
if (lp->chip_type == CS8900)
dev->dma += 5;
if (dev->dma < 5 || dev->dma > 7) {
lp->isa_config &= ~ANY_ISA_DMA;
return;
} }
#endif
lp->force = g_cs89x0_media__force;
#endif
} }
}
pr_debug("PP_addr at %p[%x]: 0x%x\n", static void
ioaddr, ADD_PORT, ioread16(ioaddr + ADD_PORT)); write_dma(struct net_device *dev, int chip_type, int dma)
iowrite16(PP_ChipID, ioaddr + ADD_PORT); {
struct net_local *lp = netdev_priv(dev);
if ((lp->isa_config & ANY_ISA_DMA) == 0)
return;
if (chip_type == CS8900)
writereg(dev, PP_CS8900_ISADMA, dma - 5);
else
writereg(dev, PP_CS8920_ISADMA, dma);
}
tmp = ioread16(ioaddr + DATA_PORT); static void
if (tmp != CHIP_EISA_ID_SIG) { set_dma_cfg(struct net_device *dev)
pr_debug("%s: incorrect signature at %p[%x]: 0x%x!=" {
CHIP_EISA_ID_SIG_STR "\n", struct net_local *lp = netdev_priv(dev);
dev->name, ioaddr, DATA_PORT, tmp);
retval = -ENODEV;
goto out1;
}
lp->virt_addr = ioaddr; if (lp->use_dma) {
if ((lp->isa_config & ANY_ISA_DMA) == 0) {
cs89_dbg(3, err, "set_dma_cfg(): no DMA\n");
return;
}
if (lp->isa_config & ISA_RxDMA) {
lp->curr_rx_cfg |= RX_DMA_ONLY;
cs89_dbg(3, info, "set_dma_cfg(): RX_DMA_ONLY\n");
} else {
lp->curr_rx_cfg |= AUTO_RX_DMA; /* not that we support it... */
cs89_dbg(3, info, "set_dma_cfg(): AUTO_RX_DMA\n");
}
}
}
/* get the chip type */ static int
rev_type = readreg(dev, PRODUCT_ID_ADD); dma_bufcfg(struct net_device *dev)
lp->chip_type = rev_type & ~REVISON_BITS; {
lp->chip_revision = ((rev_type & REVISON_BITS) >> 8) + 'A'; struct net_local *lp = netdev_priv(dev);
if (lp->use_dma)
return (lp->isa_config & ANY_ISA_DMA) ? RX_DMA_ENBL : 0;
else
return 0;
}
/* Check the chip type and revision in order to set the correct send command static int
CS8920 revision C and CS8900 revision F can use the faster send. */ dma_busctl(struct net_device *dev)
lp->send_cmd = TX_AFTER_381; {
if (lp->chip_type == CS8900 && lp->chip_revision >= 'F') int retval = 0;
lp->send_cmd = TX_NOW; struct net_local *lp = netdev_priv(dev);
if (lp->chip_type != CS8900 && lp->chip_revision >= 'C') if (lp->use_dma) {
lp->send_cmd = TX_NOW; if (lp->isa_config & ANY_ISA_DMA)
retval |= RESET_RX_DMA; /* Reset the DMA pointer */
if (lp->isa_config & DMA_BURST)
retval |= DMA_BURST_MODE; /* Does ISA config specify DMA burst ? */
if (lp->dmasize == 64)
retval |= RX_DMA_SIZE_64K; /* did they ask for 64K? */
retval |= MEMORY_ON; /* we need memory enabled to use DMA. */
}
return retval;
}
pr_info_once("%s\n", version); static void
dma_rx(struct net_device *dev)
{
struct net_local *lp = netdev_priv(dev);
struct sk_buff *skb;
int status, length;
unsigned char *bp = lp->rx_dma_ptr;
pr_info("%s: cs89%c0%s rev %c found at %p ", status = bp[0] + (bp[1] << 8);
dev->name, length = bp[2] + (bp[3] << 8);
lp->chip_type == CS8900 ? '0' : '2', bp += 4;
lp->chip_type == CS8920M ? "M" : "",
lp->chip_revision,
lp->virt_addr);
reset_chip(dev); cs89_dbg(5, debug, "%s: receiving DMA packet at %lx, status %x, length %x\n",
dev->name, (unsigned long)bp, status, length);
/* Here we read the current configuration of the chip. if ((status & RX_OK) == 0) {
* If there is no Extended EEPROM then the idea is to not disturb count_rx_errors(status, dev);
* the chip configuration, it should have been correctly setup by goto skip_this_frame;
* automatic EEPROM read on reset. So, if the chip says it read }
* the EEPROM the driver will always do *something* instead of
* complain that adapter_cnf is 0.
*/
if ((readreg(dev, PP_SelfST) & (EEPROM_OK | EEPROM_PRESENT)) == /* Malloc up new buffer. */
(EEPROM_OK | EEPROM_PRESENT)) { skb = netdev_alloc_skb(dev, length + 2);
/* Load the MAC. */ if (skb == NULL) {
for (i = 0; i < ETH_ALEN / 2; i++) { /* I don't think we want to do this to a stressed system */
unsigned int Addr; cs89_dbg(0, err, "%s: Memory squeeze, dropping packet\n",
Addr = readreg(dev, PP_IA + i * 2); dev->name);
dev->dev_addr[i * 2] = Addr & 0xFF; dev->stats.rx_dropped++;
dev->dev_addr[i * 2 + 1] = Addr >> 8;
}
/* Load the Adapter Configuration. /* AKPM: advance bp to the next frame */
* Note: Barring any more specific information from some skip_this_frame:
* other source (ie EEPROM+Schematics), we would not know bp += (length + 3) & ~3;
* how to operate a 10Base2 interface on the AUI port. if (bp >= lp->end_dma_buff)
* However, since we do read the status of HCB1 and use bp -= lp->dmasize * 1024;
* settings that always result in calls to control_dc_dc(dev,0) lp->rx_dma_ptr = bp;
* a BNC interface should work if the enable pin return;
* (dc/dc converter) is on HCB1. }
* It will be called AUI however. skb_reserve(skb, 2); /* longword align L3 header */
*/
lp->adapter_cnf = 0;
i = readreg(dev, PP_LineCTL);
/* Preserve the setting of the HCB1 pin. */
if ((i & (HCB1 | HCB1_ENBL)) == (HCB1 | HCB1_ENBL))
lp->adapter_cnf |= A_CNF_DC_DC_POLARITY;
/* Save the sqelch bit */
if ((i & LOW_RX_SQUELCH) == LOW_RX_SQUELCH)
lp->adapter_cnf |= A_CNF_EXTND_10B_2 | A_CNF_LOW_RX_SQUELCH;
/* Check if the card is in 10Base-t only mode */
if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == 0)
lp->adapter_cnf |= A_CNF_10B_T | A_CNF_MEDIA_10B_T;
/* Check if the card is in AUI only mode */
if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == AUI_ONLY)
lp->adapter_cnf |= A_CNF_AUI | A_CNF_MEDIA_AUI;
/* Check if the card is in Auto mode. */
if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == AUTO_AUI_10BASET)
lp->adapter_cnf |= A_CNF_AUI | A_CNF_10B_T |
A_CNF_MEDIA_AUI | A_CNF_MEDIA_10B_T | A_CNF_MEDIA_AUTO;
cs89_dbg(1, info, "%s: PP_LineCTL=0x%x, adapter_cnf=0x%x\n",
dev->name, i, lp->adapter_cnf);
/* IRQ. Other chips already probe, see below. */
if (lp->chip_type == CS8900)
lp->isa_config = readreg(dev, PP_CS8900_ISAINT) & INT_NO_MASK;
pr_cont("[Cirrus EEPROM] ");
}
pr_cont("\n");
/* First check to see if an EEPROM is attached. */
if ((readreg(dev, PP_SelfST) & EEPROM_PRESENT) == 0)
pr_warn("No EEPROM, relying on command line....\n");
else if (get_eeprom_data(dev, START_EEPROM_DATA, CHKSUM_LEN, eeprom_buff) < 0) {
pr_warn("EEPROM read failed, relying on command line\n");
} else if (get_eeprom_cksum(START_EEPROM_DATA, CHKSUM_LEN, eeprom_buff) < 0) {
/* Check if the chip was able to read its own configuration starting
at 0 in the EEPROM*/
if ((readreg(dev, PP_SelfST) & (EEPROM_OK | EEPROM_PRESENT)) !=
(EEPROM_OK | EEPROM_PRESENT))
pr_warn("Extended EEPROM checksum bad and no Cirrus EEPROM, relying on command line\n");
if (bp + length > lp->end_dma_buff) {
int semi_cnt = lp->end_dma_buff - bp;
memcpy(skb_put(skb, semi_cnt), bp, semi_cnt);
memcpy(skb_put(skb, length - semi_cnt), lp->dma_buff,
length - semi_cnt);
} else { } else {
/* This reads an extended EEPROM that is not documented memcpy(skb_put(skb, length), bp, length);
* in the CS8900 datasheet.
*/
/* get transmission control word but keep the autonegotiation bits */
if (!lp->auto_neg_cnf)
lp->auto_neg_cnf = eeprom_buff[AUTO_NEG_CNF_OFFSET / 2];
/* Store adapter configuration */
if (!lp->adapter_cnf)
lp->adapter_cnf = eeprom_buff[ADAPTER_CNF_OFFSET / 2];
/* Store ISA configuration */
lp->isa_config = eeprom_buff[ISA_CNF_OFFSET / 2];
dev->mem_start = eeprom_buff[PACKET_PAGE_OFFSET / 2] << 8;
/* eeprom_buff has 32-bit ints, so we can't just memcpy it */
/* store the initial memory base address */
for (i = 0; i < ETH_ALEN / 2; i++) {
dev->dev_addr[i * 2] = eeprom_buff[i];
dev->dev_addr[i * 2 + 1] = eeprom_buff[i] >> 8;
}
cs89_dbg(1, debug, "%s: new adapter_cnf: 0x%x\n",
dev->name, lp->adapter_cnf);
} }
bp += (length + 3) & ~3;
if (bp >= lp->end_dma_buff)
bp -= lp->dmasize*1024;
lp->rx_dma_ptr = bp;
/* allow them to force multiple transceivers. If they force multiple, autosense */ cs89_dbg(3, info, "%s: received %d byte DMA packet of type %x\n",
{ dev->name, length,
int count = 0; ((skb->data[ETH_ALEN + ETH_ALEN] << 8) |
if (lp->force & FORCE_RJ45) { skb->data[ETH_ALEN + ETH_ALEN + 1]));
lp->adapter_cnf |= A_CNF_10B_T;
count++;
}
if (lp->force & FORCE_AUI) {
lp->adapter_cnf |= A_CNF_AUI;
count++;
}
if (lp->force & FORCE_BNC) {
lp->adapter_cnf |= A_CNF_10B_2;
count++;
}
if (count > 1)
lp->adapter_cnf |= A_CNF_MEDIA_AUTO;
else if (lp->force & FORCE_RJ45)
lp->adapter_cnf |= A_CNF_MEDIA_10B_T;
else if (lp->force & FORCE_AUI)
lp->adapter_cnf |= A_CNF_MEDIA_AUI;
else if (lp->force & FORCE_BNC)
lp->adapter_cnf |= A_CNF_MEDIA_10B_2;
}
cs89_dbg(1, debug, "%s: after force 0x%x, adapter_cnf=0x%x\n", skb->protocol = eth_type_trans(skb, dev);
dev->name, lp->force, lp->adapter_cnf); netif_rx(skb);
dev->stats.rx_packets++;
dev->stats.rx_bytes += length;
}
/* FIXME: We don't let you set dc-dc polarity or low RX squelch from the command line: add it here */ static void release_dma_buff(struct net_local *lp)
{
if (lp->dma_buff) {
free_pages((unsigned long)(lp->dma_buff),
get_order(lp->dmasize * 1024));
lp->dma_buff = NULL;
}
}
/* FIXME: We don't let you set the IMM bit from the command line: add it to lp->auto_neg_cnf here */ #endif /* ALLOW_DMA */
/* FIXME: we don't set the Ethernet address on the command line. Use static void
* ifconfig IFACE hw ether AABBCCDDEEFF control_dc_dc(struct net_device *dev, int on_not_off)
{
struct net_local *lp = netdev_priv(dev);
unsigned int selfcontrol;
int timenow = jiffies;
/* control the DC to DC convertor in the SelfControl register.
* Note: This is hooked up to a general purpose pin, might not
* always be a DC to DC convertor.
*/ */
pr_info("media %s%s%s", selfcontrol = HCB1_ENBL; /* Enable the HCB1 bit as an output */
(lp->adapter_cnf & A_CNF_10B_T) ? "RJ-45," : "", if (((lp->adapter_cnf & A_CNF_DC_DC_POLARITY) != 0) ^ on_not_off)
(lp->adapter_cnf & A_CNF_AUI) ? "AUI," : "", selfcontrol |= HCB1;
(lp->adapter_cnf & A_CNF_10B_2) ? "BNC," : ""); else
selfcontrol &= ~HCB1;
lp->irq_map = 0xffff; writereg(dev, PP_SelfCTL, selfcontrol);
/* If this is a CS8900 then no pnp soft */
if (lp->chip_type != CS8900 &&
/* Check if the ISA IRQ has been set */
(i = readreg(dev, PP_CS8920_ISAINT) & 0xff,
(i != 0 && i < CS8920_NO_INTS))) {
if (!dev->irq)
dev->irq = i;
} else {
i = lp->isa_config & INT_NO_MASK;
#ifndef CONFIG_CS89x0_PLATFORM
if (lp->chip_type == CS8900) {
#ifdef CS89x0_NONISA_IRQ
i = cs8900_irq_map[0];
#else
/* Translate the IRQ using the IRQ mapping table. */
if (i >= ARRAY_SIZE(cs8900_irq_map))
pr_err("invalid ISA interrupt number %d\n", i);
else
i = cs8900_irq_map[i];
lp->irq_map = CS8900_IRQ_MAP; /* fixed IRQ map for CS8900 */ /* Wait for the DC/DC converter to power up - 500ms */
} else { while (jiffies - timenow < HZ)
int irq_map_buff[IRQ_MAP_LEN/2]; ;
}
if (get_eeprom_data(dev, IRQ_MAP_EEPROM_DATA, /* send a test packet - return true if carrier bits are ok */
IRQ_MAP_LEN / 2, static int
irq_map_buff) >= 0) { send_test_pkt(struct net_device *dev)
if ((irq_map_buff[0] & 0xff) == PNP_IRQ_FRMT) {
lp->irq_map = ((irq_map_buff[0] >> 8) | struct net_local *lp = netdev_priv(dev);
(irq_map_buff[1] << 8)); char test_packet[] = {
} 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
#endif 0, 46, /* A 46 in network order */
} 0, 0, /* DSAP=0 & SSAP=0 fields */
#endif 0xf3, 0 /* Control (Test Req + P bit set) */
if (!dev->irq) };
dev->irq = i; long timenow = jiffies;
}
pr_cont(" IRQ %d", dev->irq); writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) | SERIAL_TX_ON);
#if ALLOW_DMA memcpy(test_packet, dev->dev_addr, ETH_ALEN);
if (lp->use_dma) { memcpy(test_packet + ETH_ALEN, dev->dev_addr, ETH_ALEN);
get_dma_channel(dev);
pr_cont(", DMA %d", dev->dma);
} else
#endif
pr_cont(", programmed I/O");
/* print the ethernet address. */ iowrite16(TX_AFTER_ALL, lp->virt_addr + TX_CMD_PORT);
pr_cont(", MAC %pM\n", dev->dev_addr); iowrite16(ETH_ZLEN, lp->virt_addr + TX_LEN_PORT);
dev->netdev_ops = &net_ops; /* Test to see if the chip has allocated memory for the packet */
dev->watchdog_timeo = HZ; while (jiffies - timenow < 5)
if (readreg(dev, PP_BusST) & READY_FOR_TX_NOW)
break;
if (jiffies - timenow >= 5)
return 0; /* this shouldn't happen */
cs89_dbg(0, info, "cs89x0_probe1() successful\n"); /* Write the contents of the packet */
writewords(lp, TX_FRAME_PORT, test_packet, (ETH_ZLEN + 1) >> 1);
retval = register_netdev(dev); cs89_dbg(1, debug, "Sending test packet ");
if (retval) /* wait a couple of jiffies for packet to be received */
goto out2; for (timenow = jiffies; jiffies - timenow < 3;)
;
if ((readreg(dev, PP_TxEvent) & TX_SEND_OK_BITS) == TX_OK) {
cs89_dbg(1, cont, "succeeded\n");
return 1;
}
cs89_dbg(1, cont, "failed\n");
return 0; return 0;
out2:
iowrite16(PP_ChipID, lp->virt_addr + ADD_PORT);
out1:
return retval;
} }
#ifndef CONFIG_CS89x0_PLATFORM #define DETECTED_NONE 0
/* #define DETECTED_RJ45H 1
* This function converts the I/O port addres used by the cs89x0_probe() and #define DETECTED_RJ45F 2
* init_module() functions to the I/O memory address used by the #define DETECTED_AUI 3
* cs89x0_probe1() function. #define DETECTED_BNC 4
*/
static int __init static int
cs89x0_ioport_probe(struct net_device *dev, unsigned long ioport, int modular) detect_tp(struct net_device *dev)
{ {
struct net_local *lp = netdev_priv(dev); struct net_local *lp = netdev_priv(dev);
int ret; int timenow = jiffies;
void __iomem *io_mem; int fdx;
if (!lp)
return -ENOMEM;
dev->base_addr = ioport;
if (!request_region(ioport, NETCARD_IO_EXTENT, DRV_NAME)) {
ret = -EBUSY;
goto out;
}
io_mem = ioport_map(ioport & ~3, NETCARD_IO_EXTENT); cs89_dbg(1, debug, "%s: Attempting TP\n", dev->name);
if (!io_mem) {
ret = -ENOMEM;
goto release;
}
/* if they give us an odd I/O address, then do ONE write to /* If connected to another full duplex capable 10-Base-T card
* the address port, to get it back to address zero, where we * the link pulses seem to be lost when the auto detect bit in
* expect to find the EISA signature word. An IO with a base of 0x3 * the LineCTL is set. To overcome this the auto detect bit will
* will skip the test for the ADD_PORT. * be cleared whilst testing the 10-Base-T interface. This would
* not be necessary for the sparrow chip but is simpler to do it
* anyway.
*/ */
if (ioport & 1) { writereg(dev, PP_LineCTL, lp->linectl & ~AUI_ONLY);
cs89_dbg(1, info, "%s: odd ioaddr 0x%lx\n", dev->name, ioport); control_dc_dc(dev, 0);
if ((ioport & 2) != 2) {
if ((ioread16(io_mem + ADD_PORT) & ADD_MASK) !=
ADD_SIG) {
pr_err("%s: bad signature 0x%x\n",
dev->name, ioread16(io_mem + ADD_PORT));
ret = -ENODEV;
goto unmap;
}
}
}
ret = cs89x0_probe1(dev, io_mem, modular);
if (!ret)
goto out;
unmap:
ioport_unmap(io_mem);
release:
release_region(ioport, NETCARD_IO_EXTENT);
out:
return ret;
}
#ifndef MODULE
/* Check for a network adaptor of this type, and return '0' iff one exists.
* If dev->base_addr == 0, probe all likely locations.
* If dev->base_addr == 1, always return failure.
* If dev->base_addr == 2, allocate space for the device and return success
* (detachable devices only).
* Return 0 on success.
*/
struct net_device * __init cs89x0_probe(int unit)
{
struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
unsigned *port;
int err = 0;
int irq;
int io;
if (!dev)
return ERR_PTR(-ENODEV);
sprintf(dev->name, "eth%d", unit);
netdev_boot_setup_check(dev);
io = dev->base_addr;
irq = dev->irq;
cs89_dbg(0, info, "cs89x0_probe(0x%x)\n", io); /* Delay for the hardware to work out if the TP cable is present
* - 150ms
*/
for (timenow = jiffies; jiffies - timenow < 15;)
;
if ((readreg(dev, PP_LineST) & LINK_OK) == 0)
return DETECTED_NONE;
if (io > 0x1ff) { /* Check a single specified location. */ if (lp->chip_type == CS8900) {
err = cs89x0_ioport_probe(dev, io, 0); switch (lp->force & 0xf0) {
} else if (io != 0) { /* Don't probe at all. */ #if 0
err = -ENXIO; case FORCE_AUTO:
pr_info("%s: cs8900 doesn't autonegotiate\n",
dev->name);
return DETECTED_NONE;
#endif
/* CS8900 doesn't support AUTO, change to HALF*/
case FORCE_AUTO:
lp->force &= ~FORCE_AUTO;
lp->force |= FORCE_HALF;
break;
case FORCE_HALF:
break;
case FORCE_FULL:
writereg(dev, PP_TestCTL,
readreg(dev, PP_TestCTL) | FDX_8900);
break;
}
fdx = readreg(dev, PP_TestCTL) & FDX_8900;
} else { } else {
for (port = netcard_portlist; *port; port++) { switch (lp->force & 0xf0) {
if (cs89x0_ioport_probe(dev, *port, 0) == 0) case FORCE_AUTO:
break; lp->auto_neg_cnf = AUTO_NEG_ENABLE;
dev->irq = irq; break;
case FORCE_HALF:
lp->auto_neg_cnf = 0;
break;
case FORCE_FULL:
lp->auto_neg_cnf = RE_NEG_NOW | ALLOW_FDX;
break;
} }
if (!*port)
err = -ENODEV;
}
if (err)
goto out;
return dev;
out:
free_netdev(dev);
pr_warn("no cs8900 or cs8920 detected. Be sure to disable PnP with SETUP\n");
return ERR_PTR(err);
}
#endif
#endif
/*********************************
* This page contains DMA routines
*********************************/
#if ALLOW_DMA
#define dma_page_eq(ptr1, ptr2) ((long)(ptr1) >> 17 == (long)(ptr2) >> 17)
static void writereg(dev, PP_AutoNegCTL, lp->auto_neg_cnf & AUTO_NEG_MASK);
get_dma_channel(struct net_device *dev)
{
struct net_local *lp = netdev_priv(dev);
if (lp->dma) { if ((lp->auto_neg_cnf & AUTO_NEG_BITS) == AUTO_NEG_ENABLE) {
dev->dma = lp->dma; pr_info("%s: negotiating duplex...\n", dev->name);
lp->isa_config |= ISA_RxDMA; while (readreg(dev, PP_AutoNegST) & AUTO_NEG_BUSY) {
} else { if (jiffies - timenow > 4000) {
if ((lp->isa_config & ANY_ISA_DMA) == 0) pr_err("**** Full / half duplex auto-negotiation timed out ****\n");
return; break;
dev->dma = lp->isa_config & DMA_NO_MASK; }
if (lp->chip_type == CS8900) }
dev->dma += 5;
if (dev->dma < 5 || dev->dma > 7) {
lp->isa_config &= ~ANY_ISA_DMA;
return;
} }
fdx = readreg(dev, PP_AutoNegST) & FDX_ACTIVE;
} }
} if (fdx)
return DETECTED_RJ45F;
static void
write_dma(struct net_device *dev, int chip_type, int dma)
{
struct net_local *lp = netdev_priv(dev);
if ((lp->isa_config & ANY_ISA_DMA) == 0)
return;
if (chip_type == CS8900)
writereg(dev, PP_CS8900_ISADMA, dma - 5);
else else
writereg(dev, PP_CS8920_ISADMA, dma); return DETECTED_RJ45H;
} }
static void static int
set_dma_cfg(struct net_device *dev) detect_bnc(struct net_device *dev)
{ {
struct net_local *lp = netdev_priv(dev); struct net_local *lp = netdev_priv(dev);
if (lp->use_dma) { cs89_dbg(1, debug, "%s: Attempting BNC\n", dev->name);
if ((lp->isa_config & ANY_ISA_DMA) == 0) { control_dc_dc(dev, 1);
cs89_dbg(3, err, "set_dma_cfg(): no DMA\n");
return;
}
if (lp->isa_config & ISA_RxDMA) {
lp->curr_rx_cfg |= RX_DMA_ONLY;
cs89_dbg(3, info, "set_dma_cfg(): RX_DMA_ONLY\n");
} else {
lp->curr_rx_cfg |= AUTO_RX_DMA; /* not that we support it... */
cs89_dbg(3, info, "set_dma_cfg(): AUTO_RX_DMA\n");
}
}
}
static int writereg(dev, PP_LineCTL, (lp->linectl & ~AUTO_AUI_10BASET) | AUI_ONLY);
dma_bufcfg(struct net_device *dev)
{ if (send_test_pkt(dev))
struct net_local *lp = netdev_priv(dev); return DETECTED_BNC;
if (lp->use_dma)
return (lp->isa_config & ANY_ISA_DMA) ? RX_DMA_ENBL : 0;
else else
return 0; return DETECTED_NONE;
} }
static int static int
dma_busctl(struct net_device *dev) detect_aui(struct net_device *dev)
{ {
int retval = 0;
struct net_local *lp = netdev_priv(dev); struct net_local *lp = netdev_priv(dev);
if (lp->use_dma) {
if (lp->isa_config & ANY_ISA_DMA) cs89_dbg(1, debug, "%s: Attempting AUI\n", dev->name);
retval |= RESET_RX_DMA; /* Reset the DMA pointer */ control_dc_dc(dev, 0);
if (lp->isa_config & DMA_BURST)
retval |= DMA_BURST_MODE; /* Does ISA config specify DMA burst ? */ writereg(dev, PP_LineCTL, (lp->linectl & ~AUTO_AUI_10BASET) | AUI_ONLY);
if (lp->dmasize == 64)
retval |= RX_DMA_SIZE_64K; /* did they ask for 64K? */ if (send_test_pkt(dev))
retval |= MEMORY_ON; /* we need memory enabled to use DMA. */ return DETECTED_AUI;
} else
return retval; return DETECTED_NONE;
} }
/* We have a good packet(s), get it/them out of the buffers. */
static void static void
dma_rx(struct net_device *dev) net_rx(struct net_device *dev)
{ {
struct net_local *lp = netdev_priv(dev); struct net_local *lp = netdev_priv(dev);
struct sk_buff *skb; struct sk_buff *skb;
int status, length; int status, length;
unsigned char *bp = lp->rx_dma_ptr;
status = bp[0] + (bp[1] << 8);
length = bp[2] + (bp[3] << 8);
bp += 4;
cs89_dbg(5, debug, "%s: receiving DMA packet at %lx, status %x, length %x\n", status = ioread16(lp->virt_addr + RX_FRAME_PORT);
dev->name, (unsigned long)bp, status, length); length = ioread16(lp->virt_addr + RX_FRAME_PORT);
if ((status & RX_OK) == 0) { if ((status & RX_OK) == 0) {
count_rx_errors(status, dev); count_rx_errors(status, dev);
goto skip_this_frame; return;
} }
/* Malloc up new buffer. */ /* Malloc up new buffer. */
skb = netdev_alloc_skb(dev, length + 2); skb = netdev_alloc_skb(dev, length + 2);
if (skb == NULL) { if (skb == NULL) {
/* I don't think we want to do this to a stressed system */ #if 0 /* Again, this seems a cruel thing to do */
cs89_dbg(0, err, "%s: Memory squeeze, dropping packet\n", pr_warn("%s: Memory squeeze, dropping packet\n", dev->name);
dev->name); #endif
dev->stats.rx_dropped++; dev->stats.rx_dropped++;
/* AKPM: advance bp to the next frame */
skip_this_frame:
bp += (length + 3) & ~3;
if (bp >= lp->end_dma_buff)
bp -= lp->dmasize * 1024;
lp->rx_dma_ptr = bp;
return; return;
} }
skb_reserve(skb, 2); /* longword align L3 header */ skb_reserve(skb, 2); /* longword align L3 header */
if (bp + length > lp->end_dma_buff) { readwords(lp, RX_FRAME_PORT, skb_put(skb, length), length >> 1);
int semi_cnt = lp->end_dma_buff - bp; if (length & 1)
memcpy(skb_put(skb, semi_cnt), bp, semi_cnt); skb->data[length-1] = ioread16(lp->virt_addr + RX_FRAME_PORT);
memcpy(skb_put(skb, length - semi_cnt), lp->dma_buff,
length - semi_cnt);
} else {
memcpy(skb_put(skb, length), bp, length);
}
bp += (length + 3) & ~3;
if (bp >= lp->end_dma_buff)
bp -= lp->dmasize*1024;
lp->rx_dma_ptr = bp;
cs89_dbg(3, info, "%s: received %d byte DMA packet of type %x\n", cs89_dbg(3, debug, "%s: received %d byte packet of type %x\n",
dev->name, length, dev->name, length,
((skb->data[ETH_ALEN + ETH_ALEN] << 8) | (skb->data[ETH_ALEN + ETH_ALEN] << 8) |
skb->data[ETH_ALEN + ETH_ALEN + 1])); skb->data[ETH_ALEN + ETH_ALEN + 1]);
skb->protocol = eth_type_trans(skb, dev); skb->protocol = eth_type_trans(skb, dev);
netif_rx(skb); netif_rx(skb);
...@@ -915,278 +754,137 @@ dma_rx(struct net_device *dev) ...@@ -915,278 +754,137 @@ dma_rx(struct net_device *dev)
dev->stats.rx_bytes += length; dev->stats.rx_bytes += length;
} }
#endif /* ALLOW_DMA */ /* The typical workload of the driver:
* Handle the network interface interrupts.
*/
static void __init reset_chip(struct net_device *dev) static irqreturn_t net_interrupt(int irq, void *dev_id)
{ {
#if !defined(CONFIG_MACH_MX31ADS) struct net_device *dev = dev_id;
#if !defined(CS89x0_NONISA_IRQ) struct net_local *lp;
struct net_local *lp = netdev_priv(dev); int status;
#endif /* CS89x0_NONISA_IRQ */ int handled = 0;
int reset_start_time;
writereg(dev, PP_SelfCTL, readreg(dev, PP_SelfCTL) | POWER_ON_RESET);
/* wait 30 ms */
msleep(30);
#if !defined(CS89x0_NONISA_IRQ) lp = netdev_priv(dev);
if (lp->chip_type != CS8900) {
/* Hardware problem requires PNP registers to be reconfigured after a reset */
iowrite16(PP_CS8920_ISAINT, lp->virt_addr + ADD_PORT);
iowrite8(dev->irq, lp->virt_addr + DATA_PORT);
iowrite8(0, lp->virt_addr + DATA_PORT + 1);
iowrite16(PP_CS8920_ISAMemB, lp->virt_addr + ADD_PORT); /* we MUST read all the events out of the ISQ, otherwise we'll never
iowrite8((dev->mem_start >> 16) & 0xff, * get interrupted again. As a consequence, we can't have any limit
lp->virt_addr + DATA_PORT); * on the number of times we loop in the interrupt handler. The
iowrite8((dev->mem_start >> 8) & 0xff, * hardware guarantees that eventually we'll run out of events. Of
lp->virt_addr + DATA_PORT + 1); * 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 = ioread16(lp->virt_addr + ISQ_PORT))) {
cs89_dbg(4, debug, "%s: event=%04x\n", dev->name, status);
handled = 1;
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); /* Inform upper layers. */
if ((status & (TX_OK |
TX_LOST_CRS |
TX_SQE_ERROR |
TX_LATE_COL |
TX_16_COL)) != TX_OK) {
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); /* Inform upper layers. */
}
if (status & TX_UNDERRUN) {
cs89_dbg(0, err, "%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;
/* transmit cycle is done, although
* frame wasn't transmitted - this
* avoids having to wait for the upper
* layers to timeout on us, in the
* event of a tx underrun
*/
netif_wake_queue(dev); /* Inform upper layers. */
}
#if ALLOW_DMA
if (lp->use_dma && (status & RX_DMA)) {
int count = readreg(dev, PP_DmaFrameCnt);
while (count) {
cs89_dbg(5, debug,
"%s: receiving %d DMA frames\n",
dev->name, count);
if (count > 1)
cs89_dbg(2, debug,
"%s: receiving %d DMA frames\n",
dev->name, count);
dma_rx(dev);
if (--count == 0)
count = readreg(dev, PP_DmaFrameCnt);
if (count > 0)
cs89_dbg(2, debug,
"%s: continuing with %d DMA frames\n",
dev->name, count);
}
}
#endif
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;
}
} }
#endif /* CS89x0_NONISA_IRQ */ return IRQ_RETVAL(handled);
/* Wait until the chip is reset */
reset_start_time = jiffies;
while ((readreg(dev, PP_SelfST) & INIT_DONE) == 0 &&
jiffies - reset_start_time < 2)
;
#endif /* !CONFIG_MACH_MX31ADS */
} }
/* Open/initialize the board. This is called (in the current kernel)
sometime after booting when the 'ifconfig' program is run.
static void This routine should set everything up anew at each open, even
control_dc_dc(struct net_device *dev, int on_not_off) registers that "should" only need to be set once at boot, so that
{ there is non-reboot way to recover if something goes wrong.
struct net_local *lp = netdev_priv(dev); */
unsigned int selfcontrol;
int timenow = jiffies;
/* control the DC to DC convertor in the SelfControl register.
* Note: This is hooked up to a general purpose pin, might not
* always be a DC to DC convertor.
*/
selfcontrol = HCB1_ENBL; /* Enable the HCB1 bit as an output */
if (((lp->adapter_cnf & A_CNF_DC_DC_POLARITY) != 0) ^ on_not_off)
selfcontrol |= HCB1;
else
selfcontrol &= ~HCB1;
writereg(dev, PP_SelfCTL, selfcontrol);
/* Wait for the DC/DC converter to power up - 500ms */
while (jiffies - timenow < HZ)
;
}
#define DETECTED_NONE 0 /* AKPM: do we need to do any locking here? */
#define DETECTED_RJ45H 1
#define DETECTED_RJ45F 2
#define DETECTED_AUI 3
#define DETECTED_BNC 4
static int static int
detect_tp(struct net_device *dev) net_open(struct net_device *dev)
{ {
struct net_local *lp = netdev_priv(dev); struct net_local *lp = netdev_priv(dev);
int timenow = jiffies; int result = 0;
int fdx; int i;
int ret;
cs89_dbg(1, debug, "%s: Attempting TP\n", dev->name);
/* If connected to another full duplex capable 10-Base-T card
* the link pulses seem to be lost when the auto detect bit in
* the LineCTL is set. To overcome this the auto detect bit will
* be cleared whilst testing the 10-Base-T interface. This would
* not be necessary for the sparrow chip but is simpler to do it
* anyway.
*/
writereg(dev, PP_LineCTL, lp->linectl & ~AUI_ONLY);
control_dc_dc(dev, 0);
/* Delay for the hardware to work out if the TP cable is present
* - 150ms
*/
for (timenow = jiffies; jiffies - timenow < 15;)
;
if ((readreg(dev, PP_LineST) & LINK_OK) == 0)
return DETECTED_NONE;
if (lp->chip_type == CS8900) { if (dev->irq < 2) {
switch (lp->force & 0xf0) { /* Allow interrupts to be generated by the chip */
/* Cirrus' release had this: */
#if 0 #if 0
case FORCE_AUTO: writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL) | ENABLE_IRQ);
pr_info("%s: cs8900 doesn't autonegotiate\n",
dev->name);
return DETECTED_NONE;
#endif
/* CS8900 doesn't support AUTO, change to HALF*/
case FORCE_AUTO:
lp->force &= ~FORCE_AUTO;
lp->force |= FORCE_HALF;
break;
case FORCE_HALF:
break;
case FORCE_FULL:
writereg(dev, PP_TestCTL,
readreg(dev, PP_TestCTL) | FDX_8900);
break;
}
fdx = readreg(dev, PP_TestCTL) & FDX_8900;
} else {
switch (lp->force & 0xf0) {
case FORCE_AUTO:
lp->auto_neg_cnf = AUTO_NEG_ENABLE;
break;
case FORCE_HALF:
lp->auto_neg_cnf = 0;
break;
case FORCE_FULL:
lp->auto_neg_cnf = RE_NEG_NOW | ALLOW_FDX;
break;
}
writereg(dev, PP_AutoNegCTL, lp->auto_neg_cnf & AUTO_NEG_MASK);
if ((lp->auto_neg_cnf & AUTO_NEG_BITS) == AUTO_NEG_ENABLE) {
pr_info("%s: negotiating duplex...\n", dev->name);
while (readreg(dev, PP_AutoNegST) & AUTO_NEG_BUSY) {
if (jiffies - timenow > 4000) {
pr_err("**** Full / half duplex auto-negotiation timed out ****\n");
break;
}
}
}
fdx = readreg(dev, PP_AutoNegST) & FDX_ACTIVE;
}
if (fdx)
return DETECTED_RJ45F;
else
return DETECTED_RJ45H;
}
/* send a test packet - return true if carrier bits are ok */
static int
send_test_pkt(struct net_device *dev)
{
struct net_local *lp = netdev_priv(dev);
char test_packet[] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 46, /* A 46 in network order */
0, 0, /* DSAP=0 & SSAP=0 fields */
0xf3, 0 /* Control (Test Req + P bit set) */
};
long timenow = jiffies;
writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) | SERIAL_TX_ON);
memcpy(test_packet, dev->dev_addr, ETH_ALEN);
memcpy(test_packet + ETH_ALEN, dev->dev_addr, ETH_ALEN);
iowrite16(TX_AFTER_ALL, lp->virt_addr + TX_CMD_PORT);
iowrite16(ETH_ZLEN, lp->virt_addr + TX_LEN_PORT);
/* Test to see if the chip has allocated memory for the packet */
while (jiffies - timenow < 5)
if (readreg(dev, PP_BusST) & READY_FOR_TX_NOW)
break;
if (jiffies - timenow >= 5)
return 0; /* this shouldn't happen */
/* Write the contents of the packet */
writewords(lp, TX_FRAME_PORT, test_packet, (ETH_ZLEN + 1) >> 1);
cs89_dbg(1, debug, "Sending test packet ");
/* wait a couple of jiffies for packet to be received */
for (timenow = jiffies; jiffies - timenow < 3;)
;
if ((readreg(dev, PP_TxEvent) & TX_SEND_OK_BITS) == TX_OK) {
cs89_dbg(1, cont, "succeeded\n");
return 1;
}
cs89_dbg(1, cont, "failed\n");
return 0;
}
static int
detect_aui(struct net_device *dev)
{
struct net_local *lp = netdev_priv(dev);
cs89_dbg(1, debug, "%s: Attempting AUI\n", dev->name);
control_dc_dc(dev, 0);
writereg(dev, PP_LineCTL, (lp->linectl & ~AUTO_AUI_10BASET) | AUI_ONLY);
if (send_test_pkt(dev))
return DETECTED_AUI;
else
return DETECTED_NONE;
}
static int
detect_bnc(struct net_device *dev)
{
struct net_local *lp = netdev_priv(dev);
cs89_dbg(1, debug, "%s: Attempting BNC\n", dev->name);
control_dc_dc(dev, 1);
writereg(dev, PP_LineCTL, (lp->linectl & ~AUTO_AUI_10BASET) | AUI_ONLY);
if (send_test_pkt(dev))
return DETECTED_BNC;
else
return DETECTED_NONE;
}
static void
write_irq(struct net_device *dev, int chip_type, int irq)
{
int i;
if (chip_type == CS8900) {
#ifndef CONFIG_CS89x0_PLATFORM
/* Search the mapping table for the corresponding IRQ pin. */
for (i = 0; i != ARRAY_SIZE(cs8900_irq_map); i++)
if (cs8900_irq_map[i] == irq)
break;
/* Not found */
if (i == ARRAY_SIZE(cs8900_irq_map))
i = 3;
#else
/* INTRQ0 pin is used for interrupt generation. */
i = 0;
#endif
writereg(dev, PP_CS8900_ISAINT, i);
} else {
writereg(dev, PP_CS8920_ISAINT, irq);
}
}
/* 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.
*/
/* AKPM: do we need to do any locking here? */
static int
net_open(struct net_device *dev)
{
struct net_local *lp = netdev_priv(dev);
int result = 0;
int i;
int ret;
if (dev->irq < 2) {
/* Allow interrupts to be generated by the chip */
/* Cirrus' release had this: */
#if 0
writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL) | ENABLE_IRQ);
#endif #endif
/* And 2.3.47 had this: */ /* And 2.3.47 had this: */
writereg(dev, PP_BusCTL, ENABLE_IRQ | MEMORY_ON); writereg(dev, PP_BusCTL, ENABLE_IRQ | MEMORY_ON);
...@@ -1433,6 +1131,52 @@ net_open(struct net_device *dev) ...@@ -1433,6 +1131,52 @@ net_open(struct net_device *dev)
return ret; return ret;
} }
/* The inverse routine to net_open(). */
static int
net_close(struct net_device *dev)
{
#if ALLOW_DMA
struct net_local *lp = netdev_priv(dev);
#endif
netif_stop_queue(dev);
writereg(dev, PP_RxCFG, 0);
writereg(dev, PP_TxCFG, 0);
writereg(dev, PP_BufCFG, 0);
writereg(dev, PP_BusCTL, 0);
free_irq(dev->irq, dev);
#if ALLOW_DMA
if (lp->use_dma && lp->dma) {
free_dma(dev->dma);
release_dma_buff(lp);
}
#endif
/* 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;
spin_lock_irqsave(&lp->lock, 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);
spin_unlock_irqrestore(&lp->lock, flags);
return &dev->stats;
}
static void net_timeout(struct net_device *dev) static void net_timeout(struct net_device *dev)
{ {
/* If we get here, some higher level has decided we are broken. /* If we get here, some higher level has decided we are broken.
...@@ -1495,278 +1239,509 @@ static netdev_tx_t net_send_packet(struct sk_buff *skb, struct net_device *dev) ...@@ -1495,278 +1239,509 @@ static netdev_tx_t net_send_packet(struct sk_buff *skb, struct net_device *dev)
return NETDEV_TX_OK; return NETDEV_TX_OK;
} }
/* The typical workload of the driver: static void set_multicast_list(struct net_device *dev)
* 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 = netdev_priv(dev);
struct net_local *lp; unsigned long flags;
int status;
int handled = 0;
lp = netdev_priv(dev); spin_lock_irqsave(&lp->lock, flags);
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;
/* we MUST read all the events out of the ISQ, otherwise we'll never writereg(dev, PP_RxCTL, DEF_RX_ACCEPT | lp->rx_mode);
* get interrupted again. As a consequence, we can't have any limit
* on the number of times we loop in the interrupt handler. The /* in promiscuous mode, we accept errored packets,
* hardware guarantees that eventually we'll run out of events. Of * so we have to enable interrupts on them also
* 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 = ioread16(lp->virt_addr + ISQ_PORT))) { writereg(dev, PP_RxCFG,
cs89_dbg(4, debug, "%s: event=%04x\n", dev->name, status); (lp->curr_rx_cfg |
handled = 1; (lp->rx_mode == RX_ALL_ACCEPT)
switch (status & ISQ_EVENT_MASK) { ? (RX_CRC_ERROR_ENBL | RX_RUNT_ENBL | RX_EXTRA_DATA_ENBL)
case ISQ_RECEIVER_EVENT: : 0));
/* Got a packet(s). */ spin_unlock_irqrestore(&lp->lock, flags);
net_rx(dev);
break;
case ISQ_TRANSMITTER_EVENT:
dev->stats.tx_packets++;
netif_wake_queue(dev); /* Inform upper layers. */
if ((status & (TX_OK |
TX_LOST_CRS |
TX_SQE_ERROR |
TX_LATE_COL |
TX_16_COL)) != TX_OK) {
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); /* Inform upper layers. */
}
if (status & TX_UNDERRUN) {
cs89_dbg(0, err, "%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;
/* transmit cycle is done, although
* frame wasn't transmitted - this
* avoids having to wait for the upper
* layers to timeout on us, in the
* event of a tx underrun
*/
netif_wake_queue(dev); /* Inform upper layers. */
}
#if ALLOW_DMA
if (lp->use_dma && (status & RX_DMA)) {
int count = readreg(dev, PP_DmaFrameCnt);
while (count) {
cs89_dbg(5, debug,
"%s: receiving %d DMA frames\n",
dev->name, count);
if (count > 1)
cs89_dbg(2, debug,
"%s: receiving %d DMA frames\n",
dev->name, count);
dma_rx(dev);
if (--count == 0)
count = readreg(dev, PP_DmaFrameCnt);
if (count > 0)
cs89_dbg(2, debug,
"%s: continuing with %d DMA frames\n",
dev->name, count);
}
}
#endif
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_RETVAL(handled);
} }
static void static int set_mac_address(struct net_device *dev, void *p)
count_rx_errors(int status, struct net_device *dev)
{ {
dev->stats.rx_errors++; int i;
if (status & RX_RUNT) struct sockaddr *addr = p;
dev->stats.rx_length_errors++;
if (status & RX_EXTRA_DATA) if (netif_running(dev))
dev->stats.rx_length_errors++; return -EBUSY;
if ((status & RX_CRC_ERROR) && !(status & (RX_EXTRA_DATA | RX_RUNT)))
/* per str 172 */ memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
dev->stats.rx_crc_errors++;
if (status & RX_DRIBBLE) cs89_dbg(0, debug, "%s: Setting MAC address to %pM\n",
dev->stats.rx_frame_errors++; 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;
} }
/* We have a good packet(s), get it/them out of the buffers. */ #ifdef CONFIG_NET_POLL_CONTROLLER
static void /*
net_rx(struct net_device *dev) * Polling receive - used by netconsole and other diagnostic tools
* to allow network i/o with interrupts disabled.
*/
static void net_poll_controller(struct net_device *dev)
{ {
disable_irq(dev->irq);
net_interrupt(dev->irq, dev);
enable_irq(dev->irq);
}
#endif
static const struct net_device_ops net_ops = {
.ndo_open = net_open,
.ndo_stop = net_close,
.ndo_tx_timeout = net_timeout,
.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,
#ifdef CONFIG_NET_POLL_CONTROLLER
.ndo_poll_controller = net_poll_controller,
#endif
.ndo_change_mtu = eth_change_mtu,
.ndo_validate_addr = eth_validate_addr,
};
static void __init reset_chip(struct net_device *dev)
{
#if !defined(CONFIG_MACH_MX31ADS)
#if !defined(CS89x0_NONISA_IRQ)
struct net_local *lp = netdev_priv(dev); struct net_local *lp = netdev_priv(dev);
struct sk_buff *skb; #endif /* CS89x0_NONISA_IRQ */
int status, length; int reset_start_time;
status = ioread16(lp->virt_addr + RX_FRAME_PORT); writereg(dev, PP_SelfCTL, readreg(dev, PP_SelfCTL) | POWER_ON_RESET);
length = ioread16(lp->virt_addr + RX_FRAME_PORT);
if ((status & RX_OK) == 0) { /* wait 30 ms */
count_rx_errors(status, dev); msleep(30);
return;
#if !defined(CS89x0_NONISA_IRQ)
if (lp->chip_type != CS8900) {
/* Hardware problem requires PNP registers to be reconfigured after a reset */
iowrite16(PP_CS8920_ISAINT, lp->virt_addr + ADD_PORT);
iowrite8(dev->irq, lp->virt_addr + DATA_PORT);
iowrite8(0, lp->virt_addr + DATA_PORT + 1);
iowrite16(PP_CS8920_ISAMemB, lp->virt_addr + ADD_PORT);
iowrite8((dev->mem_start >> 16) & 0xff,
lp->virt_addr + DATA_PORT);
iowrite8((dev->mem_start >> 8) & 0xff,
lp->virt_addr + DATA_PORT + 1);
} }
#endif /* CS89x0_NONISA_IRQ */
/* Malloc up new buffer. */ /* Wait until the chip is reset */
skb = netdev_alloc_skb(dev, length + 2); reset_start_time = jiffies;
if (skb == NULL) { while ((readreg(dev, PP_SelfST) & INIT_DONE) == 0 &&
#if 0 /* Again, this seems a cruel thing to do */ jiffies - reset_start_time < 2)
pr_warn("%s: Memory squeeze, dropping packet\n", dev->name); ;
#endif /* !CONFIG_MACH_MX31ADS */
}
/* This is the real probe routine.
* Linux has a history of friendly device probes on the ISA bus.
* A good device probes avoids doing writes, and
* verifies that the correct device exists and functions.
* Return 0 on success.
*/
static int __init
cs89x0_probe1(struct net_device *dev, void __iomem *ioaddr, int modular)
{
struct net_local *lp = netdev_priv(dev);
int i;
int tmp;
unsigned rev_type = 0;
int eeprom_buff[CHKSUM_LEN];
int retval;
/* Initialize the device structure. */
if (!modular) {
memset(lp, 0, sizeof(*lp));
spin_lock_init(&lp->lock);
#ifndef MODULE
#if ALLOW_DMA
if (g_cs89x0_dma) {
lp->use_dma = 1;
lp->dma = g_cs89x0_dma;
lp->dmasize = 16; /* Could make this an option... */
}
#endif #endif
dev->stats.rx_dropped++; lp->force = g_cs89x0_media__force;
return; #endif
}
pr_debug("PP_addr at %p[%x]: 0x%x\n",
ioaddr, ADD_PORT, ioread16(ioaddr + ADD_PORT));
iowrite16(PP_ChipID, ioaddr + ADD_PORT);
tmp = ioread16(ioaddr + DATA_PORT);
if (tmp != CHIP_EISA_ID_SIG) {
pr_debug("%s: incorrect signature at %p[%x]: 0x%x!="
CHIP_EISA_ID_SIG_STR "\n",
dev->name, ioaddr, DATA_PORT, tmp);
retval = -ENODEV;
goto out1;
}
lp->virt_addr = ioaddr;
/* 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;
pr_info_once("%s\n", version);
pr_info("%s: cs89%c0%s rev %c found at %p ",
dev->name,
lp->chip_type == CS8900 ? '0' : '2',
lp->chip_type == CS8920M ? "M" : "",
lp->chip_revision,
lp->virt_addr);
reset_chip(dev);
/* Here we read the current configuration of the chip.
* If there is no Extended EEPROM then the idea is to not disturb
* the chip configuration, it should have been correctly setup by
* automatic EEPROM read on reset. So, if the chip says it read
* the EEPROM the driver will always do *something* instead of
* complain that adapter_cnf is 0.
*/
if ((readreg(dev, PP_SelfST) & (EEPROM_OK | EEPROM_PRESENT)) ==
(EEPROM_OK | EEPROM_PRESENT)) {
/* Load the MAC. */
for (i = 0; i < ETH_ALEN / 2; i++) {
unsigned int Addr;
Addr = readreg(dev, PP_IA + i * 2);
dev->dev_addr[i * 2] = Addr & 0xFF;
dev->dev_addr[i * 2 + 1] = Addr >> 8;
}
/* Load the Adapter Configuration.
* Note: Barring any more specific information from some
* other source (ie EEPROM+Schematics), we would not know
* how to operate a 10Base2 interface on the AUI port.
* However, since we do read the status of HCB1 and use
* settings that always result in calls to control_dc_dc(dev,0)
* a BNC interface should work if the enable pin
* (dc/dc converter) is on HCB1.
* It will be called AUI however.
*/
lp->adapter_cnf = 0;
i = readreg(dev, PP_LineCTL);
/* Preserve the setting of the HCB1 pin. */
if ((i & (HCB1 | HCB1_ENBL)) == (HCB1 | HCB1_ENBL))
lp->adapter_cnf |= A_CNF_DC_DC_POLARITY;
/* Save the sqelch bit */
if ((i & LOW_RX_SQUELCH) == LOW_RX_SQUELCH)
lp->adapter_cnf |= A_CNF_EXTND_10B_2 | A_CNF_LOW_RX_SQUELCH;
/* Check if the card is in 10Base-t only mode */
if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == 0)
lp->adapter_cnf |= A_CNF_10B_T | A_CNF_MEDIA_10B_T;
/* Check if the card is in AUI only mode */
if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == AUI_ONLY)
lp->adapter_cnf |= A_CNF_AUI | A_CNF_MEDIA_AUI;
/* Check if the card is in Auto mode. */
if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == AUTO_AUI_10BASET)
lp->adapter_cnf |= A_CNF_AUI | A_CNF_10B_T |
A_CNF_MEDIA_AUI | A_CNF_MEDIA_10B_T | A_CNF_MEDIA_AUTO;
cs89_dbg(1, info, "%s: PP_LineCTL=0x%x, adapter_cnf=0x%x\n",
dev->name, i, lp->adapter_cnf);
/* IRQ. Other chips already probe, see below. */
if (lp->chip_type == CS8900)
lp->isa_config = readreg(dev, PP_CS8900_ISAINT) & INT_NO_MASK;
pr_cont("[Cirrus EEPROM] ");
}
pr_cont("\n");
/* First check to see if an EEPROM is attached. */
if ((readreg(dev, PP_SelfST) & EEPROM_PRESENT) == 0)
pr_warn("No EEPROM, relying on command line....\n");
else if (get_eeprom_data(dev, START_EEPROM_DATA, CHKSUM_LEN, eeprom_buff) < 0) {
pr_warn("EEPROM read failed, relying on command line\n");
} else if (get_eeprom_cksum(START_EEPROM_DATA, CHKSUM_LEN, eeprom_buff) < 0) {
/* Check if the chip was able to read its own configuration starting
at 0 in the EEPROM*/
if ((readreg(dev, PP_SelfST) & (EEPROM_OK | EEPROM_PRESENT)) !=
(EEPROM_OK | EEPROM_PRESENT))
pr_warn("Extended EEPROM checksum bad and no Cirrus EEPROM, relying on command line\n");
} else {
/* This reads an extended EEPROM that is not documented
* in the CS8900 datasheet.
*/
/* get transmission control word but keep the autonegotiation bits */
if (!lp->auto_neg_cnf)
lp->auto_neg_cnf = eeprom_buff[AUTO_NEG_CNF_OFFSET / 2];
/* Store adapter configuration */
if (!lp->adapter_cnf)
lp->adapter_cnf = eeprom_buff[ADAPTER_CNF_OFFSET / 2];
/* Store ISA configuration */
lp->isa_config = eeprom_buff[ISA_CNF_OFFSET / 2];
dev->mem_start = eeprom_buff[PACKET_PAGE_OFFSET / 2] << 8;
/* eeprom_buff has 32-bit ints, so we can't just memcpy it */
/* store the initial memory base address */
for (i = 0; i < ETH_ALEN / 2; i++) {
dev->dev_addr[i * 2] = eeprom_buff[i];
dev->dev_addr[i * 2 + 1] = eeprom_buff[i] >> 8;
}
cs89_dbg(1, debug, "%s: new adapter_cnf: 0x%x\n",
dev->name, lp->adapter_cnf);
}
/* allow them to force multiple transceivers. If they force multiple, autosense */
{
int count = 0;
if (lp->force & FORCE_RJ45) {
lp->adapter_cnf |= A_CNF_10B_T;
count++;
}
if (lp->force & FORCE_AUI) {
lp->adapter_cnf |= A_CNF_AUI;
count++;
}
if (lp->force & FORCE_BNC) {
lp->adapter_cnf |= A_CNF_10B_2;
count++;
}
if (count > 1)
lp->adapter_cnf |= A_CNF_MEDIA_AUTO;
else if (lp->force & FORCE_RJ45)
lp->adapter_cnf |= A_CNF_MEDIA_10B_T;
else if (lp->force & FORCE_AUI)
lp->adapter_cnf |= A_CNF_MEDIA_AUI;
else if (lp->force & FORCE_BNC)
lp->adapter_cnf |= A_CNF_MEDIA_10B_2;
} }
skb_reserve(skb, 2); /* longword align L3 header */
readwords(lp, RX_FRAME_PORT, skb_put(skb, length), length >> 1); cs89_dbg(1, debug, "%s: after force 0x%x, adapter_cnf=0x%x\n",
if (length & 1) dev->name, lp->force, lp->adapter_cnf);
skb->data[length-1] = ioread16(lp->virt_addr + RX_FRAME_PORT);
cs89_dbg(3, debug, "%s: received %d byte packet of type %x\n", /* FIXME: We don't let you set dc-dc polarity or low RX squelch from the command line: add it here */
dev->name, length,
(skb->data[ETH_ALEN + ETH_ALEN] << 8) |
skb->data[ETH_ALEN + ETH_ALEN + 1]);
skb->protocol = eth_type_trans(skb, dev); /* FIXME: We don't let you set the IMM bit from the command line: add it to lp->auto_neg_cnf here */
netif_rx(skb);
dev->stats.rx_packets++;
dev->stats.rx_bytes += length;
}
#if ALLOW_DMA /* FIXME: we don't set the Ethernet address on the command line. Use
static void release_dma_buff(struct net_local *lp) * ifconfig IFACE hw ether AABBCCDDEEFF
{ */
if (lp->dma_buff) {
free_pages((unsigned long)(lp->dma_buff),
get_order(lp->dmasize * 1024));
lp->dma_buff = NULL;
}
}
#endif
/* The inverse routine to net_open(). */ pr_info("media %s%s%s",
static int (lp->adapter_cnf & A_CNF_10B_T) ? "RJ-45," : "",
net_close(struct net_device *dev) (lp->adapter_cnf & A_CNF_AUI) ? "AUI," : "",
{ (lp->adapter_cnf & A_CNF_10B_2) ? "BNC," : "");
#if ALLOW_DMA
struct net_local *lp = netdev_priv(dev);
#endif
netif_stop_queue(dev); lp->irq_map = 0xffff;
writereg(dev, PP_RxCFG, 0); /* If this is a CS8900 then no pnp soft */
writereg(dev, PP_TxCFG, 0); if (lp->chip_type != CS8900 &&
writereg(dev, PP_BufCFG, 0); /* Check if the ISA IRQ has been set */
writereg(dev, PP_BusCTL, 0); (i = readreg(dev, PP_CS8920_ISAINT) & 0xff,
(i != 0 && i < CS8920_NO_INTS))) {
if (!dev->irq)
dev->irq = i;
} else {
i = lp->isa_config & INT_NO_MASK;
#ifndef CONFIG_CS89x0_PLATFORM
if (lp->chip_type == CS8900) {
#ifdef CS89x0_NONISA_IRQ
i = cs8900_irq_map[0];
#else
/* Translate the IRQ using the IRQ mapping table. */
if (i >= ARRAY_SIZE(cs8900_irq_map))
pr_err("invalid ISA interrupt number %d\n", i);
else
i = cs8900_irq_map[i];
free_irq(dev->irq, dev); lp->irq_map = CS8900_IRQ_MAP; /* fixed IRQ map for CS8900 */
} else {
int irq_map_buff[IRQ_MAP_LEN/2];
#if ALLOW_DMA if (get_eeprom_data(dev, IRQ_MAP_EEPROM_DATA,
if (lp->use_dma && lp->dma) { IRQ_MAP_LEN / 2,
free_dma(dev->dma); irq_map_buff) >= 0) {
release_dma_buff(lp); if ((irq_map_buff[0] & 0xff) == PNP_IRQ_FRMT)
lp->irq_map = ((irq_map_buff[0] >> 8) |
(irq_map_buff[1] << 8));
}
#endif
}
#endif
if (!dev->irq)
dev->irq = i;
} }
pr_cont(" IRQ %d", dev->irq);
#if ALLOW_DMA
if (lp->use_dma) {
get_dma_channel(dev);
pr_cont(", DMA %d", dev->dma);
} else
#endif #endif
pr_cont(", programmed I/O");
/* Update the statistics here. */ /* print the ethernet address. */
pr_cont(", MAC %pM\n", dev->dev_addr);
dev->netdev_ops = &net_ops;
dev->watchdog_timeo = HZ;
cs89_dbg(0, info, "cs89x0_probe1() successful\n");
retval = register_netdev(dev);
if (retval)
goto out2;
return 0; return 0;
out2:
iowrite16(PP_ChipID, lp->virt_addr + ADD_PORT);
out1:
return retval;
} }
/* Get the current statistics. #ifndef CONFIG_CS89x0_PLATFORM
* This may be called with the card open or closed. /*
* This function converts the I/O port addres used by the cs89x0_probe() and
* init_module() functions to the I/O memory address used by the
* cs89x0_probe1() function.
*/ */
static struct net_device_stats * static int __init
net_get_stats(struct net_device *dev) cs89x0_ioport_probe(struct net_device *dev, unsigned long ioport, int modular)
{ {
struct net_local *lp = netdev_priv(dev); struct net_local *lp = netdev_priv(dev);
unsigned long flags; int ret;
void __iomem *io_mem;
spin_lock_irqsave(&lp->lock, 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);
spin_unlock_irqrestore(&lp->lock, flags);
return &dev->stats; if (!lp)
} return -ENOMEM;
static void set_multicast_list(struct net_device *dev) dev->base_addr = ioport;
{
struct net_local *lp = netdev_priv(dev);
unsigned long flags;
spin_lock_irqsave(&lp->lock, flags); if (!request_region(ioport, NETCARD_IO_EXTENT, DRV_NAME)) {
if (dev->flags & IFF_PROMISC) ret = -EBUSY;
lp->rx_mode = RX_ALL_ACCEPT; goto out;
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); io_mem = ioport_map(ioport & ~3, NETCARD_IO_EXTENT);
if (!io_mem) {
ret = -ENOMEM;
goto release;
}
/* in promiscuous mode, we accept errored packets, /* if they give us an odd I/O address, then do ONE write to
* so we have to enable interrupts on them also * the address port, to get it back to address zero, where we
* expect to find the EISA signature word. An IO with a base of 0x3
* will skip the test for the ADD_PORT.
*/ */
writereg(dev, PP_RxCFG, if (ioport & 1) {
(lp->curr_rx_cfg | cs89_dbg(1, info, "%s: odd ioaddr 0x%lx\n", dev->name, ioport);
(lp->rx_mode == RX_ALL_ACCEPT) if ((ioport & 2) != 2) {
? (RX_CRC_ERROR_ENBL | RX_RUNT_ENBL | RX_EXTRA_DATA_ENBL) if ((ioread16(io_mem + ADD_PORT) & ADD_MASK) !=
: 0)); ADD_SIG) {
spin_unlock_irqrestore(&lp->lock, flags); pr_err("%s: bad signature 0x%x\n",
dev->name, ioread16(io_mem + ADD_PORT));
ret = -ENODEV;
goto unmap;
}
}
}
ret = cs89x0_probe1(dev, io_mem, modular);
if (!ret)
goto out;
unmap:
ioport_unmap(io_mem);
release:
release_region(ioport, NETCARD_IO_EXTENT);
out:
return ret;
} }
static int set_mac_address(struct net_device *dev, void *p) #ifndef MODULE
{ /* Check for a network adaptor of this type, and return '0' iff one exists.
int i; * If dev->base_addr == 0, probe all likely locations.
struct sockaddr *addr = p; * If dev->base_addr == 1, always return failure.
* If dev->base_addr == 2, allocate space for the device and return success
* (detachable devices only).
* Return 0 on success.
*/
if (netif_running(dev)) struct net_device * __init cs89x0_probe(int unit)
return -EBUSY; {
struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
unsigned *port;
int err = 0;
int irq;
int io;
memcpy(dev->dev_addr, addr->sa_data, dev->addr_len); if (!dev)
return ERR_PTR(-ENODEV);
cs89_dbg(0, debug, "%s: Setting MAC address to %pM\n", sprintf(dev->name, "eth%d", unit);
dev->name, dev->dev_addr); netdev_boot_setup_check(dev);
io = dev->base_addr;
irq = dev->irq;
/* set the Ethernet address */ cs89_dbg(0, info, "cs89x0_probe(0x%x)\n", io);
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; if (io > 0x1ff) { /* Check a single specified location. */
err = cs89x0_ioport_probe(dev, io, 0);
} else if (io != 0) { /* Don't probe at all. */
err = -ENXIO;
} else {
for (port = netcard_portlist; *port; port++) {
if (cs89x0_ioport_probe(dev, *port, 0) == 0)
break;
dev->irq = irq;
}
if (!*port)
err = -ENODEV;
}
if (err)
goto out;
return dev;
out:
free_netdev(dev);
pr_warn("no cs8900 or cs8920 detected. Be sure to disable PnP with SETUP\n");
return ERR_PTR(err);
} }
#endif
#endif
#if defined(MODULE) && !defined(CONFIG_CS89x0_PLATFORM) #if defined(MODULE) && !defined(CONFIG_CS89x0_PLATFORM)
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7