1 files changed, 43 insertions, 47 deletions

diff --git a/drivers/net/tokenring/3c359.c b/drivers/net/tokenring/3c359.c
index 5d31519a6c67..44a06f8b588f 100644
--- a/drivers/net/tokenring/3c359.c
+++ b/drivers/net/tokenring/3c359.c
@@ -570,7 +570,7 @@ static int xl_open(struct net_device *dev)
         struct xl_private *xl_priv=netdev_priv(dev);
         u8 __iomem *xl_mmio = xl_priv->xl_mmio ; 
         u8 i ; 
-        u16 hwaddr[3] ; /* Should be u8[6] but we get word return values */
+        __le16 hwaddr[3] ; /* Should be u8[6] but we get word return values */
         int open_err ;
 
         u16 switchsettings, switchsettings_eeprom  ;
@@ -580,15 +580,12 @@ static int xl_open(struct net_device *dev)
         }
 
         /* 
-         * Read the information from the EEPROM that we need. I know we
-         * should use ntohs, but the word gets stored reversed in the 16
-         * bit field anyway and it all works its self out when we memcpy
-         * it into dev->dev_addr. 
+         * Read the information from the EEPROM that we need.
          */
         
-        hwaddr[0] = xl_ee_read(dev,0x10) ; 
-        hwaddr[1] = xl_ee_read(dev,0x11) ; 
-        hwaddr[2] = xl_ee_read(dev,0x12) ; 
+        hwaddr[0] = cpu_to_le16(xl_ee_read(dev,0x10));
+        hwaddr[1] = cpu_to_le16(xl_ee_read(dev,0x11));
+        hwaddr[2] = cpu_to_le16(xl_ee_read(dev,0x12));
 
         /* Ring speed */
 
@@ -665,8 +662,8 @@ static int xl_open(struct net_device *dev)
                         break ; 
 
                 skb->dev = dev ; 
-                xl_priv->xl_rx_ring[i].upfragaddr = pci_map_single(xl_priv->pdev, skb->data,xl_priv->pkt_buf_sz, PCI_DMA_FROMDEVICE) ; 
-                xl_priv->xl_rx_ring[i].upfraglen = xl_priv->pkt_buf_sz | RXUPLASTFRAG;
+                xl_priv->xl_rx_ring[i].upfragaddr = cpu_to_le32(pci_map_single(xl_priv->pdev, skb->data,xl_priv->pkt_buf_sz, PCI_DMA_FROMDEVICE));
+                xl_priv->xl_rx_ring[i].upfraglen = cpu_to_le32(xl_priv->pkt_buf_sz) | RXUPLASTFRAG;
                 xl_priv->rx_ring_skb[i] = skb ;         
         }
 
@@ -680,7 +677,7 @@ static int xl_open(struct net_device *dev)
         xl_priv->rx_ring_tail = 0 ; 
         xl_priv->rx_ring_dma_addr = pci_map_single(xl_priv->pdev,xl_priv->xl_rx_ring, sizeof(struct xl_rx_desc) * XL_RX_RING_SIZE, PCI_DMA_TODEVICE) ; 
         for (i=0;i<(xl_priv->rx_ring_no-1);i++) { 
-                xl_priv->xl_rx_ring[i].upnextptr = xl_priv->rx_ring_dma_addr + (sizeof (struct xl_rx_desc) * (i+1)) ; 
+                xl_priv->xl_rx_ring[i].upnextptr = cpu_to_le32(xl_priv->rx_ring_dma_addr + (sizeof (struct xl_rx_desc) * (i+1)));
         } 
         xl_priv->xl_rx_ring[i].upnextptr = 0 ; 
 
@@ -698,7 +695,7 @@ static int xl_open(struct net_device *dev)
          * Setup the first dummy DPD entry for polling to start working.
          */
 
-        xl_priv->xl_tx_ring[0].framestartheader = TXDPDEMPTY ; 
+        xl_priv->xl_tx_ring[0].framestartheader = TXDPDEMPTY;
         xl_priv->xl_tx_ring[0].buffer = 0 ; 
         xl_priv->xl_tx_ring[0].buffer_length = 0 ; 
         xl_priv->xl_tx_ring[0].dnnextptr = 0 ; 
