X-Git-Url: https://git.rohieb.name/openwrt.git/blobdiff_plain/0955ccfcf3124640951de8ef3d1207da3a7cc2bc..18a076fccdba90cd7bea1dd4cff1b6b0559b75f0:/target/linux/ar71xx/files/drivers/net/ag71xx/ag71xx_main.c

diff --git a/target/linux/ar71xx/files/drivers/net/ag71xx/ag71xx_main.c b/target/linux/ar71xx/files/drivers/net/ag71xx/ag71xx_main.c
index 06a1f67d8..883489f26 100644
--- a/target/linux/ar71xx/files/drivers/net/ag71xx/ag71xx_main.c
+++ b/target/linux/ar71xx/files/drivers/net/ag71xx/ag71xx_main.c
@@ -14,14 +14,14 @@
 #include "ag71xx.h"
 
 #define AG71XX_DEFAULT_MSG_ENABLE	\
-	( NETIF_MSG_DRV 		\
+	(NETIF_MSG_DRV			\
 	| NETIF_MSG_PROBE		\
 	| NETIF_MSG_LINK		\
 	| NETIF_MSG_TIMER		\
 	| NETIF_MSG_IFDOWN		\
 	| NETIF_MSG_IFUP		\
 	| NETIF_MSG_RX_ERR		\
-	| NETIF_MSG_TX_ERR )
+	| NETIF_MSG_TX_ERR)
 
 static int ag71xx_msg_level = -1;
 
@@ -119,14 +119,15 @@ static int ag71xx_ring_alloc(struct ag71xx_ring *ring, unsigned int size)
 	}
 
 	for (i = 0; i < size; i++) {
-		ring->buf[i].desc = (struct ag71xx_desc *)&ring->descs_cpu[i * ring->desc_size];
+		int idx = i * ring->desc_size;
+		ring->buf[i].desc = (struct ag71xx_desc *)&ring->descs_cpu[idx];
 		DBG("ag71xx: ring %p, desc %d at %p\n",
 			ring, i, ring->buf[i].desc);
 	}
 
 	return 0;
 
- err:
+err:
 	return err;
 }
 
@@ -192,9 +193,28 @@ static void ag71xx_ring_rx_clean(struct ag71xx *ag)
 		}
 }
 
