Skip to content

R
raspberrypi-kernel

openeuler / raspberrypi-kernel

通知 14
Star 1
Fork 0
R
raspberrypi-kernel
提交 6fba180e 编写于 作者: J Joe Perches 提交者： David S. Miller
浏览文件
操作

cirrus: cs89x0: Remove function prototypes and reorder declarations 

Move blocks of code around to avoid function prototypes.
Signed-off-by: NJoe Perches <joe@perches.com>
Signed-off-by: NDavid S. Miller <davem@davemloft.net>
上级 808e9a77
显示空白变更内容
内联 并排
Showing with 947 addition and 972 deletion
drivers/net/ethernet/cirrus/cs89x0.c
浏览文件 @ 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; if (lp->use_dma) {
goto out1; 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");
} }
}
}
lp->virt_addr = ioaddr; static int
dma_bufcfg(struct net_device *dev)
{
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;
}
/* get the chip type */ static int
rev_type = readreg(dev, PRODUCT_ID_ADD); dma_busctl(struct net_device *dev)
lp->chip_type = rev_type & ~REVISON_BITS; {
lp->chip_revision = ((rev_type & REVISON_BITS) >> 8) + 'A'; int retval = 0;
struct net_local *lp = netdev_priv(dev);
if (lp->use_dma) {
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;
}
/* Check the chip type and revision in order to set the correct send command static void
CS8920 revision C and CS8900 revision F can use the faster send. */ dma_rx(struct net_device *dev)
lp->send_cmd = TX_AFTER_381; {
if (lp->chip_type == CS8900 && lp->chip_revision >= 'F') struct net_local *lp = netdev_priv(dev);
lp->send_cmd = TX_NOW; struct sk_buff *skb;
if (lp->chip_type != CS8900 && lp->chip_revision >= 'C') int status, length;
lp->send_cmd = TX_NOW; unsigned char *bp = lp->rx_dma_ptr;
pr_info_once("%s\n", version); status = bp[0] + (bp[1] << 8);
length = bp[2] + (bp[3] << 8);
bp += 4;
pr_info("%s: cs89%c0%s rev %c found at %p ", cs89_dbg(5, debug, "%s: receiving DMA packet at %lx, status %x, length %x\n",
dev->name, dev->name, (unsigned long)bp, status, length);
lp->chip_type == CS8900 ? '0' : '2',
lp->chip_type == CS8920M ? "M" : "",
lp->chip_revision,
lp->virt_addr);
reset_chip(dev); if ((status & RX_OK) == 0) {
count_rx_errors(status, dev);
goto skip_this_frame;
}
/* Here we read the current configuration of the chip. /* Malloc up new buffer. */
* If there is no Extended EEPROM then the idea is to not disturb skb = netdev_alloc_skb(dev, length + 2);
* the chip configuration, it should have been correctly setup by if (skb == NULL) {
* automatic EEPROM read on reset. So, if the chip says it read /* I don't think we want to do this to a stressed system */
* the EEPROM the driver will always do *something* instead of cs89_dbg(0, err, "%s: Memory squeeze, dropping packet\n",
* complain that adapter_cnf is 0. dev->name);
*/ dev->stats.rx_dropped++;
if ((readreg(dev, PP_SelfST) & (EEPROM_OK | EEPROM_PRESENT)) == /* AKPM: advance bp to the next frame */
(EEPROM_OK | EEPROM_PRESENT)) { skip_this_frame:
/* Load the MAC. */ bp += (length + 3) & ~3;
for (i = 0; i < ETH_ALEN / 2; i++) { if (bp >= lp->end_dma_buff)
unsigned int Addr; bp -= lp->dmasize * 1024;
Addr = readreg(dev, PP_IA + i * 2); lp->rx_dma_ptr = bp;
dev->dev_addr[i * 2] = Addr & 0xFF; return;
dev->dev_addr[i * 2 + 1] = Addr >> 8;
} }
skb_reserve(skb, 2); /* longword align L3 header */
/* Load the Adapter Configuration. if (bp + length > lp->end_dma_buff) {
* Note: Barring any more specific information from some int semi_cnt = lp->end_dma_buff - bp;
* other source (ie EEPROM+Schematics), we would not know memcpy(skb_put(skb, semi_cnt), bp, semi_cnt);
* how to operate a 10Base2 interface on the AUI port. memcpy(skb_put(skb, length - semi_cnt), lp->dma_buff,
* However, since we do read the status of HCB1 and use length - semi_cnt);
* 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 { } 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," : "");
lp->irq_map = 0xffff;
/* 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 else
i = cs8900_irq_map[i]; selfcontrol &= ~HCB1;
writereg(dev, PP_SelfCTL, selfcontrol);
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) cs89_dbg(1, debug, "%s: Attempting TP\n", dev->name);
return -ENOMEM;
dev->base_addr = ioport; /* If connected to another full duplex capable 10-Base-T card
* the link pulses seem to be lost when the auto detect bit in
if (!request_region(ioport, NETCARD_IO_EXTENT, DRV_NAME)) { * the LineCTL is set. To overcome this the auto detect bit will
ret = -EBUSY; * be cleared whilst testing the 10-Base-T interface. This would
goto out; * not be necessary for the sparrow chip but is simpler to do it
} * anyway.
io_mem = ioport_map(ioport & ~3, NETCARD_IO_EXTENT);
if (!io_mem) {
ret = -ENOMEM;
goto release;
}
/* if they give us an odd I/O address, then do ONE write to
* 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.
*/ */
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 /* Delay for the hardware to work out if the TP cable is present
/* Check for a network adaptor of this type, and return '0' iff one exists. * - 150ms
* 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.
*/ */
for (timenow = jiffies; jiffies - timenow < 15;)
;
if ((readreg(dev, PP_LineST) & LINK_OK) == 0)
return DETECTED_NONE;
struct net_device * __init cs89x0_probe(int unit) if (lp->chip_type == CS8900) {
{ switch (lp->force & 0xf0) {
struct net_device *dev = alloc_etherdev(sizeof(struct net_local)); #if 0
unsigned *port; case FORCE_AUTO:
int err = 0; pr_info("%s: cs8900 doesn't autonegotiate\n",
int irq; dev->name);
int io; return DETECTED_NONE;
#endif
if (!dev) /* CS8900 doesn't support AUTO, change to HALF*/
return ERR_PTR(-ENODEV); case FORCE_AUTO:
lp->force &= ~FORCE_AUTO;
sprintf(dev->name, "eth%d", unit); lp->force |= FORCE_HALF;
netdev_boot_setup_check(dev); break;
io = dev->base_addr; case FORCE_HALF:
irq = dev->irq; break;
case FORCE_FULL:
cs89_dbg(0, info, "cs89x0_probe(0x%x)\n", io); writereg(dev, PP_TestCTL,
readreg(dev, PP_TestCTL) | FDX_8900);
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; break;
dev->irq = irq;
}
if (!*port)
err = -ENODEV;
} }
if (err) fdx = readreg(dev, PP_TestCTL) & FDX_8900;
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
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 { } else {
if ((lp->isa_config & ANY_ISA_DMA) == 0) switch (lp->force & 0xf0) {
return; case FORCE_AUTO:
dev->dma = lp->isa_config & DMA_NO_MASK; lp->auto_neg_cnf = AUTO_NEG_ENABLE;
if (lp->chip_type == CS8900) break;
dev->dma += 5; case FORCE_HALF:
if (dev->dma < 5 || dev->dma > 7) { lp->auto_neg_cnf = 0;
lp->isa_config &= ~ANY_ISA_DMA; break;
return; case FORCE_FULL:
} lp->auto_neg_cnf = RE_NEG_NOW | ALLOW_FDX;
break;
} }
}
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
writereg(dev, PP_CS8920_ISADMA, dma);
}
static void writereg(dev, PP_AutoNegCTL, lp->auto_neg_cnf & AUTO_NEG_MASK);
set_dma_cfg(struct net_device *dev)
{
struct net_local *lp = netdev_priv(dev);
if (lp->use_dma) { if ((lp->auto_neg_cnf & AUTO_NEG_BITS) == AUTO_NEG_ENABLE) {
if ((lp->isa_config & ANY_ISA_DMA) == 0) { pr_info("%s: negotiating duplex...\n", dev->name);
cs89_dbg(3, err, "set_dma_cfg(): no DMA\n"); while (readreg(dev, PP_AutoNegST) & AUTO_NEG_BUSY) {
return; if (jiffies - timenow > 4000) {
pr_err("**** Full / half duplex auto-negotiation timed out ****\n");
break;
}
} }
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");
} }
fdx = readreg(dev, PP_AutoNegST) & FDX_ACTIVE;
} }
if (fdx)
return DETECTED_RJ45F;
else
return DETECTED_RJ45H;
} }
static int static int
dma_bufcfg(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)
return (lp->isa_config & ANY_ISA_DMA) ? RX_DMA_ENBL : 0; 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 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++;
return;
}
skb_reserve(skb, 2); /* longword align L3 header */
/* AKPM: advance bp to the next frame */ readwords(lp, RX_FRAME_PORT, skb_put(skb, length), length >> 1);
skip_this_frame: if (length & 1)
bp += (length + 3) & ~3; skb->data[length-1] = ioread16(lp->virt_addr + RX_FRAME_PORT);
if (bp >= lp->end_dma_buff)
bp -= lp->dmasize * 1024;
lp->rx_dma_ptr = bp;
return;
}
skb_reserve(skb, 2); /* longword align L3 header */
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 {
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,289 +754,148 @@ dma_rx(struct net_device *dev) ...@@ -915,289 +754,148 @@ 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++;
} }
#endif /* CS89x0_NONISA_IRQ */ break;
case ISQ_BUFFER_EVENT:
/* Wait until the chip is reset */ if (status & READY_FOR_TX) {
reset_start_time = jiffies; /* we tried to transmit a packet earlier,
while ((readreg(dev, PP_SelfST) & INIT_DONE) == 0 && * but inexplicably ran out of buffers.
jiffies - reset_start_time < 2) * That shouldn't happen since we only ever
; * load one packet. Shrug. Do the right
#endif /* !CONFIG_MACH_MX31ADS */ * thing anyway.
} */
netif_wake_queue(dev); /* Inform upper layers. */
}
static void if (status & TX_UNDERRUN) {
control_dc_dc(struct net_device *dev, int on_not_off) cs89_dbg(0, err, "%s: transmit underrun\n",
{ dev->name);
struct net_local *lp = netdev_priv(dev); lp->send_underrun++;
unsigned int selfcontrol; if (lp->send_underrun == 3)
int timenow = jiffies; lp->send_cmd = TX_AFTER_381;
/* control the DC to DC convertor in the SelfControl register. else if (lp->send_underrun == 6)
* Note: This is hooked up to a general purpose pin, might not lp->send_cmd = TX_AFTER_ALL;
* always be a DC to DC convertor. /* 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);
}
selfcontrol = HCB1_ENBL; /* Enable the HCB1 bit as an output */ /* Open/initialize the board. This is called (in the current kernel)
if (((lp->adapter_cnf & A_CNF_DC_DC_POLARITY) != 0) ^ on_not_off) sometime after booting when the 'ifconfig' program is run.
selfcontrol |= HCB1;
else
selfcontrol &= ~HCB1;
writereg(dev, PP_SelfCTL, selfcontrol);
/* Wait for the DC/DC converter to power up - 500ms */ This routine should set everything up anew at each open, even
while (jiffies - timenow < HZ) registers that "should" only need to be set once at boot, so that
; there is non-reboot way to recover if something goes wrong.
} */
#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 #endif
/* CS8900 doesn't support AUTO, change to HALF*/ /* And 2.3.47 had this: */
case FORCE_AUTO: writereg(dev, PP_BusCTL, ENABLE_IRQ | MEMORY_ON);
lp->force &= ~FORCE_AUTO;
lp->force |= FORCE_HALF; for (i = 2; i < CS8920_NO_INTS; i++) {
break; if ((1 << i) & lp->irq_map) {
case FORCE_HALF: if (request_irq(i, net_interrupt, 0, dev->name,
break; dev) == 0) {
case FORCE_FULL: dev->irq = i;
writereg(dev, PP_TestCTL, write_irq(dev, lp->chip_type, i);
readreg(dev, PP_TestCTL) | FDX_8900); /* writereg(dev, PP_BufCFG, GENERATE_SW_INTERRUPT); */
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
/* And 2.3.47 had this: */
writereg(dev, PP_BusCTL, ENABLE_IRQ | MEMORY_ON);
for (i = 2; i < CS8920_NO_INTS; i++) {
if ((1 << i) & lp->irq_map) {
if (request_irq(i, net_interrupt, 0, dev->name,
dev) == 0) {
dev->irq = i;
write_irq(dev, lp->chip_type, i);
/* writereg(dev, PP_BufCFG, GENERATE_SW_INTERRUPT); */
break; break;
} }
} }
...@@ -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. {
struct net_local *lp = netdev_priv(dev);
unsigned long flags;
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;
static irqreturn_t net_interrupt(int irq, void *dev_id) 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));
spin_unlock_irqrestore(&lp->lock, flags);
}
static int set_mac_address(struct net_device *dev, void *p)
{ {
struct net_device *dev = dev_id; int i;
struct net_local *lp; struct sockaddr *addr = p;
int status;
int handled = 0;
lp = netdev_priv(dev); if (netif_running(dev))
return -EBUSY;
/* we MUST read all the events out of the ISQ, otherwise we'll never memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
* get interrupted again. As a consequence, we can't have any limit
* on the number of times we loop in the interrupt handler. The cs89_dbg(0, debug, "%s: Setting MAC address to %pM\n",
* hardware guarantees that eventually we'll run out of events. Of dev->name, dev->dev_addr);
* course, if you're on a slow machine, and packets are arriving
* faster than you can read them off, you're screwed. Hasta la /* set the Ethernet address */
* vista, baby! 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 CONFIG_NET_POLL_CONTROLLER
/*
* Polling receive - used by netconsole and other diagnostic tools
* to allow network i/o with interrupts disabled.
*/ */
while ((status = ioread16(lp->virt_addr + ISQ_PORT))) { static void net_poll_controller(struct net_device *dev)
cs89_dbg(4, debug, "%s: event=%04x\n", dev->name, status); {
handled = 1; disable_irq(dev->irq);
switch (status & ISQ_EVENT_MASK) { net_interrupt(dev->irq, dev);
case ISQ_RECEIVER_EVENT: enable_irq(dev->irq);
/* Got a packet(s). */ }
net_rx(dev); #endif
break;
case ISQ_TRANSMITTER_EVENT: static const struct net_device_ops net_ops = {
dev->stats.tx_packets++; .ndo_open = net_open,
netif_wake_queue(dev); /* Inform upper layers. */ .ndo_stop = net_close,
if ((status & (TX_OK | .ndo_tx_timeout = net_timeout,
TX_LOST_CRS | .ndo_start_xmit = net_send_packet,
TX_SQE_ERROR | .ndo_get_stats = net_get_stats,
TX_LATE_COL | .ndo_set_rx_mode = set_multicast_list,
TX_16_COL)) != TX_OK) { .ndo_set_mac_address = set_mac_address,
if ((status & TX_OK) == 0) #ifdef CONFIG_NET_POLL_CONTROLLER
dev->stats.tx_errors++; .ndo_poll_controller = net_poll_controller,
if (status & TX_LOST_CRS) #endif
dev->stats.tx_carrier_errors++; .ndo_change_mtu = eth_change_mtu,
if (status & TX_SQE_ERROR) .ndo_validate_addr = eth_validate_addr,
dev->stats.tx_heartbeat_errors++; };
if (status & TX_LATE_COL)
dev->stats.tx_window_errors++; static void __init reset_chip(struct net_device *dev)
if (status & TX_16_COL) {
dev->stats.tx_aborted_errors++; #if !defined(CONFIG_MACH_MX31ADS)
#if !defined(CS89x0_NONISA_IRQ)
struct net_local *lp = netdev_priv(dev);
#endif /* CS89x0_NONISA_IRQ */
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)
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);
} }
break; #endif /* CS89x0_NONISA_IRQ */
case ISQ_BUFFER_EVENT:
if (status & READY_FOR_TX) { /* Wait until the chip is reset */
/* we tried to transmit a packet earlier, reset_start_time = jiffies;
* but inexplicably ran out of buffers. while ((readreg(dev, PP_SelfST) & INIT_DONE) == 0 &&
* That shouldn't happen since we only ever jiffies - reset_start_time < 2)
* load one packet. Shrug. Do the right ;
* thing anyway. #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.
*/ */
netif_wake_queue(dev); /* Inform upper layers. */ 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... */
} }
if (status & TX_UNDERRUN) { #endif
cs89_dbg(0, err, "%s: transmit underrun\n", lp->force = g_cs89x0_media__force;
dev->name); #endif
lp->send_underrun++; }
if (lp->send_underrun == 3)
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; lp->send_cmd = TX_AFTER_381;
else if (lp->send_underrun == 6) if (lp->chip_type == CS8900 && lp->chip_revision >= 'F')
lp->send_cmd = TX_AFTER_ALL; lp->send_cmd = TX_NOW;
/* transmit cycle is done, although if (lp->chip_type != CS8900 && lp->chip_revision >= 'C')
* frame wasn't transmitted - this lp->send_cmd = TX_NOW;
* avoids having to wait for the upper
* layers to timeout on us, in the pr_info_once("%s\n", version);
* event of a tx underrun
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.
*/ */
netif_wake_queue(dev); /* Inform upper layers. */
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;
} }
#if ALLOW_DMA
if (lp->use_dma && (status & RX_DMA)) { /* Load the Adapter Configuration.
int count = readreg(dev, PP_DmaFrameCnt); * Note: Barring any more specific information from some
while (count) { * other source (ie EEPROM+Schematics), we would not know
cs89_dbg(5, debug, * how to operate a 10Base2 interface on the AUI port.
"%s: receiving %d DMA frames\n", * However, since we do read the status of HCB1 and use
dev->name, count); * settings that always result in calls to control_dc_dc(dev,0)
if (count > 1) * a BNC interface should work if the enable pin
cs89_dbg(2, debug, * (dc/dc converter) is on HCB1.
"%s: receiving %d DMA frames\n", * It will be called AUI however.
dev->name, count); */
dma_rx(dev);
if (--count == 0) lp->adapter_cnf = 0;
count = readreg(dev, PP_DmaFrameCnt); i = readreg(dev, PP_LineCTL);
if (count > 0) /* Preserve the setting of the HCB1 pin. */
cs89_dbg(2, debug, if ((i & (HCB1 | HCB1_ENBL)) == (HCB1 | HCB1_ENBL))
"%s: continuing with %d DMA frames\n", lp->adapter_cnf |= A_CNF_DC_DC_POLARITY;
dev->name, count); /* 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;
} }
#endif cs89_dbg(1, debug, "%s: new adapter_cnf: 0x%x\n",
break; dev->name, lp->adapter_cnf);
case ISQ_RX_MISS_EVENT: }
dev->stats.rx_missed_errors += (status >> 6);
break; /* allow them to force multiple transceivers. If they force multiple, autosense */
case ISQ_TX_COL_EVENT: {
dev->stats.collisions += (status >> 6); int count = 0;
break; 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;
} }
return IRQ_RETVAL(handled);
}
static void cs89_dbg(1, debug, "%s: after force 0x%x, adapter_cnf=0x%x\n",
count_rx_errors(int status, struct net_device *dev) dev->name, lp->force, lp->adapter_cnf);
{
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++;
}
/* We have a good packet(s), get it/them out of the buffers. */ /* FIXME: We don't let you set dc-dc polarity or low RX squelch from the command line: add it here */
static void
net_rx(struct net_device *dev)
{
struct net_local *lp = netdev_priv(dev);
struct sk_buff *skb;
int status, length;
status = ioread16(lp->virt_addr + RX_FRAME_PORT); /* FIXME: We don't let you set the IMM bit from the command line: add it to lp->auto_neg_cnf here */
length = ioread16(lp->virt_addr + RX_FRAME_PORT);
if ((status & RX_OK) == 0) { /* FIXME: we don't set the Ethernet address on the command line. Use
count_rx_errors(status, dev); * ifconfig IFACE hw ether AABBCCDDEEFF
return; */
}
/* Malloc up new buffer. */ pr_info("media %s%s%s",
skb = netdev_alloc_skb(dev, length + 2); (lp->adapter_cnf & A_CNF_10B_T) ? "RJ-45," : "",
if (skb == NULL) { (lp->adapter_cnf & A_CNF_AUI) ? "AUI," : "",
#if 0 /* Again, this seems a cruel thing to do */ (lp->adapter_cnf & A_CNF_10B_2) ? "BNC," : "");
pr_warn("%s: Memory squeeze, dropping packet\n", dev->name);
#endif
dev->stats.rx_dropped++;
return;
}
skb_reserve(skb, 2); /* longword align L3 header */
readwords(lp, RX_FRAME_PORT, skb_put(skb, length), length >> 1); lp->irq_map = 0xffff;
if (length & 1)
skb->data[length-1] = ioread16(lp->virt_addr + RX_FRAME_PORT);
cs89_dbg(3, debug, "%s: received %d byte packet of type %x\n", /* If this is a CS8900 then no pnp soft */
dev->name, length, if (lp->chip_type != CS8900 &&
(skb->data[ETH_ALEN + ETH_ALEN] << 8) | /* Check if the ISA IRQ has been set */
skb->data[ETH_ALEN + ETH_ALEN + 1]); (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];
skb->protocol = eth_type_trans(skb, dev); lp->irq_map = CS8900_IRQ_MAP; /* fixed IRQ map for CS8900 */
netif_rx(skb); } else {
dev->stats.rx_packets++; int irq_map_buff[IRQ_MAP_LEN/2];
dev->stats.rx_bytes += length;
}
#if ALLOW_DMA if (get_eeprom_data(dev, IRQ_MAP_EEPROM_DATA,
static void release_dma_buff(struct net_local *lp) IRQ_MAP_LEN / 2,
{ irq_map_buff) >= 0) {
if (lp->dma_buff) { if ((irq_map_buff[0] & 0xff) == PNP_IRQ_FRMT)
free_pages((unsigned long)(lp->dma_buff), lp->irq_map = ((irq_map_buff[0] >> 8) |
get_order(lp->dmasize * 1024)); (irq_map_buff[1] << 8));
lp->dma_buff = NULL; }
#endif
} }
}
#endif #endif
if (!dev->irq)
dev->irq = i;
}
pr_cont(" IRQ %d", dev->irq);
/* The inverse routine to net_open(). */
static int
net_close(struct net_device *dev)
{
#if ALLOW_DMA #if ALLOW_DMA
struct net_local *lp = netdev_priv(dev); if (lp->use_dma) {
get_dma_channel(dev);
pr_cont(", DMA %d", dev->dma);
} else
#endif #endif
pr_cont(", programmed I/O");
netif_stop_queue(dev); /* print the ethernet address. */
pr_cont(", MAC %pM\n", dev->dev_addr);
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); dev->netdev_ops = &net_ops;
dev->watchdog_timeo = HZ;
#if ALLOW_DMA cs89_dbg(0, info, "cs89x0_probe1() successful\n");
if (lp->use_dma && lp->dma) {
free_dma(dev->dma);
release_dma_buff(lp);
}
#endif
/* Update the statistics here. */ 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); if (!lp)
/* Update the statistics from the device registers. */ return -ENOMEM;
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; dev->base_addr = ioport;
}
static void set_multicast_list(struct net_device *dev) if (!request_region(ioport, NETCARD_IO_EXTENT, DRV_NAME)) {
{ ret = -EBUSY;
struct net_local *lp = netdev_priv(dev); goto out;
unsigned long flags; }
spin_lock_irqsave(&lp->lock, flags); io_mem = ioport_map(ioport & ~3, NETCARD_IO_EXTENT);
if (dev->flags & IFF_PROMISC) if (!io_mem) {
lp->rx_mode = RX_ALL_ACCEPT; ret = -ENOMEM;
else if ((dev->flags & IFF_ALLMULTI) || !netdev_mc_empty(dev)) goto release;
/* The multicast-accept list is initialized to accept-all, }
* and we rely on higher-level filtering for now.
/* if they give us an odd I/O address, then do ONE write to
* 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.
*/ */
lp->rx_mode = RX_MULTCAST_ACCEPT; if (ioport & 1) {
else cs89_dbg(1, info, "%s: odd ioaddr 0x%lx\n", dev->name, ioport);
lp->rx_mode = 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;
}
}
}
writereg(dev, PP_RxCTL, DEF_RX_ACCEPT | lp->rx_mode); 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;
}
/* in promiscuous mode, we accept errored packets, #ifndef MODULE
* so we have to enable interrupts on them also /* 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.
*/ */
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));
spin_unlock_irqrestore(&lp->lock, flags);
}
static int set_mac_address(struct net_device *dev, void *p) struct net_device * __init cs89x0_probe(int unit)
{ {
int i; struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
struct sockaddr *addr = p; unsigned *port;
int err = 0;
if (netif_running(dev)) int irq;
return -EBUSY; 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% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或