@@ -811,17 +808,17 @@ static int xl_open_hw(struct net_device *dev)
                 return open_err ; 
         } else { 
                 writel( (MEM_WORD_READ | 0xD0000 | xl_priv->srb) + 8, xl_mmio + MMIO_MAC_ACCESS_CMD) ; 
-                xl_priv->asb = ntohs(readw(xl_mmio + MMIO_MACDATA)) ; 
+                xl_priv->asb = swab16(readw(xl_mmio + MMIO_MACDATA)) ;
                 printk(KERN_INFO "%s: Adapter Opened Details: ",dev->name) ; 
                 printk("ASB: %04x",xl_priv->asb ) ; 
                 writel( (MEM_WORD_READ | 0xD0000 | xl_priv->srb) + 10, xl_mmio + MMIO_MAC_ACCESS_CMD) ; 
-                printk(", SRB: %04x",ntohs(readw(xl_mmio + MMIO_MACDATA)) ) ; 
+                printk(", SRB: %04x",swab16(readw(xl_mmio + MMIO_MACDATA)) ) ;
  
                 writel( (MEM_WORD_READ | 0xD0000 | xl_priv->srb) + 12, xl_mmio + MMIO_MAC_ACCESS_CMD) ; 
-                xl_priv->arb = ntohs(readw(xl_mmio + MMIO_MACDATA)) ; 
+                xl_priv->arb = swab16(readw(xl_mmio + MMIO_MACDATA)) ;
                 printk(", ARB: %04x \n",xl_priv->arb ) ; 
                 writel( (MEM_WORD_READ | 0xD0000 | xl_priv->srb) + 14, xl_mmio + MMIO_MAC_ACCESS_CMD) ; 
-                vsoff = ntohs(readw(xl_mmio + MMIO_MACDATA)) ; 
+                vsoff = swab16(readw(xl_mmio + MMIO_MACDATA)) ;
 
                 /* 
                  * Interesting, sending the individual characters directly to printk was causing klogd to use
@@ -873,16 +870,15 @@ static int xl_open_hw(struct net_device *dev)
 static void adv_rx_ring(struct net_device *dev) /* Advance rx_ring, cut down on bloat in xl_rx */ 
 {
         struct xl_private *xl_priv=netdev_priv(dev);
-        int prev_ring_loc ; 
-
-        prev_ring_loc = (xl_priv->rx_ring_tail + XL_RX_RING_SIZE - 1) & (XL_RX_RING_SIZE - 1);
-        xl_priv->xl_rx_ring[prev_ring_loc].upnextptr = xl_priv->rx_ring_dma_addr + (sizeof (struct xl_rx_desc) * xl_priv->rx_ring_tail) ; 
-        xl_priv->xl_rx_ring[xl_priv->rx_ring_tail].framestatus = 0 ; 
-        xl_priv->xl_rx_ring[xl_priv->rx_ring_tail].upnextptr = 0 ;      
-        xl_priv->rx_ring_tail++ ; 
-        xl_priv->rx_ring_tail &= (XL_RX_RING_SIZE-1) ; 
-
-        return ; 
+        int n = xl_priv->rx_ring_tail;
+        int prev_ring_loc;
+
+        prev_ring_loc = (n + XL_RX_RING_SIZE - 1) & (XL_RX_RING_SIZE - 1);
+        xl_priv->xl_rx_ring[prev_ring_loc].upnextptr = cpu_to_le32(xl_priv->rx_ring_dma_addr + (sizeof (struct xl_rx_desc) * n));
+        xl_priv->xl_rx_ring[n].framestatus = 0;
+        xl_priv->xl_rx_ring[n].upnextptr = 0;
+        xl_priv->rx_ring_tail++;
+        xl_priv->rx_ring_tail &= (XL_RX_RING_SIZE-1);
 }
 
 static void xl_rx(struct net_device *dev)
@@ -914,7 +910,7 @@ static void xl_rx(struct net_device *dev)
                                 temp_ring_loc &= (XL_RX_RING_SIZE-1) ; 
                         }
 