+static int ag71xx_rx_reserve(struct ag71xx *ag)
+{
+	int reserve = 0;
+
+	if (ag71xx_get_pdata(ag)->is_ar724x) {
+		if (!ag71xx_has_ar8216(ag))
+			reserve = 2;
+
+		if (ag->phy_dev)
+			reserve += 4 - (ag->phy_dev->pkt_align % 4);
+
+		reserve %= 4;
+	}
+
+	return reserve + AG71XX_RX_PKT_RESERVE;
+}
+
+
 static int ag71xx_ring_rx_init(struct ag71xx *ag)
 {
 	struct ag71xx_ring *ring = &ag->rx_ring;
+	unsigned int reserve = ag71xx_rx_reserve(ag);
 	unsigned int i;
 	int ret;
 
@@ -212,14 +232,14 @@ static int ag71xx_ring_rx_init(struct ag71xx *ag)
 		struct sk_buff *skb;
 		dma_addr_t dma_addr;
 
-		skb = dev_alloc_skb(AG71XX_RX_PKT_SIZE + AG71XX_RX_PKT_RESERVE);
+		skb = dev_alloc_skb(AG71XX_RX_PKT_SIZE + reserve);
 		if (!skb) {
 			ret = -ENOMEM;
 			break;
 		}
 
 		skb->dev = ag->dev;
-		skb_reserve(skb, AG71XX_RX_PKT_RESERVE);
+		skb_reserve(skb, reserve);
 
 		dma_addr = dma_map_single(&ag->dev->dev, skb->data,
 					  AG71XX_RX_PKT_SIZE,
@@ -242,6 +262,7 @@ static int ag71xx_ring_rx_init(struct ag71xx *ag)
 static int ag71xx_ring_rx_refill(struct ag71xx *ag)
 {
 	struct ag71xx_ring *ring = &ag->rx_ring;
+	unsigned int reserve = ag71xx_rx_reserve(ag);
 	unsigned int count;
 
 	count = 0;
@@ -254,12 +275,11 @@ static int ag71xx_ring_rx_refill(struct ag71xx *ag)
 			dma_addr_t dma_addr;
 			struct sk_buff *skb;
 
-			skb = dev_alloc_skb(AG71XX_RX_PKT_SIZE +
-					    AG71XX_RX_PKT_RESERVE);
+			skb = dev_alloc_skb(AG71XX_RX_PKT_SIZE + reserve);
 			if (skb == NULL)
 				break;
 
-			skb_reserve(skb, AG71XX_RX_PKT_RESERVE);
+			skb_reserve(skb, reserve);
 			skb->dev = ag->dev;
 
 			dma_addr = dma_map_single(&ag->dev->dev, skb->data,
@@ -415,12 +435,12 @@ static void ag71xx_hw_set_macaddr(struct ag71xx *ag, unsigned char *mac)
 {
 	u32 t;
 
-	t = (((u32) mac[0]) << 24) | (((u32) mac[1]) << 16)
-	  | (((u32) mac[2]) << 8) | ((u32) mac[3]);
+	t = (((u32) mac[5]) << 24) | (((u32) mac[4]) << 16)
+	  | (((u32) mac[3]) << 8) | ((u32) mac[2]);
 
 	ag71xx_wr(ag, AG71XX_REG_MAC_ADDR1, t);
 
-	t = (((u32) mac[4]) << 24) | (((u32) mac[5]) << 16);
+	t = (((u32) mac[1]) << 24) | (((u32) mac[0]) << 16);
 	ag71xx_wr(ag, AG71XX_REG_MAC_ADDR2, t);
 }
 
@@ -435,6 +455,12 @@ static void ag71xx_dma_reset(struct ag71xx *ag)
 	ag71xx_wr(ag, AG71XX_REG_RX_CTRL, 0);
 	ag71xx_wr(ag, AG71XX_REG_TX_CTRL, 0);
 
+	/*
+	 * give the hardware some time to really stop all rx/tx activity
+	 * clearing the descriptors too early causes random memory corruption
+	 */
+	mdelay(1);
+
 	/* clear descriptor addresses */
 	ag71xx_wr(ag, AG71XX_REG_TX_DESC, 0);
 	ag71xx_wr(ag, AG71XX_REG_RX_DESC, 0);
@@ -548,12 +574,16 @@ static void ag71xx_hw_stop(struct ag71xx *ag)
 static int ag71xx_open(struct net_device *dev)
 {
 	struct ag71xx *ag = netdev_priv(dev);
+	struct ag71xx_platform_data *pdata = ag71xx_get_pdata(ag);
 	int ret;
 
 	ret = ag71xx_rings_init(ag);
 	if (ret)
 		goto err;
 
+	if (pdata->is_ar724x)
+		ag71xx_hw_init(ag);
+
 	napi_enable(&ag->napi);
 
 	netif_carrier_off(dev);
@@ -570,7 +600,7 @@ static int ag71xx_open(struct net_device *dev)
 
 	return 0;
 
- err:
+err:
 	ag71xx_rings_cleanup(ag);
 	return ret;
 }
@@ -614,7 +644,8 @@ static netdev_tx_t ag71xx_hard_start_xmit(struct sk_buff *skb,
 	if (!ag71xx_desc_empty(desc))
 		goto err_drop;
 
-	ag71xx_add_ar8216_header(ag, skb);
+	if (ag71xx_has_ar8216(ag))
+		ag71xx_add_ar8216_header(ag, skb);
 
 	if (skb->len <= 0) {
 		DBG("%s: packet len is too small\n", ag->dev->name);
@@ -646,7 +677,7 @@ static netdev_tx_t ag71xx_hard_start_xmit(struct sk_buff *skb,
 
 	return NETDEV_TX_OK;
 
- err_drop:
+err_drop:
 	dev->stats.tx_dropped++;
 
 	dev_kfree_skb(skb);
@@ -655,7 +686,6 @@ static netdev_tx_t ag71xx_hard_start_xmit(struct sk_buff *skb,
 
 static int ag71xx_do_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
 {
-	struct mii_ioctl_data *data = (struct mii_ioctl_data *) &ifr->ifr_data;
 	struct ag71xx *ag = netdev_priv(dev);
 	int ret;
 
@@ -687,7 +717,7 @@ static int ag71xx_do_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
 		if (ag->phy_dev == NULL)
 			break;
 
-		return phy_mii_ioctl(ag->phy_dev, data, cmd);
+		return phy_mii_ioctl(ag->phy_dev, ifr, cmd);
 
 	default:
 		break;
@@ -772,6 +802,7 @@ static int ag71xx_rx_packets(struct ag71xx *ag, int limit)
 		struct ag71xx_desc *desc = ring->buf[i].desc;
 		struct sk_buff *skb;
 		int pktlen;
+		int err = 0;
 
 		if (ag71xx_desc_empty(desc))
 			break;
@@ -790,21 +821,26 @@ static int ag71xx_rx_packets(struct ag71xx *ag, int limit)
 		dma_unmap_single(&dev->dev, ring->buf[i].dma_addr,
 				 AG71XX_RX_PKT_SIZE, DMA_FROM_DEVICE);
 
-		skb_put(skb, pktlen);
-
-		skb->dev = dev;
-		skb->ip_summed = CHECKSUM_NONE;
-
 		dev->last_rx = jiffies;
 		dev->stats.rx_packets++;
 		dev->stats.rx_bytes += pktlen;
 
-		if (ag71xx_remove_ar8216_header(ag, skb) != 0) {
+		skb_put(skb, pktlen);
+		if (ag71xx_has_ar8216(ag))
+			err = ag71xx_remove_ar8216_header(ag, skb, pktlen);
+
+		if (err) {
 			dev->stats.rx_dropped++;
 			kfree_skb(skb);
 		} else {
-			skb->protocol = eth_type_trans(skb, dev);
-			netif_receive_skb(skb);
+			skb->dev = dev;
+			skb->ip_summed = CHECKSUM_NONE;
+			if (ag->phy_dev) {
+				ag->phy_dev->netif_receive_skb(skb);
+			} else {
+				skb->protocol = eth_type_trans(skb, dev);
+				netif_receive_skb(skb);
+			}
 		}
 
 		ring->buf[i].skb = NULL;
@@ -873,12 +909,12 @@ static int ag71xx_poll(struct napi_struct *napi, int limit)
 		return rx_done;
 	}
 
- more:
+more:
 	DBG("%s: stay in polling mode, rx=%d, tx=%d, limit=%d\n",
 			dev->name, rx_done, tx_done, limit);
 	return rx_done;
 
- oom:
+oom:
 	if (netif_msg_rx_err(ag))
 		printk(KERN_DEBUG "%s: out of memory\n", dev->name);
 
@@ -926,6 +962,20 @@ static void ag71xx_set_multicast_list(struct net_device *dev)
 	/* TODO */
 }
 
+#ifdef CONFIG_NET_POLL_CONTROLLER
+/*
+ * Polling 'interrupt' - used by things like netconsole to send skbs
+ * without having to re-enable interrupts. It's not called while
+ * the interrupt routine is executing.
+ */
+static void ag71xx_netpoll(struct net_device *dev)
+{
+	disable_irq(dev->irq);
+	ag71xx_interrupt(dev->irq, dev);
+	enable_irq(dev->irq);
+}
+#endif
+
 static const struct net_device_ops ag71xx_netdev_ops = {
 	.ndo_open		= ag71xx_open,
 	.ndo_stop		= ag71xx_stop,
@@ -936,9 +986,12 @@ static const struct net_device_ops ag71xx_netdev_ops = {
 	.ndo_change_mtu		= eth_change_mtu,
 	.ndo_set_mac_address	= eth_mac_addr,
 	.ndo_validate_addr	= eth_validate_addr,
+#ifdef CONFIG_NET_POLL_CONTROLLER
+	.ndo_poll_controller	= ag71xx_netpoll,
+#endif
 };
 
-static int __init ag71xx_probe(struct platform_device *pdev)
+static int __devinit ag71xx_probe(struct platform_device *pdev)
 {
 	struct net_device *dev;
 	struct resource *res;
@@ -1005,7 +1058,7 @@ static int __init ag71xx_probe(struct platform_device *pdev)
 
 	dev->irq = platform_get_irq(pdev, 0);
 	err = request_irq(dev->irq, ag71xx_interrupt,
-			  IRQF_DISABLED | IRQF_SAMPLE_RANDOM,
+			  IRQF_DISABLED,
 			  dev->name, dev);
 	if (err) {
 		dev_err(&pdev->dev, "unable to request IRQ %d\n", dev->irq);
@@ -1053,24 +1106,24 @@ static int __init ag71xx_probe(struct platform_device *pdev)
 
 	return 0;
 
- err_phy_disconnect:
+err_phy_disconnect:
 	ag71xx_phy_disconnect(ag);
- err_unregister_netdev:
+err_unregister_netdev:
 	unregister_netdev(dev);
- err_free_irq:
+err_free_irq:
 	free_irq(dev->irq, dev);
- err_unmap_mii_ctrl:
+err_unmap_mii_ctrl:
 	iounmap(ag->mii_ctrl);
- err_unmap_base:
+err_unmap_base:
 	iounmap(ag->mac_base);
- err_free_dev:
+err_free_dev:
 	kfree(dev);
- err_out:
+err_out:
 	platform_set_drvdata(pdev, NULL);
 	return err;
 }
 
-static int __exit ag71xx_remove(struct platform_device *pdev)
+static int __devexit ag71xx_remove(struct platform_device *pdev)
 {
 	struct net_device *dev = platform_get_drvdata(pdev);
 
@@ -1116,11 +1169,11 @@ static int __init ag71xx_module_init(void)
 
 	return 0;
 
- err_mdio_exit:
+err_mdio_exit:
 	ag71xx_mdio_driver_exit();
- err_debugfs_exit:
+err_debugfs_exit:
 	ag71xx_debugfs_root_exit();
- err_out:
+err_out:
 	return ret;
 }