git://ftp.safe.ca / safe / jmp / linux-2.6 / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
PM/Suspend: Introduce two new platform callbacks to avoid breakage
[safe/jmp/linux-2.6] / drivers / net / korina.c
diff --git a/drivers/net/korina.c b/drivers/net/korina.c
index 7aa05f8..38d6649 100644 (file)
--- a/drivers/net/korina.c
+++ b/drivers/net/korina.c
@@ -199,7 +199,7 @@ static int korina_send_packet(struct sk_buff *skb, struct net_device *dev)
        struct korina_private *lp = netdev_priv(dev);
        unsigned long flags;
        u32 length;
-       u32 chain_index;
+       u32 chain_prev, chain_next;
        struct dma_desc *td;
 
        spin_lock_irqsave(&lp->lock, flags);
@@ -231,8 +231,8 @@ static int korina_send_packet(struct sk_buff *skb, struct net_device *dev)
        /* Setup the transmit descriptor. */
        dma_cache_inv((u32) td, sizeof(*td));
        td->ca = CPHYSADDR(skb->data);
-       chain_index = (lp->tx_chain_tail - 1) &
-                       KORINA_TDS_MASK;
+       chain_prev = (lp->tx_chain_tail - 1) & KORINA_TDS_MASK;
+       chain_next = (lp->tx_chain_tail + 1) & KORINA_TDS_MASK;
 
        if (readl(&(lp->tx_dma_regs->dmandptr)) == 0) {
                if (lp->tx_chain_status == desc_empty) {
@@ -240,7 +240,7 @@ static int korina_send_packet(struct sk_buff *skb, struct net_device *dev)
                        td->control = DMA_COUNT(length) |
                                        DMA_DESC_COF | DMA_DESC_IOF;
                        /* Move tail */
-                       lp->tx_chain_tail = chain_index;
+                       lp->tx_chain_tail = chain_next;
                        /* Write to NDPTR */
                        writel(CPHYSADDR(&lp->td_ring[lp->tx_chain_head]),
                                        &lp->tx_dma_regs->dmandptr);
@@ -251,12 +251,12 @@ static int korina_send_packet(struct sk_buff *skb, struct net_device *dev)
                        td->control = DMA_COUNT(length) |
                                        DMA_DESC_COF | DMA_DESC_IOF;
                        /* Link to prev */
-                       lp->td_ring[chain_index].control &=
+                       lp->td_ring[chain_prev].control &=
                                        ~DMA_DESC_COF;
                        /* Link to prev */
-                       lp->td_ring[chain_index].link =  CPHYSADDR(td);
+                       lp->td_ring[chain_prev].link =  CPHYSADDR(td);
                        /* Move tail */
-                       lp->tx_chain_tail = chain_index;
+                       lp->tx_chain_tail = chain_next;
                        /* Write to NDPTR */
                        writel(CPHYSADDR(&lp->td_ring[lp->tx_chain_head]),
                                        &(lp->tx_dma_regs->dmandptr));
@@ -270,17 +270,16 @@ static int korina_send_packet(struct sk_buff *skb, struct net_device *dev)
                        td->control = DMA_COUNT(length) |
                                        DMA_DESC_COF | DMA_DESC_IOF;
                        /* Move tail */
-                       lp->tx_chain_tail = chain_index;
+                       lp->tx_chain_tail = chain_next;
                        lp->tx_chain_status = desc_filled;
-                       netif_stop_queue(dev);
                } else {
                        /* Update tail */
                        td->control = DMA_COUNT(length) |
                                        DMA_DESC_COF | DMA_DESC_IOF;
-                       lp->td_ring[chain_index].control &=
+                       lp->td_ring[chain_prev].control &=
                                        ~DMA_DESC_COF;
-                       lp->td_ring[chain_index].link =  CPHYSADDR(td);
-                       lp->tx_chain_tail = chain_index;
+                       lp->td_ring[chain_prev].link =  CPHYSADDR(td);
+                       lp->tx_chain_tail = chain_next;
                }
        }
        dma_cache_wback((u32) td, sizeof(*td));
@@ -330,13 +329,13 @@ static irqreturn_t korina_rx_dma_interrupt(int irq, void *dev_id)
 
        dmas = readl(&lp->rx_dma_regs->dmas);
        if (dmas & (DMA_STAT_DONE | DMA_STAT_HALT | DMA_STAT_ERR)) {
-               netif_rx_schedule(&lp->napi);
-
                dmasm = readl(&lp->rx_dma_regs->dmasm);
                writel(dmasm | (DMA_STAT_DONE |
                                DMA_STAT_HALT | DMA_STAT_ERR),
                                &lp->rx_dma_regs->dmasm);
 
+               napi_schedule(&lp->napi);
+
                if (dmas & DMA_STAT_ERR)
                        printk(KERN_ERR DRV_NAME "%s: DMA error\n", dev->name);
 
@@ -417,6 +416,9 @@ static int korina_rx(struct net_device *dev, int limit)
                        if (devcs & ETH_RX_MP)
                                dev->stats.multicast++;
 
+                       /* 16 bit align */
+                       skb_reserve(skb_new, 2);
+
                        lp->rx_skb[lp->rx_next_done] = skb_new;
                }
 