-                        frame_length = xl_priv->xl_rx_ring[temp_ring_loc].framestatus & 0x7FFF ; 
+                        frame_length = le32_to_cpu(xl_priv->xl_rx_ring[temp_ring_loc].framestatus) & 0x7FFF;
 
                         skb = dev_alloc_skb(frame_length) ;
  
@@ -931,29 +927,29 @@ static void xl_rx(struct net_device *dev)
                         }
         
                         while (xl_priv->rx_ring_tail != temp_ring_loc) { 
-                                copy_len = xl_priv->xl_rx_ring[xl_priv->rx_ring_tail].upfraglen & 0x7FFF ; 
+                                copy_len = le32_to_cpu(xl_priv->xl_rx_ring[xl_priv->rx_ring_tail].upfraglen) & 0x7FFF;
                                 frame_length -= copy_len ;  
-                                pci_dma_sync_single_for_cpu(xl_priv->pdev,xl_priv->xl_rx_ring[xl_priv->rx_ring_tail].upfragaddr,xl_priv->pkt_buf_sz,PCI_DMA_FROMDEVICE) ;
+                                pci_dma_sync_single_for_cpu(xl_priv->pdev,le32_to_cpu(xl_priv->xl_rx_ring[xl_priv->rx_ring_tail].upfragaddr),xl_priv->pkt_buf_sz,PCI_DMA_FROMDEVICE);
                                 skb_copy_from_linear_data(xl_priv->rx_ring_skb[xl_priv->rx_ring_tail],
                                                           skb_put(skb, copy_len),
                                                           copy_len);
-                                pci_dma_sync_single_for_device(xl_priv->pdev,xl_priv->xl_rx_ring[xl_priv->rx_ring_tail].upfragaddr,xl_priv->pkt_buf_sz,PCI_DMA_FROMDEVICE) ;
+                                pci_dma_sync_single_for_device(xl_priv->pdev,le32_to_cpu(xl_priv->xl_rx_ring[xl_priv->rx_ring_tail].upfragaddr),xl_priv->pkt_buf_sz,PCI_DMA_FROMDEVICE);
                                 adv_rx_ring(dev) ; 
                         } 
 
                         /* Now we have found the last fragment */
-                        pci_dma_sync_single_for_cpu(xl_priv->pdev,xl_priv->xl_rx_ring[xl_priv->rx_ring_tail].upfragaddr,xl_priv->pkt_buf_sz,PCI_DMA_FROMDEVICE) ;
+                        pci_dma_sync_single_for_cpu(xl_priv->pdev,le32_to_cpu(xl_priv->xl_rx_ring[xl_priv->rx_ring_tail].upfragaddr),xl_priv->pkt_buf_sz,PCI_DMA_FROMDEVICE);
                         skb_copy_from_linear_data(xl_priv->rx_ring_skb[xl_priv->rx_ring_tail],
                                       skb_put(skb,copy_len), frame_length);
 /*                      memcpy(skb_put(skb,frame_length), bus_to_virt(xl_priv->xl_rx_ring[xl_priv->rx_ring_tail].upfragaddr), frame_length) ; */
-                        pci_dma_sync_single_for_device(xl_priv->pdev,xl_priv->xl_rx_ring[xl_priv->rx_ring_tail].upfragaddr,xl_priv->pkt_buf_sz,PCI_DMA_FROMDEVICE) ;
+                        pci_dma_sync_single_for_device(xl_priv->pdev,le32_to_cpu(xl_priv->xl_rx_ring[xl_priv->rx_ring_tail].upfragaddr),xl_priv->pkt_buf_sz,PCI_DMA_FROMDEVICE);
                         adv_rx_ring(dev) ; 
                         skb->protocol = tr_type_trans(skb,dev) ; 
                         netif_rx(skb) ; 
 
                 } else { /* Single Descriptor Used, simply swap buffers over, fast path  */
 
-                        frame_length = xl_priv->xl_rx_ring[xl_priv->rx_ring_tail].framestatus & 0x7FFF ; 
+                        frame_length = le32_to_cpu(xl_priv->xl_rx_ring[xl_priv->rx_ring_tail].framestatus) & 0x7FFF;
                         
                         skb = dev_alloc_skb(xl_priv->pkt_buf_sz) ; 
 
@@ -966,13 +962,13 @@ static void xl_rx(struct net_device *dev)
                         }
 
                         skb2 = xl_priv->rx_ring_skb[xl_priv->rx_ring_tail] ; 
