OpenWrt
/
ACwifidude
mirror of https://github.com/ACwifidude/openwrt.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

switch driver cleanup, 2nd phase 

SVN-Revision: 9330
This commit is contained in:
Gabor Juhos 2007-10-16 08:15:18 +00:00
parent e9d7dc5803
commit 63c27908bf
1 changed files with 333 additions and 148 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

479
target/linux/adm5120/files/drivers/net/adm5120sw.c
View File

@ -45,7 +45,7 @@ MODULE_LICENSE("GPL");
/* ------------------------------------------------------------------------ */ /* ------------------------------------------------------------------------ */
#if 1 /*def ADM5120_SWITCH_DEBUG*/ #if 0 /*def ADM5120_SWITCH_DEBUG*/
#define SW_DBG(f, a...) printk(KERN_DEBUG "%s: " f, DRV_NAME , ## a) #define SW_DBG(f, a...) printk(KERN_DEBUG "%s: " f, DRV_NAME , ## a)
#else #else
#define SW_DBG(f, a...) do {} while (0) #define SW_DBG(f, a...) do {} while (0)
@ -63,6 +63,11 @@ MODULE_LICENSE("GPL");
#define TX_QUEUE_LEN 28 /* Limit ring entries actually used. */ #define TX_QUEUE_LEN 28 /* Limit ring entries actually used. */
#define TX_TIMEOUT HZ*400 #define TX_TIMEOUT HZ*400
#define RX_DESCS_SIZE (RX_RING_SIZE * sizeof(struct dma_desc *))
#define RX_SKBS_SIZE (RX_RING_SIZE * sizeof(struct sk_buff *))
#define TX_DESCS_SIZE (TX_RING_SIZE * sizeof(struct dma_desc *))
#define TX_SKBS_SIZE (TX_RING_SIZE * sizeof(struct sk_buff *))
#define SKB_ALLOC_LEN (RX_MAX_PKTLEN + 32) #define SKB_ALLOC_LEN (RX_MAX_PKTLEN + 32)
#define SKB_RESERVE_LEN (NET_IP_ALIGN + NET_SKB_PAD) #define SKB_RESERVE_LEN (NET_IP_ALIGN + NET_SKB_PAD)
@ -140,19 +145,14 @@ static struct net_device *adm5120_devs[SWITCH_NUM_PORTS];
/* Lookup table port -> device */ /* Lookup table port -> device */
static struct net_device *adm5120_port[SWITCH_NUM_PORTS]; static struct net_device *adm5120_port[SWITCH_NUM_PORTS];
static struct dma_desc txh_descs_v[TX_RING_SIZE] __attribute__((aligned(16)));
static struct dma_desc txl_descs_v[TX_RING_SIZE] __attribute__((aligned(16)));
static struct dma_desc rxh_descs_v[RX_RING_SIZE] __attribute__((aligned(16)));
static struct dma_desc rxl_descs_v[RX_RING_SIZE] __attribute__((aligned(16)));
static struct dma_desc *txh_descs;
static struct dma_desc *txl_descs; static struct dma_desc *txl_descs;
static struct dma_desc *rxh_descs;
static struct dma_desc *rxl_descs; static struct dma_desc *rxl_descs;
static struct sk_buff *rxl_skbuff[RX_RING_SIZE]; static dma_addr_t txl_descs_dma;
static struct sk_buff *rxh_skbuff[RX_RING_SIZE]; static dma_addr_t rxl_descs_dma;
static struct sk_buff *txl_skbuff[TX_RING_SIZE];
static struct sk_buff *txh_skbuff[TX_RING_SIZE]; static struct sk_buff **txl_skbuff;
static struct sk_buff **rxl_skbuff;
static unsigned int cur_rxl, dirty_rxl; /* producer/consumer ring indices */ static unsigned int cur_rxl, dirty_rxl; /* producer/consumer ring indices */
static unsigned int cur_txl, dirty_txl; static unsigned int cur_txl, dirty_txl;
@ -160,8 +160,10 @@ static unsigned int cur_txl, dirty_txl;
static unsigned int sw_used; static unsigned int sw_used;
static spinlock_t sw_lock = SPIN_LOCK_UNLOCKED; static spinlock_t sw_lock = SPIN_LOCK_UNLOCKED;
static spinlock_t poll_lock = SPIN_LOCK_UNLOCKED;
static struct net_device sw_dev; static struct net_device sw_dev;
static struct net_device *poll_dev;
/* ------------------------------------------------------------------------ */ /* ------------------------------------------------------------------------ */
@ -175,7 +177,7 @@ static inline void sw_write_reg(u32 reg, u32 val)
__raw_writel(val, (void __iomem *)KSEG1ADDR(ADM5120_SWITCH_BASE)+reg); __raw_writel(val, (void __iomem *)KSEG1ADDR(ADM5120_SWITCH_BASE)+reg);
} }
static inline void sw_int_disable(u32 mask) static inline void sw_int_mask(u32 mask)
{ {
u32 t; u32 t;
@ -184,7 +186,7 @@ static inline void sw_int_disable(u32 mask)
sw_write_reg(SWITCH_REG_INT_MASK, t); sw_write_reg(SWITCH_REG_INT_MASK, t);
} }
static inline void sw_int_enable(u32 mask) static inline void sw_int_unmask(u32 mask)
{ {
u32 t; u32 t;
@ -198,6 +200,15 @@ static inline void sw_int_ack(u32 mask)
sw_write_reg(SWITCH_REG_INT_STATUS, mask); sw_write_reg(SWITCH_REG_INT_STATUS, mask);
} }
static inline u32 sw_int_status(void)
{
u32 t;
t = sw_read_reg(SWITCH_REG_INT_STATUS);
t &= ~sw_read_reg(SWITCH_REG_INT_MASK);
return t;
}
/* ------------------------------------------------------------------------ */ /* ------------------------------------------------------------------------ */
static void sw_dump_desc(char *label, struct dma_desc *desc, int tx) static void sw_dump_desc(char *label, struct dma_desc *desc, int tx)
@ -264,6 +275,64 @@ static void sw_dump_intr_mask(char *label, u32 mask)
(mask & SWITCH_INT_CPUH) ? " CPUH" : ""); (mask & SWITCH_INT_CPUH) ? " CPUH" : "");
} }
static void sw_dump_regs(void)
{
u32 t;
t = SW_READ_REG(PHY_STATUS);
SW_DBG("phy_status: %08X\n", t);
t = SW_READ_REG(CPUP_CONF);
SW_DBG("cpup_conf: %08X%s%s%s\n", t,
(t & CPUP_CONF_DCPUP) ? " DCPUP" : "",
(t & CPUP_CONF_CRCP) ? " CRCP" : "",
(t & CPUP_CONF_BTM) ? " BTM" : "");
t = SW_READ_REG(PORT_CONF0);
SW_DBG("port_conf0: %08X\n", t);
t = SW_READ_REG(PORT_CONF1);
SW_DBG("port_conf1: %08X\n", t);
t = SW_READ_REG(PORT_CONF2);
SW_DBG("port_conf2: %08X\n", t);
t = SW_READ_REG(VLAN_G1);
SW_DBG("vlan g1: %08X\n", t);
t = SW_READ_REG(VLAN_G2);
SW_DBG("vlan g2: %08X\n", t);
t = SW_READ_REG(BW_CNTL0);
SW_DBG("bw_cntl0: %08X\n", t);
t = SW_READ_REG(BW_CNTL1);
SW_DBG("bw_cntl1: %08X\n", t);
t = SW_READ_REG(PHY_CNTL0);
SW_DBG("phy_cntl0: %08X\n", t);
t = SW_READ_REG(PHY_CNTL1);
SW_DBG("phy_cntl1: %08X\n", t);
t = SW_READ_REG(PHY_CNTL2);
SW_DBG("phy_cntl2: %08X\n", t);
t = SW_READ_REG(PHY_CNTL3);
SW_DBG("phy_cntl3: %08X\n", t);
t = SW_READ_REG(PHY_CNTL4);
SW_DBG("phy_cntl4: %08X\n", t);
t = SW_READ_REG(INT_STATUS);
sw_dump_intr_mask("int_status: ", t);
t = SW_READ_REG(INT_MASK);
sw_dump_intr_mask("int_mask: ", t);
t = SW_READ_REG(SHDA);
SW_DBG("shda: %08X\n", t);
t = SW_READ_REG(SLDA);
SW_DBG("slda: %08X\n", t);
t = SW_READ_REG(RHDA);
SW_DBG("rhda: %08X\n", t);
t = SW_READ_REG(RLDA);
SW_DBG("rlda: %08X\n", t);
}
/* ------------------------------------------------------------------------ */ /* ------------------------------------------------------------------------ */
static inline void adm5120_rx_dma_update(struct dma_desc *desc, static inline void adm5120_rx_dma_update(struct dma_desc *desc,
@ -276,82 +345,141 @@ static inline void adm5120_rx_dma_update(struct dma_desc *desc,
DESC_OWN | (end ? DESC_EOR : 0); DESC_OWN | (end ? DESC_EOR : 0);
} }
static int adm5120_switch_rx(struct net_device *dev, int *budget) static void adm5120_switch_rx_refill(void)
{ {
struct sk_buff *skb, *skbn; unsigned int entry;
struct adm5120_sw *priv;
struct net_device *cdev;
struct dma_desc *desc;
int len, quota;
quota = min(dev->quota, *budget); for (; cur_rxl - dirty_rxl > 0; dirty_rxl++) {
SW_DBG("%s polling, quota=%d\n", dev->name, quota); struct dma_desc *desc;
struct sk_buff *skb;
entry = dirty_rxl % RX_RING_SIZE;
desc = &rxl_descs[entry];
skb = rxl_skbuff[entry];
if (skb == NULL) {
skb = alloc_skb(SKB_ALLOC_LEN, GFP_ATOMIC);
if (skb) {
skb_reserve(skb, SKB_RESERVE_LEN);
rxl_skbuff[entry] = skb;
} else {
SW_ERR("no memory for skb\n");
desc->buflen = 0;
desc->buf2 = 0;
desc->misc = 0;
desc->buf1 = (desc->buf1 & DESC_EOR) | DESC_OWN;
break;
}
}
desc->buf2 = 0;
desc->buflen = RX_MAX_PKTLEN;
desc->misc = 0;
desc->buf1 = (desc->buf1 & DESC_EOR) | DESC_OWN |
DESC_ADDR(skb->data);
}
}
static int adm5120_switch_rx(int limit)
{
unsigned int done = 0;
SW_DBG("rx start, limit=%d, cur_rxl=%u, dirty_rxl=%u\n",
limit, cur_rxl, dirty_rxl);
sw_int_ack(SWITCH_INTS_POLL); sw_int_ack(SWITCH_INTS_POLL);
desc = &rxl_descs[cur_rxl]; while (done < limit) {
while (!(desc->buf1 & DESC_OWN) && quota) { int entry = cur_rxl % RX_RING_SIZE;
u32 port = desc_get_srcport(desc); struct dma_desc *desc = &rxl_descs[entry];
cdev = adm5120_port[port]; struct net_device *rdev;
if (cdev != dev) { /* The current packet belongs to a different device */ unsigned int port;
if ((cdev==NULL) || !netif_running(cdev)) {
/* discard (update with old skb) */
skb = skbn = NULL;
goto rx_skip;
}
else {
netif_rx_schedule(cdev);/* Start polling next device */
return 1; /* return 1 -> More packets to process */
}
} if (desc->buf1 & DESC_OWN)
skb = rxl_skbuff[cur_rxl]; break;
len = desc_get_pktlen(desc);
len -= ETH_CSUM_LEN;
priv = netdev_priv(dev); if (dirty_rxl + RX_RING_SIZE == cur_rxl)
if (len <= 0 || len > RX_MAX_PKTLEN || break;
desc_ipcsum_fail(desc)) {
dev->stats.rx_errors++; port = desc_get_srcport(desc);
skbn = NULL; rdev = adm5120_port[port];
SW_DBG("rx descriptor %u, desc=%p, skb=%p\n", entry, desc,
rxl_skbuff[entry]);
if ((rdev) && netif_running(rdev)) {
struct sk_buff *skb = rxl_skbuff[entry];
int pktlen;
pktlen = desc_get_pktlen(desc);
pktlen -= ETH_CSUM_LEN;
if ((pktlen == 0) || desc_ipcsum_fail(desc)) {
rdev->stats.rx_errors++;
if (pktlen == 0)
rdev->stats.rx_length_errors++;
if (desc_ipcsum_fail(desc))
rdev->stats.rx_crc_errors++;
SW_DBG("rx error, recycling skb %u\n", entry);
} else { } else {
skbn = dev_alloc_skb(SKB_ALLOC_LEN); skb_put(skb, pktlen);
if (skbn) {
skb_put(skb, len); skb->dev = rdev;
skb->dev = dev; skb->protocol = eth_type_trans(skb, rdev);
skb->protocol = eth_type_trans(skb, dev);
skb->ip_summed = CHECKSUM_UNNECESSARY; skb->ip_summed = CHECKSUM_UNNECESSARY;
dev->last_rx = jiffies;
dev->stats.rx_packets++;
dev->stats.rx_bytes += len;
skb_reserve(skbn, SKB_RESERVE_LEN);
rxl_skbuff[cur_rxl] = skbn;
} else {
SW_INFO("%s recycling!\n", dev->name);
}
}
rx_skip:
adm5120_rx_dma_update(&rxl_descs[cur_rxl],
rxl_skbuff[cur_rxl],
(RX_RING_SIZE-1==cur_rxl));
if (RX_RING_SIZE == ++cur_rxl)
cur_rxl = 0;
desc = &rxl_descs[cur_rxl];
if (skbn){
netif_receive_skb(skb);
dev->quota--;
(*budget)--;
quota--;
}
} /* while */
if (quota) { dma_cache_wback_inv((unsigned long)skb->data,
netif_rx_complete(dev); skb->len);
sw_int_enable(SWITCH_INTS_POLL);
netif_receive_skb(skb);
rdev->last_rx = jiffies;
rdev->stats.rx_packets++;
rdev->stats.rx_bytes += pktlen;
rxl_skbuff[entry] = NULL;
done++;
}
} else {
SW_DBG("no rx device, recycling skb %u\n", entry);
}
cur_rxl++;
if (cur_rxl - dirty_rxl > RX_RING_SIZE / 4)
adm5120_switch_rx_refill();
}
adm5120_switch_rx_refill();
SW_DBG("rx finished, cur_rxl=%u, dirty_rxl=%u, processed %d\n",
cur_rxl, dirty_rxl, done);
return done;
}
static int adm5120_switch_poll(struct net_device *dev, int *budget)
{
int limit = min(dev->quota, *budget);
int done;
u32 status;
done = adm5120_switch_rx(limit);
*budget -= done;
dev->quota -= done;
status = sw_int_status() & SWITCH_INTS_POLL;
if ((done < limit) && (!status)) {
spin_lock_irq(&poll_lock);
SW_DBG("disable polling mode for %s\n", poll_dev->name);
netif_rx_complete(poll_dev);
sw_int_unmask(SWITCH_INTS_POLL);
poll_dev = NULL;
spin_unlock_irq(&poll_lock);
return 0; return 0;
} }
/* If there are still packets to process, return 1 */
return 1; return 1;
} }
@ -368,7 +496,6 @@ static void adm5120_switch_tx(void)
if (desc->buf1 & DESC_OWN) if (desc->buf1 & DESC_OWN)
break; break;
sw_dump_desc("tx done", desc, 1);
if (netif_running(skb->dev)) { if (netif_running(skb->dev)) {
skb->dev->stats.tx_bytes += skb->len; skb->dev->stats.tx_bytes += skb->len;
skb->dev->stats.tx_packets++; skb->dev->stats.tx_packets++;
@ -395,30 +522,35 @@ static irqreturn_t adm5120_poll_irq(int irq, void *dev_id)
struct net_device *dev = dev_id; struct net_device *dev = dev_id;
u32 status; u32 status;
status = sw_read_reg(SWITCH_REG_INT_STATUS); status = sw_int_status();
status &= ~(sw_read_reg(SWITCH_REG_INT_MASK));
status &= SWITCH_INTS_POLL; status &= SWITCH_INTS_POLL;
if (!status) if (!status)
return IRQ_NONE; return IRQ_NONE;
sw_int_disable(SWITCH_INTS_POLL); sw_dump_intr_mask("poll ints", status);
netif_rx_schedule(dev);
if (!netif_running(dev)) {
SW_DBG("device %s is not running\n", dev->name);
return IRQ_NONE;
}
spin_lock(&poll_lock);
if (!poll_dev) {
SW_DBG("enable polling mode for %s\n", dev->name);
poll_dev = dev;
sw_int_mask(SWITCH_INTS_POLL);
netif_rx_schedule(poll_dev);
}
spin_unlock(&poll_lock);
SW_DBG("%s handling IRQ%d\n", dev->name, irq);
return IRQ_HANDLED; return IRQ_HANDLED;
} }
static irqreturn_t adm5120_switch_irq(int irq, void *dev_id) static irqreturn_t adm5120_switch_irq(int irq, void *dev_id)
{ {
irqreturn_t ret;
u32 status; u32 status;
status = sw_read_reg(SWITCH_REG_INT_STATUS); status = sw_int_status();
status &= ~(sw_read_reg(SWITCH_REG_INT_MASK));
sw_dump_intr_mask("sw irq", status);
status &= SWITCH_INTS_ALL & ~SWITCH_INTS_POLL; status &= SWITCH_INTS_ALL & ~SWITCH_INTS_POLL;
if (!status) if (!status)
return IRQ_NONE; return IRQ_NONE;
@ -481,7 +613,7 @@ static int adm5120_switch_open(struct net_device *dev)
netif_start_queue(dev); netif_start_queue(dev);
if (!sw_used++) if (!sw_used++)
/* enable interrupts on first open */ /* enable interrupts on first open */
sw_int_enable(SWITCH_INTS_USED); sw_int_unmask(SWITCH_INTS_USED);
/* enable (additional) port */ /* enable (additional) port */
t = sw_read_reg(SWITCH_REG_PORT_CONF0); t = sw_read_reg(SWITCH_REG_PORT_CONF0);
@ -500,7 +632,7 @@ static int adm5120_switch_stop(struct net_device *dev)
int i; int i;
if (!--sw_used) if (!--sw_used)
sw_int_disable(SWITCH_INTS_USED); sw_int_mask(SWITCH_INTS_USED);
/* disable port if not assigned to other devices */ /* disable port if not assigned to other devices */
t = sw_read_reg(SWITCH_REG_PORT_CONF0); t = sw_read_reg(SWITCH_REG_PORT_CONF0);
@ -522,6 +654,9 @@ static int adm5120_sw_start_xmit(struct sk_buff *skb, struct net_device *dev)
unsigned int entry; unsigned int entry;
unsigned long data; unsigned long data;
/* lock switch irq */
spin_lock_irq(&sw_lock);
/* calculate the next TX descriptor entry. */ /* calculate the next TX descriptor entry. */
entry = cur_txl % TX_RING_SIZE; entry = cur_txl % TX_RING_SIZE;
@ -544,9 +679,6 @@ static int adm5120_sw_start_xmit(struct sk_buff *skb, struct net_device *dev)
desc->buflen = skb->len < ETH_ZLEN ? ETH_ZLEN : skb->len; desc->buflen = skb->len < ETH_ZLEN ? ETH_ZLEN : skb->len;
/* lock switch irq */
spin_lock_irq(&sw_lock);
desc->buf1 = data | DESC_OWN; desc->buf1 = data | DESC_OWN;
sw_write_reg(SWITCH_REG_SEND_TRIG, SEND_TRIG_STL); sw_write_reg(SWITCH_REG_SEND_TRIG, SEND_TRIG_STL);
@ -720,7 +852,50 @@ static void adm5120_dma_rx_init(struct dma_desc *desc, struct sk_buff **skbl,
} }
} }
static int __init adm5120_sw_init(void) static void adm5120_switch_cleanup(void)
{
int i;
/* disable interrupts */
sw_int_mask(SWITCH_INTS_ALL);
for (i = 0; i < SWITCH_NUM_PORTS; i++) {
struct net_device *dev = adm5120_devs[i];
if (dev) {
unregister_netdev(dev);
free_irq(ADM5120_IRQ_SWITCH, dev);
free_netdev(dev);
}
}
/* cleanup TX ring */
if (txl_skbuff) {
for (i = 0; i < TX_RING_SIZE; i++)
if (txl_skbuff[i])
kfree_skb(txl_skbuff[i]);
kfree(txl_skbuff);
}
if (txl_descs)
dma_free_coherent(NULL, TX_DESCS_SIZE, txl_descs,
txl_descs_dma);
/* cleanup RX ring */
if (rxl_skbuff) {
for (i = 0; i < RX_RING_SIZE; i++)
if (rxl_skbuff[i])
kfree_skb(rxl_skbuff[i]);
kfree(rxl_skbuff);
}
if (rxl_descs)
dma_free_coherent(NULL, RX_DESCS_SIZE, rxl_descs,
rxl_descs_dma);
free_irq(ADM5120_IRQ_SWITCH, &sw_dev);
}
static int __init adm5120_switch_init(void)
{ {
struct net_device *dev; struct net_device *dev;
u32 t; u32 t;
@ -728,8 +903,10 @@ static int __init adm5120_sw_init(void)
err = request_irq(ADM5120_IRQ_SWITCH, adm5120_switch_irq, err = request_irq(ADM5120_IRQ_SWITCH, adm5120_switch_irq,
(IRQF_SHARED | IRQF_DISABLED), "switch", &sw_dev); (IRQF_SHARED | IRQF_DISABLED), "switch", &sw_dev);
if (err) if (err) {
goto out; SW_ERR("request_irq failed with error %d\n", err);
goto err;
}
adm5120_nrdevs = adm5120_eth_num_ports; adm5120_nrdevs = adm5120_eth_num_ports;
@ -759,31 +936,63 @@ static int __init adm5120_sw_init(void)
/* Force all the packets from all ports are low priority */ /* Force all the packets from all ports are low priority */
sw_write_reg(SWITCH_REG_PRI_CNTL, 0); sw_write_reg(SWITCH_REG_PRI_CNTL, 0);
sw_int_disable(SWITCH_INTS_ALL); sw_int_mask(SWITCH_INTS_ALL);
sw_int_ack(SWITCH_INTS_ALL); sw_int_ack(SWITCH_INTS_ALL);
cur_txl = dirty_txl = 0; /* init RX ring */
cur_rxl = dirty_rxl = 0; cur_rxl = dirty_rxl = 0;
rxl_descs = dma_alloc_coherent(NULL, RX_DESCS_SIZE, &rxl_descs_dma,
GFP_ATOMIC);
if (!rxl_descs) {
err = -ENOMEM;
goto err;
}
txh_descs = (void *)KSEG1ADDR((u32)txh_descs_v); rxl_skbuff = kzalloc(RX_SKBS_SIZE, GFP_KERNEL);
txl_descs = (void *)KSEG1ADDR((u32)txl_descs_v); if (!rxl_skbuff) {
rxh_descs = (void *)KSEG1ADDR((u32)rxh_descs_v); err = -ENOMEM;
rxl_descs = (void *)KSEG1ADDR((u32)rxl_descs_v); goto err;
}
for (i = 0; i < RX_RING_SIZE; i++) {
struct sk_buff *skb;
skb = alloc_skb(SKB_ALLOC_LEN, GFP_ATOMIC);
if (!skb) {
err = -ENOMEM;
goto err;
}
rxl_skbuff[i] = skb;
skb_reserve(skb, SKB_RESERVE_LEN);
}
/* init TX ring */
cur_txl = dirty_txl = 0;
txl_descs = dma_alloc_coherent(NULL, TX_DESCS_SIZE, &txl_descs_dma,
GFP_ATOMIC);
if (!txl_descs) {
err = -ENOMEM;
goto err;
}
txl_skbuff = kzalloc(TX_SKBS_SIZE, GFP_KERNEL);
if (!txl_skbuff) {
err = -ENOMEM;
goto err;
}
adm5120_dma_tx_init(txh_descs, txh_skbuff, TX_RING_SIZE);
adm5120_dma_tx_init(txl_descs, txl_skbuff, TX_RING_SIZE); adm5120_dma_tx_init(txl_descs, txl_skbuff, TX_RING_SIZE);
adm5120_dma_rx_init(rxh_descs, rxh_skbuff, RX_RING_SIZE);
adm5120_dma_rx_init(rxl_descs, rxl_skbuff, RX_RING_SIZE); adm5120_dma_rx_init(rxl_descs, rxl_skbuff, RX_RING_SIZE);
sw_write_reg(SWITCH_REG_SHDA, KSEG1ADDR(txh_descs));
sw_write_reg(SWITCH_REG_SHDA, 0);
sw_write_reg(SWITCH_REG_SLDA, KSEG1ADDR(txl_descs)); sw_write_reg(SWITCH_REG_SLDA, KSEG1ADDR(txl_descs));
sw_write_reg(SWITCH_REG_RHDA, KSEG1ADDR(rxh_descs)); sw_write_reg(SWITCH_REG_RHDA, 0);
sw_write_reg(SWITCH_REG_RLDA, KSEG1ADDR(rxl_descs)); sw_write_reg(SWITCH_REG_RLDA, KSEG1ADDR(rxl_descs));
for (i = 0; i < SWITCH_NUM_PORTS; i++) { for (i = 0; i < SWITCH_NUM_PORTS; i++) {
adm5120_devs[i] = alloc_etherdev(sizeof(struct adm5120_sw)); adm5120_devs[i] = alloc_etherdev(sizeof(struct adm5120_sw));
if (!adm5120_devs[i]) { if (!adm5120_devs[i]) {
err = -ENOMEM; err = -ENOMEM;
goto out_int; goto err;
} }
dev = adm5120_devs[i]; dev = adm5120_devs[i];
@ -791,7 +1000,7 @@ static int __init adm5120_sw_init(void)
(IRQF_SHARED | IRQF_DISABLED), dev->name, dev); (IRQF_SHARED | IRQF_DISABLED), dev->name, dev);
if (err) { if (err) {
SW_ERR("unable to get irq for %s\n", dev->name); SW_ERR("unable to get irq for %s\n", dev->name);
goto out_int; goto err;
} }
SET_MODULE_OWNER(dev); SET_MODULE_OWNER(dev);
@ -807,19 +1016,21 @@ static int __init adm5120_sw_init(void)
dev->tx_timeout = adm5120_tx_timeout; dev->tx_timeout = adm5120_tx_timeout;
dev->watchdog_timeo = TX_TIMEOUT; dev->watchdog_timeo = TX_TIMEOUT;
dev->set_mac_address = adm5120_sw_set_mac_address; dev->set_mac_address = adm5120_sw_set_mac_address;
dev->poll = adm5120_switch_rx; dev->poll = adm5120_switch_poll;
dev->weight = 64; dev->weight = 64;
memcpy(dev->dev_addr, adm5120_eth_macs[i], 6); memcpy(dev->dev_addr, adm5120_eth_macs[i], 6);
adm5120_write_mac(dev); adm5120_write_mac(dev);
if ((err = register_netdev(dev))) { err = register_netdev(dev);
free_irq(ADM5120_IRQ_SWITCH, dev); if (err) {
free_netdev(dev); SW_INFO("%s register failed, error=%d\n",
goto out_int; dev->name, err);
goto err;
} }
SW_INFO("%s created for switch port%d\n", dev->name, i); SW_INFO("%s created for switch port%d\n", dev->name, i);
} }
/* setup vlan/port mapping after devs are filled up */ /* setup vlan/port mapping after devs are filled up */
adm5120_set_vlan(adm5120_eth_vlans); adm5120_set_vlan(adm5120_eth_vlans);
@ -830,43 +1041,17 @@ static int __init adm5120_sw_init(void)
return 0; return 0;
out_int: err:
/* Undo everything that did succeed */ adm5120_switch_cleanup();
for (; i; i--) {
unregister_netdev(adm5120_devs[i-1]);
free_netdev(adm5120_devs[i-1]);
}
free_irq(ADM5120_IRQ_SWITCH, NULL);
out:
SW_ERR("init failed\n"); SW_ERR("init failed\n");
return err; return err;
} }
static void __exit adm5120_sw_exit(void) static void __exit adm5120_switch_exit(void)
{ {
int i; adm5120_switch_cleanup();
for (i = 0; i < SWITCH_NUM_PORTS; i++) {
struct net_device *dev = adm5120_devs[i];
unregister_netdev(dev);
free_irq(ADM5120_IRQ_SWITCH, dev);
free_netdev(dev);
}
free_irq(ADM5120_IRQ_SWITCH, &sw_dev);
for (i = 0; i < RX_RING_SIZE; i++) {
if (!rxh_skbuff[i])
break;
kfree_skb(rxh_skbuff[i]);
}
for (i = 0; i < RX_RING_SIZE; i++) {
if (!rxl_skbuff[i])
break;
kfree_skb(rxl_skbuff[i]);
}
} }
module_init(adm5120_sw_init); module_init(adm5120_switch_init);
module_exit(adm5120_sw_exit); module_exit(adm5120_switch_exit);