@@ -466,7 +468,7 @@ static int korina_poll(struct napi_struct *napi, int budget)
 
        work_done = korina_rx(dev, budget);
        if (work_done < budget) {
-               netif_rx_complete(napi);
+               napi_complete(napi);
 
                writel(readl(&lp->rx_dma_regs->dmasm) &
                        ~(DMA_STAT_DONE | DMA_STAT_HALT | DMA_STAT_ERR),
@@ -623,12 +625,12 @@ korina_tx_dma_interrupt(int irq, void *dev_id)
        dmas = readl(&lp->tx_dma_regs->dmas);
 
        if (dmas & (DMA_STAT_FINI | DMA_STAT_ERR)) {
-               korina_tx(dev);
-
                dmasm = readl(&lp->tx_dma_regs->dmasm);
                writel(dmasm | (DMA_STAT_FINI | DMA_STAT_ERR),
                                &lp->tx_dma_regs->dmasm);
 
+               korina_tx(dev);
+
                if (lp->tx_chain_status == desc_filled &&
                        (readl(&(lp->tx_dma_regs->dmandptr)) == 0)) {
                        writel(CPHYSADDR(&lp->td_ring[lp->tx_chain_head]),
@@ -741,6 +743,7 @@ static struct ethtool_ops netdev_ethtool_ops = {
 static void korina_alloc_ring(struct net_device *dev)
 {
        struct korina_private *lp = netdev_priv(dev);
+       struct sk_buff *skb;
        int i;
 
        /* Initialize the transmit descriptors */
@@ -756,8 +759,6 @@ static void korina_alloc_ring(struct net_device *dev)
 
        /* Initialize the receive descriptors */
        for (i = 0; i < KORINA_NUM_RDS; i++) {
-               struct sk_buff *skb = lp->rx_skb[i];
-
                skb = dev_alloc_skb(KORINA_RBSIZE + 2);
                if (!skb)
                        break;
@@ -770,11 +771,12 @@ static void korina_alloc_ring(struct net_device *dev)
                lp->rd_ring[i].link = CPHYSADDR(&lp->rd_ring[i+1]);
        }
 
-       /* loop back */
-       lp->rd_ring[i].link = CPHYSADDR(&lp->rd_ring[0]);
-       lp->rx_next_done  = 0;
+       /* loop back receive descriptors, so the last
+        * descriptor points to the first one */
+       lp->rd_ring[i - 1].link = CPHYSADDR(&lp->rd_ring[0]);
+       lp->rd_ring[i - 1].control |= DMA_DESC_COD;
 
-       lp->rd_ring[i].control |= DMA_DESC_COD;
+       lp->rx_next_done  = 0;
        lp->rx_chain_head = 0;
        lp->rx_chain_tail = 0;
        lp->rx_chain_status = desc_empty;
@@ -1001,14 +1003,14 @@ static int korina_open(struct net_device *dev)
         * that handles the Done Finished
         * Ovr and Und Events */
        ret = request_irq(lp->rx_irq, &korina_rx_dma_interrupt,
-               IRQF_SHARED | IRQF_DISABLED, "Korina ethernet Rx", dev);
+                       IRQF_DISABLED, "Korina ethernet Rx", dev);
        if (ret < 0) {
                printk(KERN_ERR DRV_NAME "%s: unable to get Rx DMA IRQ %d\n",
                    dev->name, lp->rx_irq);
                goto err_release;
        }
        ret = request_irq(lp->tx_irq, &korina_tx_dma_interrupt,
-               IRQF_SHARED | IRQF_DISABLED, "Korina ethernet Tx", dev);
+                       IRQF_DISABLED, "Korina ethernet Tx", dev);
        if (ret < 0) {
                printk(KERN_ERR DRV_NAME "%s: unable to get Tx DMA IRQ %d\n",
                    dev->name, lp->tx_irq);
@@ -1017,7 +1019,7 @@ static int korina_open(struct net_device *dev)
 
        /* Install handler for overrun error. */
        ret = request_irq(lp->ovr_irq, &korina_ovr_interrupt,
-                       IRQF_SHARED | IRQF_DISABLED, "Ethernet Overflow", dev);
+                       IRQF_DISABLED, "Ethernet Overflow", dev);
        if (ret < 0) {
                printk(KERN_ERR DRV_NAME"%s: unable to get OVR IRQ %d\n",
                    dev->name, lp->ovr_irq);
@@ -1026,7 +1028,7 @@ static int korina_open(struct net_device *dev)
 
        /* Install handler for underflow error. */
        ret = request_irq(lp->und_irq, &korina_und_interrupt,
-                       IRQF_SHARED | IRQF_DISABLED, "Ethernet Underflow", dev);
+                       IRQF_DISABLED, "Ethernet Underflow", dev);
        if (ret < 0) {
                printk(KERN_ERR DRV_NAME "%s: unable to get UND IRQ %d\n",
                    dev->name, lp->und_irq);
Full containers within linux kernel