-                        pci_unmap_single(xl_priv->pdev, xl_priv->xl_rx_ring[xl_priv->rx_ring_tail].upfragaddr, xl_priv->pkt_buf_sz,PCI_DMA_FROMDEVICE) ; 
+                        pci_unmap_single(xl_priv->pdev, le32_to_cpu(xl_priv->xl_rx_ring[xl_priv->rx_ring_tail].upfragaddr), xl_priv->pkt_buf_sz,PCI_DMA_FROMDEVICE) ;
                         skb_put(skb2, frame_length) ; 
                         skb2->protocol = tr_type_trans(skb2,dev) ; 
 
                         xl_priv->rx_ring_skb[xl_priv->rx_ring_tail] = skb ;     
-                        xl_priv->xl_rx_ring[xl_priv->rx_ring_tail].upfragaddr = pci_map_single(xl_priv->pdev,skb->data,xl_priv->pkt_buf_sz, PCI_DMA_FROMDEVICE) ; 
-                        xl_priv->xl_rx_ring[xl_priv->rx_ring_tail].upfraglen = xl_priv->pkt_buf_sz | RXUPLASTFRAG ; 
+                        xl_priv->xl_rx_ring[xl_priv->rx_ring_tail].upfragaddr = cpu_to_le32(pci_map_single(xl_priv->pdev,skb->data,xl_priv->pkt_buf_sz, PCI_DMA_FROMDEVICE));
+                        xl_priv->xl_rx_ring[xl_priv->rx_ring_tail].upfraglen = cpu_to_le32(xl_priv->pkt_buf_sz) | RXUPLASTFRAG;
                         adv_rx_ring(dev) ; 
                         xl_priv->xl_stats.rx_packets++ ; 
                         xl_priv->xl_stats.rx_bytes += frame_length ;    
@@ -1022,7 +1018,7 @@ static void xl_freemem(struct net_device *dev)
 
         for (i=0;i<XL_RX_RING_SIZE;i++) {
                 dev_kfree_skb_irq(xl_priv->rx_ring_skb[xl_priv->rx_ring_tail]) ; 
-                pci_unmap_single(xl_priv->pdev,xl_priv->xl_rx_ring[xl_priv->rx_ring_tail].upfragaddr,xl_priv->pkt_buf_sz, PCI_DMA_FROMDEVICE) ; 
+                pci_unmap_single(xl_priv->pdev,le32_to_cpu(xl_priv->xl_rx_ring[xl_priv->rx_ring_tail].upfragaddr),xl_priv->pkt_buf_sz, PCI_DMA_FROMDEVICE);
                 xl_priv->rx_ring_tail++ ; 
                 xl_priv->rx_ring_tail &= XL_RX_RING_SIZE-1; 
         } 
@@ -1181,9 +1177,9 @@ static int xl_xmit(struct sk_buff *skb, struct net_device *dev)
 
                 txd = &(xl_priv->xl_tx_ring[tx_head]) ; 
                 txd->dnnextptr = 0 ; 
-                txd->framestartheader = skb->len | TXDNINDICATE ; 
-                txd->buffer = pci_map_single(xl_priv->pdev, skb->data, skb->len, PCI_DMA_TODEVICE) ; 
-                txd->buffer_length = skb->len | TXDNFRAGLAST  ; 
+                txd->framestartheader = cpu_to_le32(skb->len) | TXDNINDICATE;
+                txd->buffer = cpu_to_le32(pci_map_single(xl_priv->pdev, skb->data, skb->len, PCI_DMA_TODEVICE));
+                txd->buffer_length = cpu_to_le32(skb->len) | TXDNFRAGLAST;
                 xl_priv->tx_ring_skb[tx_head] = skb ; 
                 xl_priv->xl_stats.tx_packets++ ; 
                 xl_priv->xl_stats.tx_bytes += skb->len ;
@@ -1199,7 +1195,7 @@ static int xl_xmit(struct sk_buff *skb, struct net_device *dev)
                 xl_priv->tx_ring_head &= (XL_TX_RING_SIZE - 1) ;
                 xl_priv->free_ring_entries-- ; 
 
-                xl_priv->xl_tx_ring[tx_prev].dnnextptr = xl_priv->tx_ring_dma_addr + (sizeof (struct xl_tx_desc) * tx_head) ; 
+                xl_priv->xl_tx_ring[tx_prev].dnnextptr = cpu_to_le32(xl_priv->tx_ring_dma_addr + (sizeof (struct xl_tx_desc) * tx_head));
 
                 /* Sneaky, by doing a read on DnListPtr we can force the card to poll on the DnNextPtr */
                 /* readl(xl_mmio + MMIO_DNLISTPTR) ; */
@@ -1237,9 +1233,9 @@ static void xl_dn_comp(struct net_device *dev)
 
         while (xl_priv->xl_tx_ring[xl_priv->tx_ring_tail].framestartheader & TXDNCOMPLETE ) { 
                 txd = &(xl_priv->xl_tx_ring[xl_priv->tx_ring_tail]) ;
-                pci_unmap_single(xl_priv->pdev,txd->buffer, xl_priv->tx_ring_skb[xl_priv->tx_ring_tail]->len, PCI_DMA_TODEVICE) ; 
+                pci_unmap_single(xl_priv->pdev, le32_to_cpu(txd->buffer), xl_priv->tx_ring_skb[xl_priv->tx_ring_tail]->len, PCI_DMA_TODEVICE);
                 txd->framestartheader = 0 ; 
-                txd->buffer = 0xdeadbeef  ; 
+                txd->buffer = cpu_to_le32(0xdeadbeef);
                 txd->buffer_length  = 0 ;  
                 dev_kfree_skb_irq(xl_priv->tx_ring_skb[xl_priv->tx_ring_tail]) ;
                 xl_priv->tx_ring_tail++ ; 
@@ -1507,9 +1503,9 @@ static void xl_arb_cmd(struct net_device *dev)
         if (arb_cmd == RING_STATUS_CHANGE) { /* Ring.Status.Change */
                 writel( ( (MEM_WORD_READ | 0xD0000 | xl_priv->arb) + 6), xl_mmio + MMIO_MAC_ACCESS_CMD) ;
                  
-                printk(KERN_INFO "%s: Ring Status Change: New Status = %04x\n", dev->name, ntohs(readw(xl_mmio + MMIO_MACDATA) )) ; 
+                printk(KERN_INFO "%s: Ring Status Change: New Status = %04x\n", dev->name, swab16(readw(xl_mmio + MMIO_MACDATA) )) ;
 
-                lan_status = ntohs(readw(xl_mmio + MMIO_MACDATA));
+                lan_status = swab16(readw(xl_mmio + MMIO_MACDATA));
         
                 /* Acknowledge interrupt, this tells nic we are done with the arb */
                 writel(ACK_INTERRUPT | ARBCACK | LATCH_ACK, xl_mmio + MMIO_COMMAND) ; 
@@ -1573,7 +1569,7 @@ static void xl_arb_cmd(struct net_device *dev)
                 printk(KERN_INFO "Received.Data \n") ; 
 #endif          
                 writel( ((MEM_WORD_READ | 0xD0000 | xl_priv->arb) + 6), xl_mmio + MMIO_MAC_ACCESS_CMD) ;
-                xl_priv->mac_buffer = ntohs(readw(xl_mmio + MMIO_MACDATA)) ;
+                xl_priv->mac_buffer = swab16(readw(xl_mmio + MMIO_MACDATA)) ;
                 
                 /* Now we are going to be really basic here and not do anything
                  * with the data at all. The tech docs do not give me enough
@@ -1634,7 +1630,7 @@ static void xl_asb_cmd(struct net_device *dev)
         writeb(0x81, xl_mmio + MMIO_MACDATA) ; 
 
         writel(MEM_WORD_WRITE | 0xd0000 | xl_priv->asb | 6, xl_mmio + MMIO_MAC_ACCESS_CMD) ; 
-        writew(ntohs(xl_priv->mac_buffer), xl_mmio + MMIO_MACDATA) ; 
+        writew(swab16(xl_priv->mac_buffer), xl_mmio + MMIO_MACDATA) ;
 
         xl_wait_misr_flags(dev) ;