X-Git-Url: http://git.rohieb.name/openwrt.git/blobdiff_plain/4aac3b42a23c57e7e4076ee7805432995025a278..d5a64cf57a973a10767c757ef283d3ad68075682:/target/linux/ar7/files/drivers/net/cpmac.c diff --git a/target/linux/ar7/files/drivers/net/cpmac.c b/target/linux/ar7/files/drivers/net/cpmac.c index 7d8e1b824..b575aa868 100644 --- a/target/linux/ar7/files/drivers/net/cpmac.c +++ b/target/linux/ar7/files/drivers/net/cpmac.c @@ -1,18 +1,16 @@ /* - * $Id$ - * * Copyright (C) 2006, 2007 OpenWrt.org - * + * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. - * + * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. - * + * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA @@ -23,7 +21,7 @@ #include #include -#include /* printk() */ +#include #include #include #include @@ -37,151 +35,151 @@ #include #include #include -#include -#include +#include +#include MODULE_AUTHOR("Eugene Konev"); MODULE_DESCRIPTION("TI AR7 ethernet driver (CPMAC)"); MODULE_LICENSE("GPL"); -static int rx_ring_size = 64; -static int disable_napi = 0; -module_param(rx_ring_size, int, 64); -module_param(disable_napi, int, 0); -MODULE_PARM_DESC(rx_ring_size, "Size of rx ring (in skbs)"); +static int disable_napi; +static int debug_level = 8; +static int dumb_switch; + +module_param(disable_napi, int, 0644); +/* Next 2 are only used in cpmac_probe, so it's pointless to change them */ +module_param(debug_level, int, 0444); +module_param(dumb_switch, int, 0444); + MODULE_PARM_DESC(disable_napi, "Disable NAPI polling"); +MODULE_PARM_DESC(debug_level, "Number of NETIF_MSG bits to enable"); +MODULE_PARM_DESC(dumb_switch, "Assume switch is not connected to MDIO bus"); + +/* stolen from net/ieee80211.h */ +#ifndef MAC_FMT +#define MAC_FMT "%02x:%02x:%02x:%02x:%02x:%02x" +#define MAC_ARG(x) ((u8*)(x))[0], ((u8*)(x))[1], ((u8*)(x))[2], \ + ((u8*)(x))[3], ((u8*)(x))[4], ((u8*)(x))[5] +#endif +/* frame size + 802.1q tag */ +#define CPMAC_SKB_SIZE (ETH_FRAME_LEN + 4) +#define CPMAC_TX_RING_SIZE 8 + +/* Ethernet registers */ +#define CPMAC_TX_CONTROL 0x0004 +#define CPMAC_TX_TEARDOWN 0x0008 +#define CPMAC_RX_CONTROL 0x0014 +#define CPMAC_RX_TEARDOWN 0x0018 +#define CPMAC_MBP 0x0100 +# define MBP_RXPASSCRC 0x40000000 +# define MBP_RXQOS 0x20000000 +# define MBP_RXNOCHAIN 0x10000000 +# define MBP_RXCMF 0x01000000 +# define MBP_RXSHORT 0x00800000 +# define MBP_RXCEF 0x00400000 +# define MBP_RXPROMISC 0x00200000 +# define MBP_PROMISCCHAN(channel) (((channel) & 0x7) << 16) +# define MBP_RXBCAST 0x00002000 +# define MBP_BCASTCHAN(channel) (((channel) & 0x7) << 8) +# define MBP_RXMCAST 0x00000020 +# define MBP_MCASTCHAN(channel) ((channel) & 0x7) +#define CPMAC_UNICAST_ENABLE 0x0104 +#define CPMAC_UNICAST_CLEAR 0x0108 +#define CPMAC_MAX_LENGTH 0x010c +#define CPMAC_BUFFER_OFFSET 0x0110 +#define CPMAC_MAC_CONTROL 0x0160 +# define MAC_TXPTYPE 0x00000200 +# define MAC_TXPACE 0x00000040 +# define MAC_MII 0x00000020 +# define MAC_TXFLOW 0x00000010 +# define MAC_RXFLOW 0x00000008 +# define MAC_MTEST 0x00000004 +# define MAC_LOOPBACK 0x00000002 +# define MAC_FDX 0x00000001 +#define CPMAC_MAC_STATUS 0x0164 +# define MAC_STATUS_QOS 0x00000004 +# define MAC_STATUS_RXFLOW 0x00000002 +# define MAC_STATUS_TXFLOW 0x00000001 +#define CPMAC_TX_INT_ENABLE 0x0178 +#define CPMAC_TX_INT_CLEAR 0x017c +#define CPMAC_MAC_INT_VECTOR 0x0180 +# define MAC_INT_STATUS 0x00080000 +# define MAC_INT_HOST 0x00040000 +# define MAC_INT_RX 0x00020000 +# define MAC_INT_TX 0x00010000 +#define CPMAC_MAC_EOI_VECTOR 0x0184 +#define CPMAC_RX_INT_ENABLE 0x0198 +#define CPMAC_RX_INT_CLEAR 0x019c +#define CPMAC_MAC_INT_ENABLE 0x01a8 +#define CPMAC_MAC_INT_CLEAR 0x01ac +#define CPMAC_MAC_ADDR_LO(channel) (0x01b0 + (channel) * 4) +#define CPMAC_MAC_ADDR_MID 0x01d0 +#define CPMAC_MAC_ADDR_HI 0x01d4 +#define CPMAC_MAC_HASH_LO 0x01d8 +#define CPMAC_MAC_HASH_HI 0x01dc +#define CPMAC_TX_PTR(channel) (0x0600 + (channel) * 4) +#define CPMAC_RX_PTR(channel) (0x0620 + (channel) * 4) +#define CPMAC_TX_ACK(channel) (0x0640 + (channel) * 4) +#define CPMAC_RX_ACK(channel) (0x0660 + (channel) * 4) +#define CPMAC_REG_END 0x0680 +/* + * Rx/Tx statistics + * TODO: use some of them to fill stats in cpmac_stats() + */ +#define CPMAC_STATS_RX_GOOD 0x0200 +#define CPMAC_STATS_RX_BCAST 0x0204 +#define CPMAC_STATS_RX_MCAST 0x0208 +#define CPMAC_STATS_RX_PAUSE 0x020c +#define CPMAC_STATS_RX_CRC 0x0210 +#define CPMAC_STATS_RX_ALIGN 0x0214 +#define CPMAC_STATS_RX_OVER 0x0218 +#define CPMAC_STATS_RX_JABBER 0x021c +#define CPMAC_STATS_RX_UNDER 0x0220 +#define CPMAC_STATS_RX_FRAG 0x0224 +#define CPMAC_STATS_RX_FILTER 0x0228 +#define CPMAC_STATS_RX_QOSFILTER 0x022c +#define CPMAC_STATS_RX_OCTETS 0x0230 + +#define CPMAC_STATS_TX_GOOD 0x0234 +#define CPMAC_STATS_TX_BCAST 0x0238 +#define CPMAC_STATS_TX_MCAST 0x023c +#define CPMAC_STATS_TX_PAUSE 0x0240 +#define CPMAC_STATS_TX_DEFER 0x0244 +#define CPMAC_STATS_TX_COLLISION 0x0248 +#define CPMAC_STATS_TX_SINGLECOLL 0x024c +#define CPMAC_STATS_TX_MULTICOLL 0x0250 +#define CPMAC_STATS_TX_EXCESSCOLL 0x0254 +#define CPMAC_STATS_TX_LATECOLL 0x0258 +#define CPMAC_STATS_TX_UNDERRUN 0x025c +#define CPMAC_STATS_TX_CARRIERSENSE 0x0260 +#define CPMAC_STATS_TX_OCTETS 0x0264 + +#define cpmac_read(base, reg) (readl((void __iomem *)(base) + (reg))) +#define cpmac_write(base, reg, val) (writel(val, (void __iomem *)(base) + \ + (reg))) + +/* MDIO bus */ +#define CPMAC_MDIO_VERSION 0x0000 +#define CPMAC_MDIO_CONTROL 0x0004 +# define MDIOC_IDLE 0x80000000 +# define MDIOC_ENABLE 0x40000000 +# define MDIOC_PREAMBLE 0x00100000 +# define MDIOC_FAULT 0x00080000 +# define MDIOC_FAULTDETECT 0x00040000 +# define MDIOC_INTTEST 0x00020000 +# define MDIOC_CLKDIV(div) ((div) & 0xff) +#define CPMAC_MDIO_ALIVE 0x0008 +#define CPMAC_MDIO_LINK 0x000c +#define CPMAC_MDIO_ACCESS(channel) (0x0080 + (channel) * 8) +# define MDIO_BUSY 0x80000000 +# define MDIO_WRITE 0x40000000 +# define MDIO_REG(reg) (((reg) & 0x1f) << 21) +# define MDIO_PHY(phy) (((phy) & 0x1f) << 16) +# define MDIO_DATA(data) ((data) & 0xffff) +#define CPMAC_MDIO_PHYSEL(channel) (0x0084 + (channel) * 8) +# define PHYSEL_LINKSEL 0x00000040 +# define PHYSEL_LINKINT 0x00000020 -/* Register definitions */ -struct cpmac_control_regs { - volatile u32 revision; - volatile u32 control; - volatile u32 teardown; - volatile u32 unused; -} __attribute__ ((packed)); - -struct cpmac_int_regs { - volatile u32 stat_raw; - volatile u32 stat_masked; - volatile u32 enable; - volatile u32 clear; -} __attribute__ ((packed)); - -struct cpmac_stats { - volatile u32 good; - volatile u32 bcast; - volatile u32 mcast; - volatile u32 pause; - volatile u32 crc_error; - volatile u32 align_error; - volatile u32 oversized; - volatile u32 jabber; - volatile u32 undersized; - volatile u32 fragment; - volatile u32 filtered; - volatile u32 qos_filtered; - volatile u32 octets; -} __attribute__ ((packed)); - -struct cpmac_regs { - struct cpmac_control_regs tx_ctrl; - struct cpmac_control_regs rx_ctrl; - volatile u32 unused1[56]; - volatile u32 mbp; -/* MBP bits */ -#define MBP_RXPASSCRC 0x40000000 -#define MBP_RXQOS 0x20000000 -#define MBP_RXNOCHAIN 0x10000000 -#define MBP_RXCMF 0x01000000 -#define MBP_RXSHORT 0x00800000 -#define MBP_RXCEF 0x00400000 -#define MBP_RXPROMISC 0x00200000 -#define MBP_PROMISCCHAN(chan) (((chan) & 0x7) << 16) -#define MBP_RXBCAST 0x00002000 -#define MBP_BCASTCHAN(chan) (((chan) & 0x7) << 8) -#define MBP_RXMCAST 0x00000020 -#define MBP_MCASTCHAN(chan) ((chan) & 0x7) - volatile u32 unicast_enable; - volatile u32 unicast_clear; - volatile u32 max_len; - volatile u32 buffer_offset; - volatile u32 filter_flow_threshold; - volatile u32 unused2[2]; - volatile u32 flow_thre[8]; - volatile u32 free_buffer[8]; - volatile u32 mac_control; -#define MAC_TXPTYPE 0x00000200 -#define MAC_TXPACE 0x00000040 -#define MAC_MII 0x00000020 -#define MAC_TXFLOW 0x00000010 -#define MAC_RXFLOW 0x00000008 -#define MAC_MTEST 0x00000004 -#define MAC_LOOPBACK 0x00000002 -#define MAC_FDX 0x00000001 - volatile u32 mac_status; -#define MACST_QOS 0x4 -#define MACST_RXFLOW 0x2 -#define MACST_TXFLOW 0x1 - volatile u32 emc_control; - volatile u32 unused3; - struct cpmac_int_regs tx_int; - volatile u32 mac_int_vector; -/* Int Status bits */ -#define INTST_STATUS 0x80000 -#define INTST_HOST 0x40000 -#define INTST_RX 0x20000 -#define INTST_TX 0x10000 - volatile u32 mac_eoi_vector; - volatile u32 unused4[2]; - struct cpmac_int_regs rx_int; - volatile u32 mac_int_stat_raw; - volatile u32 mac_int_stat_masked; - volatile u32 mac_int_enable; - volatile u32 mac_int_clear; - volatile u32 mac_addr_low[8]; - volatile u32 mac_addr_mid; - volatile u32 mac_addr_high; - volatile u32 mac_hash_low; - volatile u32 mac_hash_high; - volatile u32 boff_test; - volatile u32 pac_test; - volatile u32 rx_pause; - volatile u32 tx_pause; - volatile u32 unused5[2]; - struct cpmac_stats rx_stats; - struct cpmac_stats tx_stats; - volatile u32 unused6[232]; - volatile u32 tx_ptr[8]; - volatile u32 rx_ptr[8]; - volatile u32 tx_ack[8]; - volatile u32 rx_ack[8]; - -} __attribute__ ((packed)); - -struct cpmac_mdio_regs { - volatile u32 version; - volatile u32 control; -#define MDIOC_IDLE 0x80000000 -#define MDIOC_ENABLE 0x40000000 -#define MDIOC_PREAMBLE 0x00100000 -#define MDIOC_FAULT 0x00080000 -#define MDIOC_FAULTDETECT 0x00040000 -#define MDIOC_INTTEST 0x00020000 -#define MDIOC_CLKDIV(div) ((div) & 0xff) - volatile u32 alive; - volatile u32 link; - struct cpmac_int_regs link_int; - struct cpmac_int_regs user_int; - u32 unused[20]; - volatile u32 access; -#define MDIO_BUSY 0x80000000 -#define MDIO_WRITE 0x40000000 -#define MDIO_REG(reg) (((reg) & 0x1f) << 21) -#define MDIO_PHY(phy) (((phy) & 0x1f) << 16) -#define MDIO_DATA(data) ((data) & 0xffff) - volatile u32 physel; -} __attribute__ ((packed)); - -/* Descriptor */ struct cpmac_desc { u32 hw_next; u32 hw_data; @@ -189,32 +187,30 @@ struct cpmac_desc { u16 bufflags; u16 datalen; u16 dataflags; -/* Flags bits */ -#define CPMAC_SOP 0x8000 -#define CPMAC_EOP 0x4000 -#define CPMAC_OWN 0x2000 -#define CPMAC_EOQ 0x1000 +#define CPMAC_SOP 0x8000 +#define CPMAC_EOP 0x4000 +#define CPMAC_OWN 0x2000 +#define CPMAC_EOQ 0x1000 struct sk_buff *skb; struct cpmac_desc *next; -} __attribute__ ((packed)); + dma_addr_t mapping; + dma_addr_t data_mapping; +}; struct cpmac_priv { - struct net_device_stats stats; spinlock_t lock; - struct sk_buff *skb_pool; - int free_skbs; struct cpmac_desc *rx_head; int tx_head, tx_tail; + int ring_size; struct cpmac_desc *desc_ring; - struct cpmac_regs *regs; + dma_addr_t dma_ring; + void __iomem *regs; struct mii_bus *mii_bus; struct phy_device *phy; char phy_name[BUS_ID_SIZE]; - struct plat_cpmac_data *config; int oldlink, oldspeed, oldduplex; u32 msg_enable; - struct net_device *dev; - struct work_struct alloc_work; + struct platform_device *pdev; }; static irqreturn_t cpmac_irq(int, void *); @@ -223,70 +219,75 @@ static void cpmac_hw_init(struct net_device *dev); static int cpmac_stop(struct net_device *dev); static int cpmac_open(struct net_device *dev); -#undef CPMAC_DEBUG -#define CPMAC_LOW_THRESH 32 -#define CPMAC_ALLOC_SIZE 64 -#define CPMAC_SKB_SIZE 1518 -#define CPMAC_TX_RING_SIZE 8 - -#ifdef CPMAC_DEBUG -static void cpmac_dump_regs(u32 *base, int count) +static void cpmac_dump_regs(struct net_device *dev) { int i; - for (i = 0; i < (count + 3) / 4; i++) { - if (i % 4 == 0) printk("\nCPMAC[0x%04x]:", i * 4); - printk(" 0x%08x", *(base + i)); + struct cpmac_priv *priv = netdev_priv(dev); + for (i = 0; i < CPMAC_REG_END; i += 4) { + if (i % 16 == 0) { + if (i) + printk("\n"); + printk(KERN_DEBUG "%s: reg[%p]:", dev->name, + priv->regs + i); + } + printk(" %08x", cpmac_read(priv->regs, i)); } printk("\n"); } -static const char *cpmac_dump_buf(const uint8_t * buf, unsigned size) +static void cpmac_dump_desc(struct net_device *dev, struct cpmac_desc *desc) { - static char buffer[3 * 25 + 1]; - char *p = &buffer[0]; - if (size > 20) - size = 20; - while (size-- > 0) { - p += sprintf(p, " %02x", *buf++); - } - return buffer; + int i; + printk(KERN_DEBUG "%s: desc[%p]:", dev->name, desc); + for (i = 0; i < sizeof(*desc) / 4; i++) + printk(" %08x", ((u32 *)desc)[i]); + printk("\n"); } -#endif -static int cpmac_mdio_read(struct mii_bus *bus, int phy_id, int regnum) +static void cpmac_dump_skb(struct net_device *dev, struct sk_buff *skb) { - struct cpmac_mdio_regs *regs = (struct cpmac_mdio_regs *)bus->priv; - volatile u32 val; - - while ((val = regs->access) & MDIO_BUSY); - regs->access = MDIO_BUSY | MDIO_REG(regnum & 0x1f) | - MDIO_PHY(phy_id & 0x1f); - while ((val = regs->access) & MDIO_BUSY); - - return val & 0xffff; + int i; + printk(KERN_DEBUG "%s: skb 0x%p, len=%d\n", dev->name, skb, skb->len); + for (i = 0; i < skb->len; i++) { + if (i % 16 == 0) { + if (i) + printk("\n"); + printk(KERN_DEBUG "%s: data[%p]:", dev->name, + skb->data + i); + } + printk(" %02x", ((u8 *)skb->data)[i]); + } + printk("\n"); } -static int cpmac_mdio_write(struct mii_bus *bus, int phy_id, int regnum, u16 val) +static int cpmac_mdio_read(struct mii_bus *bus, int phy_id, int reg) { - struct cpmac_mdio_regs *regs = (struct cpmac_mdio_regs *)bus->priv; - volatile u32 tmp; - - while ((tmp = regs->access) & MDIO_BUSY); - regs->access = MDIO_BUSY | MDIO_WRITE | - MDIO_REG(regnum & 0x1f) | MDIO_PHY(phy_id & 0x1f) | - val; + u32 val; + + while (cpmac_read(bus->priv, CPMAC_MDIO_ACCESS(0)) & MDIO_BUSY) + cpu_relax(); + cpmac_write(bus->priv, CPMAC_MDIO_ACCESS(0), MDIO_BUSY | MDIO_REG(reg) | + MDIO_PHY(phy_id)); + while ((val = cpmac_read(bus->priv, CPMAC_MDIO_ACCESS(0))) & MDIO_BUSY) + cpu_relax(); + return MDIO_DATA(val); +} +static int cpmac_mdio_write(struct mii_bus *bus, int phy_id, + int reg, u16 val) +{ + while (cpmac_read(bus->priv, CPMAC_MDIO_ACCESS(0)) & MDIO_BUSY) + cpu_relax(); + cpmac_write(bus->priv, CPMAC_MDIO_ACCESS(0), MDIO_BUSY | MDIO_WRITE | + MDIO_REG(reg) | MDIO_PHY(phy_id) | MDIO_DATA(val)); return 0; } static int cpmac_mdio_reset(struct mii_bus *bus) { - struct cpmac_mdio_regs *regs = (struct cpmac_mdio_regs *)bus->priv; - ar7_device_reset(AR7_RESET_BIT_MDIO); - regs->control = MDIOC_ENABLE | - MDIOC_CLKDIV(ar7_cpmac_freq() / 2200000 - 1); - + cpmac_write(bus->priv, CPMAC_MDIO_CONTROL, MDIOC_ENABLE | + MDIOC_CLKDIV(ar7_cpmac_freq() / 2200000 - 1)); return 0; } @@ -313,134 +314,102 @@ static int cpmac_config(struct net_device *dev, struct ifmap *map) return 0; } -static int cpmac_set_mac_address(struct net_device *dev, void *addr) -{ - struct sockaddr *sa = addr; - - if (dev->flags & IFF_UP) - return -EBUSY; - - memcpy(dev->dev_addr, sa->sa_data, dev->addr_len); - - return 0; -} - static void cpmac_set_multicast_list(struct net_device *dev) { struct dev_mc_list *iter; int i; - int hash, tmp; - int hashlo = 0, hashhi = 0; + u8 tmp; + u32 mbp, bit, hash[2] = { 0, }; struct cpmac_priv *priv = netdev_priv(dev); - if(dev->flags & IFF_PROMISC) { - priv->regs->mbp &= ~MBP_PROMISCCHAN(0); /* promisc channel 0 */ - priv->regs->mbp |= MBP_RXPROMISC; + mbp = cpmac_read(priv->regs, CPMAC_MBP); + if (dev->flags & IFF_PROMISC) { + cpmac_write(priv->regs, CPMAC_MBP, (mbp & ~MBP_PROMISCCHAN(0)) | + MBP_RXPROMISC); } else { - priv->regs->mbp &= ~MBP_RXPROMISC; - if(dev->flags & IFF_ALLMULTI) { + cpmac_write(priv->regs, CPMAC_MBP, mbp & ~MBP_RXPROMISC); + if (dev->flags & IFF_ALLMULTI) { /* enable all multicast mode */ - priv->regs->mac_hash_low = 0xffffffff; - priv->regs->mac_hash_high = 0xffffffff; + cpmac_write(priv->regs, CPMAC_MAC_HASH_LO, 0xffffffff); + cpmac_write(priv->regs, CPMAC_MAC_HASH_HI, 0xffffffff); } else { - for(i = 0, iter = dev->mc_list; i < dev->mc_count; - i++, iter = iter->next) { - hash = 0; + /* + * cpmac uses some strange mac address hashing + * (not crc32) + */ + for (i = 0, iter = dev->mc_list; i < dev->mc_count; + i++, iter = iter->next) { + bit = 0; tmp = iter->dmi_addr[0]; - hash ^= (tmp >> 2) ^ (tmp << 4); + bit ^= (tmp >> 2) ^ (tmp << 4); tmp = iter->dmi_addr[1]; - hash ^= (tmp >> 4) ^ (tmp << 2); + bit ^= (tmp >> 4) ^ (tmp << 2); tmp = iter->dmi_addr[2]; - hash ^= (tmp >> 6) ^ tmp; + bit ^= (tmp >> 6) ^ tmp; + tmp = iter->dmi_addr[3]; + bit ^= (tmp >> 2) ^ (tmp << 4); tmp = iter->dmi_addr[4]; - hash ^= (tmp >> 2) ^ (tmp << 4); + bit ^= (tmp >> 4) ^ (tmp << 2); tmp = iter->dmi_addr[5]; - hash ^= (tmp >> 4) ^ (tmp << 2); - tmp = iter->dmi_addr[6]; - hash ^= (tmp >> 6) ^ tmp; - hash &= 0x3f; - if(hash < 32) { - hashlo |= 1<> 6) ^ tmp; + bit &= 0x3f; + hash[bit / 32] |= 1 << (bit % 32); } - priv->regs->mac_hash_low = hashlo; - priv->regs->mac_hash_high = hashhi; - } - } -} - -static struct sk_buff *cpmac_get_skb(struct net_device *dev) -{ - struct sk_buff *skb; - struct cpmac_priv *priv = netdev_priv(dev); - - skb = priv->skb_pool; - if (likely(skb)) { - priv->skb_pool = skb->next; - } else { - skb = dev_alloc_skb(CPMAC_SKB_SIZE + 2); - if (skb) { - skb->next = NULL; - skb_reserve(skb, 2); - skb->dev = priv->dev; + cpmac_write(priv->regs, CPMAC_MAC_HASH_LO, hash[0]); + cpmac_write(priv->regs, CPMAC_MAC_HASH_HI, hash[1]); } } - - if (likely(priv->free_skbs)) - priv->free_skbs--; - - if (priv->free_skbs < CPMAC_LOW_THRESH) - schedule_work(&priv->alloc_work); - - return skb; } -static inline struct sk_buff *cpmac_rx_one(struct net_device *dev, - struct cpmac_priv *priv, - struct cpmac_desc *desc) +static struct sk_buff *cpmac_rx_one(struct net_device *dev, + struct cpmac_priv *priv, + struct cpmac_desc *desc) { unsigned long flags; - char *data; struct sk_buff *skb, *result = NULL; - priv->regs->rx_ack[0] = virt_to_phys(desc); + if (unlikely(netif_msg_hw(priv))) + cpmac_dump_desc(dev, desc); + cpmac_write(priv->regs, CPMAC_RX_ACK(0), (u32)desc->mapping); if (unlikely(!desc->datalen)) { - if (printk_ratelimit()) + if (netif_msg_rx_err(priv) && net_ratelimit()) printk(KERN_WARNING "%s: rx: spurious interrupt\n", dev->name); - priv->stats.rx_errors++; return NULL; } + skb = netdev_alloc_skb(dev, CPMAC_SKB_SIZE); spin_lock_irqsave(&priv->lock, flags); - skb = cpmac_get_skb(dev); if (likely(skb)) { - data = (char *)phys_to_virt(desc->hw_data); - dma_cache_inv((u32)data, desc->datalen); + skb_reserve(skb, 2); skb_put(desc->skb, desc->datalen); desc->skb->protocol = eth_type_trans(desc->skb, dev); desc->skb->ip_summed = CHECKSUM_NONE; - priv->stats.rx_packets++; - priv->stats.rx_bytes += desc->datalen; + dev->stats.rx_packets++; + dev->stats.rx_bytes += desc->datalen; result = desc->skb; + dma_unmap_single(&dev->dev, desc->data_mapping, CPMAC_SKB_SIZE, + DMA_FROM_DEVICE); desc->skb = skb; + desc->data_mapping = dma_map_single(&dev->dev, skb->data, + CPMAC_SKB_SIZE, + DMA_FROM_DEVICE); + desc->hw_data = (u32)desc->data_mapping; + if (unlikely(netif_msg_pktdata(priv))) { + printk(KERN_DEBUG "%s: received packet:\n", dev->name); + cpmac_dump_skb(dev, result); + } } else { -#ifdef CPMAC_DEBUG - if (printk_ratelimit()) - printk("%s: low on skbs, dropping packet\n", - dev->name); -#endif - priv->stats.rx_dropped++; + if (netif_msg_rx_err(priv) && net_ratelimit()) + printk(KERN_WARNING + "%s: low on skbs, dropping packet\n", dev->name); + dev->stats.rx_dropped++; } spin_unlock_irqrestore(&priv->lock, flags); - desc->hw_data = virt_to_phys(desc->skb->data); desc->buflen = CPMAC_SKB_SIZE; desc->dataflags = CPMAC_OWN; - dma_cache_wback((u32)desc, 16); return result; } @@ -458,23 +427,16 @@ static void cpmac_rx(struct net_device *dev) } desc = priv->rx_head; - dma_cache_inv((u32)desc, 16); -#ifdef CPMAC_DEBUG - printk(KERN_DEBUG "%s: len=%d, %s\n", __func__, pkt->datalen, - cpmac_dump_buf(data, pkt->datalen)); -#endif while ((desc->dataflags & CPMAC_OWN) == 0) { skb = cpmac_rx_one(dev, priv, desc); - if (likely(skb)) { + if (likely(skb)) netif_rx(skb); - } desc = desc->next; - dma_cache_inv((u32)desc, 16); } priv->rx_head = desc; - priv->regs->rx_ptr[0] = virt_to_phys(desc); + cpmac_write(priv->regs, CPMAC_RX_PTR(0), (u32)desc->mapping); spin_unlock(&priv->lock); } @@ -486,7 +448,7 @@ static int cpmac_poll(struct net_device *dev, int *budget) struct cpmac_priv *priv = netdev_priv(dev); if (unlikely(!priv->rx_head)) { - if (printk_ratelimit()) + if (netif_msg_rx_err(priv) && net_ratelimit()) printk(KERN_WARNING "%s: rx: polling, but no queue\n", dev->name); netif_rx_complete(dev); @@ -494,8 +456,7 @@ static int cpmac_poll(struct net_device *dev, int *budget) } desc = priv->rx_head; - dma_cache_inv((u32)desc, 16); - + while ((received < quota) && ((desc->dataflags & CPMAC_OWN) == 0)) { skb = cpmac_rx_one(dev, priv, desc); if (likely(skb)) { @@ -503,119 +464,76 @@ static int cpmac_poll(struct net_device *dev, int *budget) received++; } desc = desc->next; - priv->rx_head = desc; - dma_cache_inv((u32)desc, 16); } + priv->rx_head = desc; *budget -= received; dev->quota -= received; -#ifdef CPMAC_DEBUG - printk("%s: processed %d packets\n", dev->name, received); -#endif + if (unlikely(netif_msg_rx_status(priv))) + printk(KERN_DEBUG "%s: poll processed %d packets\n", dev->name, + received); if (desc->dataflags & CPMAC_OWN) { - priv->regs->rx_ptr[0] = virt_to_phys(desc); netif_rx_complete(dev); - priv->regs->rx_int.enable = 0x1; - priv->regs->rx_int.clear = 0xfe; + cpmac_write(priv->regs, CPMAC_RX_PTR(0), (u32)desc->mapping); + cpmac_write(priv->regs, CPMAC_RX_INT_ENABLE, 1); return 0; } return 1; } -#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 20) -static void -cpmac_alloc_skbs(struct work_struct *work) -{ - struct cpmac_priv *priv = container_of(work, struct cpmac_priv, - alloc_work); -#else -static void -cpmac_alloc_skbs(void *data) -{ - struct net_device *dev = (struct net_device*)data; - struct cpmac_priv *priv = netdev_priv(dev); -#endif - unsigned long flags; - int i, num_skbs = 0; - struct sk_buff *skb, *skbs = NULL; - - for (i = 0; i < CPMAC_ALLOC_SIZE; i++) { - skb = alloc_skb(CPMAC_SKB_SIZE + 2, GFP_KERNEL); - if (!skb) - break; - skb->next = skbs; - skb_reserve(skb, 2); - skb->dev = priv->dev; - num_skbs++; - skbs = skb; - } - - if (skbs) { - spin_lock_irqsave(&priv->lock, flags); - for (skb = priv->skb_pool; skb && skb->next; skb = skb->next); - if (!skb) { - priv->skb_pool = skbs; - } else { - skb->next = skbs; - } - priv->free_skbs += num_skbs; - spin_unlock_irqrestore(&priv->lock, flags); -#ifdef CPMAC_DEBUG - printk("%s: allocated %d skbs\n", priv->dev->name, num_skbs); -#endif - } -} - static int cpmac_start_xmit(struct sk_buff *skb, struct net_device *dev) { unsigned long flags; - int len, chan; + int channel, len; struct cpmac_desc *desc; struct cpmac_priv *priv = netdev_priv(dev); - len = skb->len; -#ifdef CPMAC_DEBUG - printk(KERN_DEBUG "%s: len=%d\n", __func__, len); //cpmac_dump_buf(const uint8_t * buf, unsigned size) -#endif - if (unlikely(len < ETH_ZLEN)) { - if (unlikely(skb_padto(skb, ETH_ZLEN))) { - if (printk_ratelimit()) - printk(KERN_NOTICE "%s: padding failed, dropping\n", - dev->name); - spin_lock_irqsave(&priv->lock, flags); - priv->stats.tx_dropped++; - spin_unlock_irqrestore(&priv->lock, flags); - return -ENOMEM; - } - len = ETH_ZLEN; + if (unlikely(skb_padto(skb, ETH_ZLEN))) { + if (netif_msg_tx_err(priv) && net_ratelimit()) + printk(KERN_WARNING"%s: tx: padding failed, dropping\n", + dev->name); + spin_lock_irqsave(&priv->lock, flags); + dev->stats.tx_dropped++; + spin_unlock_irqrestore(&priv->lock, flags); + return -ENOMEM; } + + len = max(skb->len, ETH_ZLEN); spin_lock_irqsave(&priv->lock, flags); - chan = priv->tx_tail++; - priv->tx_tail %= 8; + channel = priv->tx_tail++; + priv->tx_tail %= CPMAC_TX_RING_SIZE; if (priv->tx_tail == priv->tx_head) netif_stop_queue(dev); - desc = &priv->desc_ring[chan]; - dma_cache_inv((u32)desc, 16); + desc = &priv->desc_ring[channel]; if (desc->dataflags & CPMAC_OWN) { - printk(KERN_NOTICE "%s: tx dma ring full, dropping\n", dev->name); - priv->stats.tx_dropped++; + if (netif_msg_tx_err(priv) && net_ratelimit()) + printk(KERN_WARNING "%s: tx dma ring full, dropping\n", + dev->name); + dev->stats.tx_dropped++; spin_unlock_irqrestore(&priv->lock, flags); + dev_kfree_skb_any(skb); return -ENOMEM; } dev->trans_start = jiffies; + spin_unlock_irqrestore(&priv->lock, flags); desc->dataflags = CPMAC_SOP | CPMAC_EOP | CPMAC_OWN; desc->skb = skb; - desc->hw_data = virt_to_phys(skb->data); - dma_cache_wback((u32)skb->data, len); - desc->buflen = len; + desc->data_mapping = dma_map_single(&dev->dev, skb->data, len, + DMA_TO_DEVICE); + desc->hw_data = (u32)desc->data_mapping; desc->datalen = len; - desc->hw_next = 0; - dma_cache_wback((u32)desc, 16); - priv->regs->tx_ptr[chan] = virt_to_phys(desc); - spin_unlock_irqrestore(&priv->lock, flags); + desc->buflen = len; + if (unlikely(netif_msg_tx_queued(priv))) + printk(KERN_DEBUG "%s: sending 0x%p, len=%d\n", dev->name, skb, + skb->len); + if (unlikely(netif_msg_hw(priv))) + cpmac_dump_desc(dev, desc); + if (unlikely(netif_msg_pktdata(priv))) + cpmac_dump_skb(dev, skb); + cpmac_write(priv->regs, CPMAC_TX_PTR(channel), (u32)desc->mapping); return 0; } @@ -627,18 +545,24 @@ static void cpmac_end_xmit(struct net_device *dev, int channel) spin_lock(&priv->lock); desc = &priv->desc_ring[channel]; - priv->regs->tx_ack[channel] = virt_to_phys(desc); + cpmac_write(priv->regs, CPMAC_TX_ACK(channel), (u32)desc->mapping); if (likely(desc->skb)) { - priv->stats.tx_packets++; - priv->stats.tx_bytes += desc->skb->len; + dev->stats.tx_packets++; + dev->stats.tx_bytes += desc->skb->len; + dma_unmap_single(&dev->dev, desc->data_mapping, desc->skb->len, + DMA_TO_DEVICE); + + if (unlikely(netif_msg_tx_done(priv))) + printk(KERN_DEBUG "%s: sent 0x%p, len=%d\n", dev->name, + desc->skb, desc->skb->len); + dev_kfree_skb_irq(desc->skb); if (netif_queue_stopped(dev)) netif_wake_queue(dev); - } else { - if (printk_ratelimit()) - printk(KERN_NOTICE "%s: end_xmit: spurious interrupt\n", - dev->name); - } + } else + if (netif_msg_tx_err(priv) && net_ratelimit()) + printk(KERN_WARNING + "%s: end_xmit: spurious interrupt\n", dev->name); spin_unlock(&priv->lock); } @@ -646,15 +570,19 @@ static void cpmac_reset(struct net_device *dev) { int i; struct cpmac_priv *priv = netdev_priv(dev); + struct plat_cpmac_data *pdata = priv->pdev->dev.platform_data; - ar7_device_reset(priv->config->reset_bit); - priv->regs->rx_ctrl.control &= ~1; - priv->regs->tx_ctrl.control &= ~1; + ar7_device_reset(pdata->reset_bit); + cpmac_write(priv->regs, CPMAC_RX_CONTROL, + cpmac_read(priv->regs, CPMAC_RX_CONTROL) & ~1); + cpmac_write(priv->regs, CPMAC_TX_CONTROL, + cpmac_read(priv->regs, CPMAC_TX_CONTROL) & ~1); for (i = 0; i < 8; i++) { - priv->regs->tx_ptr[i] = 0; - priv->regs->rx_ptr[i] = 0; + cpmac_write(priv->regs, CPMAC_TX_PTR(i), 0); + cpmac_write(priv->regs, CPMAC_RX_PTR(i), 0); } - priv->regs->mac_control &= ~MAC_MII; /* disable mii */ + cpmac_write(priv->regs, CPMAC_MAC_CONTROL, + cpmac_read(priv->regs, CPMAC_MAC_CONTROL) & ~MAC_MII); } static inline void cpmac_free_rx_ring(struct net_device *dev) @@ -667,51 +595,59 @@ static inline void cpmac_free_rx_ring(struct net_device *dev) return; desc = priv->rx_head; - dma_cache_inv((u32)desc, 16); - - for (i = 0; i < rx_ring_size; i++) { + + for (i = 0; i < priv->ring_size; i++) { desc->buflen = CPMAC_SKB_SIZE; if ((desc->dataflags & CPMAC_OWN) == 0) { + if (netif_msg_rx_err(priv) && net_ratelimit()) + printk(KERN_WARNING "%s: packet dropped\n", + dev->name); + if (unlikely(netif_msg_hw(priv))) + cpmac_dump_desc(dev, desc); desc->dataflags = CPMAC_OWN; - priv->stats.rx_dropped++; + dev->stats.rx_dropped++; } - dma_cache_wback((u32)desc, 16); desc = desc->next; - dma_cache_inv((u32)desc, 16); } } static irqreturn_t cpmac_irq(int irq, void *dev_id) { - struct net_device *dev = (struct net_device *)dev_id; - struct cpmac_priv *priv = netdev_priv(dev); + struct net_device *dev = dev_id; + struct cpmac_priv *priv; u32 status; if (!dev) return IRQ_NONE; - status = priv->regs->mac_int_vector; + priv = netdev_priv(dev); + + status = cpmac_read(priv->regs, CPMAC_MAC_INT_VECTOR); + + if (unlikely(netif_msg_intr(priv))) + printk(KERN_DEBUG "%s: interrupt status: 0x%08x\n", dev->name, + status); - if (status & INTST_TX) { + if (status & MAC_INT_TX) cpmac_end_xmit(dev, (status & 7)); - } - if (status & INTST_RX) { - if (disable_napi) { + if (status & MAC_INT_RX) { + if (disable_napi) cpmac_rx(dev); - } else { - priv->regs->rx_int.enable = 0; - priv->regs->rx_int.clear = 0xff; + else { + cpmac_write(priv->regs, CPMAC_RX_INT_CLEAR, 1); netif_rx_schedule(dev); } } - priv->regs->mac_eoi_vector = 0; + cpmac_write(priv->regs, CPMAC_MAC_EOI_VECTOR, 0); - if (unlikely(status & (INTST_HOST | INTST_STATUS))) { - if (printk_ratelimit()) { - printk(KERN_ERR "%s: hw error, resetting...\n", dev->name); - } + if (unlikely(status & (MAC_INT_HOST | MAC_INT_STATUS))) { + if (netif_msg_drv(priv) && net_ratelimit()) + printk(KERN_ERR "%s: hw error, resetting...\n", + dev->name); + if (unlikely(netif_msg_hw(priv))) + cpmac_dump_regs(dev); spin_lock(&priv->lock); phy_stop(priv->phy); cpmac_reset(dev); @@ -728,12 +664,13 @@ static void cpmac_tx_timeout(struct net_device *dev) struct cpmac_priv *priv = netdev_priv(dev); struct cpmac_desc *desc; - priv->stats.tx_errors++; + dev->stats.tx_errors++; desc = &priv->desc_ring[priv->tx_head++]; priv->tx_head %= 8; - printk("%s: transmit timeout\n", dev->name); + if (netif_msg_tx_err(priv) && net_ratelimit()) + printk(KERN_WARNING "%s: transmit timeout\n", dev->name); if (desc->skb) - dev_kfree_skb(desc->skb); + dev_kfree_skb_any(desc->skb); netif_wake_queue(dev); } @@ -744,7 +681,7 @@ static int cpmac_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd) return -EINVAL; if (!priv->phy) return -EINVAL; - if ((cmd == SIOCGMIIPHY) || (cmd == SIOCGMIIREG) || + if ((cmd == SIOCGMIIPHY) || (cmd == SIOCGMIIREG) || (cmd == SIOCSMIIREG)) return phy_mii_ioctl(priv->phy, if_mii(ifr), cmd); @@ -774,7 +711,32 @@ static int cpmac_set_settings(struct net_device *dev, struct ethtool_cmd *cmd) return -EINVAL; } -static void cpmac_get_drvinfo(struct net_device *dev, +static void cpmac_get_ringparam(struct net_device *dev, struct ethtool_ringparam* ring) +{ + struct cpmac_priv *priv = netdev_priv(dev); + + ring->rx_max_pending = 1024; + ring->rx_mini_max_pending = 1; + ring->rx_jumbo_max_pending = 1; + ring->tx_max_pending = 1; + + ring->rx_pending = priv->ring_size; + ring->rx_mini_pending = 1; + ring->rx_jumbo_pending = 1; + ring->tx_pending = 1; +} + +static int cpmac_set_ringparam(struct net_device *dev, struct ethtool_ringparam* ring) +{ + struct cpmac_priv *priv = netdev_priv(dev); + + if (dev->flags && IFF_UP) + return -EBUSY; + priv->ring_size = ring->rx_pending; + return 0; +} + +static void cpmac_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info) { strcpy(info->driver, "cpmac"); @@ -789,34 +751,10 @@ static const struct ethtool_ops cpmac_ethtool_ops = { .set_settings = cpmac_set_settings, .get_drvinfo = cpmac_get_drvinfo, .get_link = ethtool_op_get_link, + .get_ringparam = cpmac_get_ringparam, + .set_ringparam = cpmac_set_ringparam, }; -static struct net_device_stats *cpmac_stats(struct net_device *dev) -{ - struct cpmac_priv *priv = netdev_priv(dev); - - if (netif_device_present(dev)) - return &priv->stats; - - return NULL; -} - -static int cpmac_change_mtu(struct net_device *dev, int mtu) -{ - unsigned long flags; - struct cpmac_priv *priv = netdev_priv(dev); - spinlock_t *lock = &priv->lock; - - if ((mtu < 68) || (mtu > 1500)) - return -EINVAL; - - spin_lock_irqsave(lock, flags); - dev->mtu = mtu; - spin_unlock_irqrestore(lock, flags); - - return 0; -} - static void cpmac_adjust_link(struct net_device *dev) { struct cpmac_priv *priv = netdev_priv(dev); @@ -847,7 +785,7 @@ static void cpmac_adjust_link(struct net_device *dev) priv->oldduplex = -1; } - if (new_state) + if (new_state && netif_msg_link(priv) && net_ratelimit()) phy_print_status(priv->phy); spin_unlock_irqrestore(&priv->lock, flags); @@ -858,30 +796,38 @@ static void cpmac_hw_init(struct net_device *dev) int i; struct cpmac_priv *priv = netdev_priv(dev); - for (i = 0; i < 8; i++) - priv->regs->tx_ptr[i] = 0; - priv->regs->rx_ptr[0] = virt_to_phys(priv->rx_head); + for (i = 0; i < 8; i++) { + cpmac_write(priv->regs, CPMAC_TX_PTR(i), 0); + cpmac_write(priv->regs, CPMAC_RX_PTR(i), 0); + } + cpmac_write(priv->regs, CPMAC_RX_PTR(0), priv->rx_head->mapping); - priv->regs->mbp = MBP_RXSHORT | MBP_RXBCAST | MBP_RXMCAST; - priv->regs->unicast_enable = 0x1; - priv->regs->unicast_clear = 0xfe; - priv->regs->buffer_offset = 0; + cpmac_write(priv->regs, CPMAC_MBP, MBP_RXSHORT | MBP_RXBCAST | + MBP_RXMCAST); + cpmac_write(priv->regs, CPMAC_UNICAST_ENABLE, 1); + cpmac_write(priv->regs, CPMAC_UNICAST_CLEAR, 0xfe); + cpmac_write(priv->regs, CPMAC_BUFFER_OFFSET, 0); for (i = 0; i < 8; i++) - priv->regs->mac_addr_low[i] = dev->dev_addr[5]; - priv->regs->mac_addr_mid = dev->dev_addr[4]; - priv->regs->mac_addr_high = dev->dev_addr[0] | (dev->dev_addr[1] << 8) - | (dev->dev_addr[2] << 16) | (dev->dev_addr[3] << 24); - priv->regs->max_len = CPMAC_SKB_SIZE; - priv->regs->rx_int.enable = 0x1; - priv->regs->rx_int.clear = 0xfe; - priv->regs->tx_int.enable = 0xff; - priv->regs->tx_int.clear = 0; - priv->regs->mac_int_enable = 3; - priv->regs->mac_int_clear = 0xfc; - - priv->regs->rx_ctrl.control |= 1; - priv->regs->tx_ctrl.control |= 1; - priv->regs->mac_control |= MAC_MII | MAC_FDX; + cpmac_write(priv->regs, CPMAC_MAC_ADDR_LO(i), dev->dev_addr[5]); + cpmac_write(priv->regs, CPMAC_MAC_ADDR_MID, dev->dev_addr[4]); + cpmac_write(priv->regs, CPMAC_MAC_ADDR_HI, dev->dev_addr[0] | + (dev->dev_addr[1] << 8) | (dev->dev_addr[2] << 16) | + (dev->dev_addr[3] << 24)); + cpmac_write(priv->regs, CPMAC_MAX_LENGTH, CPMAC_SKB_SIZE); + cpmac_write(priv->regs, CPMAC_RX_INT_CLEAR, 0xff); + cpmac_write(priv->regs, CPMAC_TX_INT_CLEAR, 0xff); + cpmac_write(priv->regs, CPMAC_MAC_INT_CLEAR, 0xff); + cpmac_write(priv->regs, CPMAC_RX_INT_ENABLE, 1); + cpmac_write(priv->regs, CPMAC_TX_INT_ENABLE, 0xff); + cpmac_write(priv->regs, CPMAC_MAC_INT_ENABLE, 3); + + cpmac_write(priv->regs, CPMAC_RX_CONTROL, + cpmac_read(priv->regs, CPMAC_RX_CONTROL) | 1); + cpmac_write(priv->regs, CPMAC_TX_CONTROL, + cpmac_read(priv->regs, CPMAC_TX_CONTROL) | 1); + cpmac_write(priv->regs, CPMAC_MAC_CONTROL, + cpmac_read(priv->regs, CPMAC_MAC_CONTROL) | MAC_MII | + MAC_FDX); priv->phy->state = PHY_CHANGELINK; phy_start(priv->phy); @@ -891,78 +837,75 @@ static int cpmac_open(struct net_device *dev) { int i, size, res; struct cpmac_priv *priv = netdev_priv(dev); + struct resource *mem; struct cpmac_desc *desc; struct sk_buff *skb; -#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 20) priv->phy = phy_connect(dev, priv->phy_name, &cpmac_adjust_link, 0, PHY_INTERFACE_MODE_MII); -#else - priv->phy = phy_connect(dev, priv->phy_name, &cpmac_adjust_link, 0); -#endif if (IS_ERR(priv->phy)) { - printk(KERN_ERR "%s: Could not attach to PHY\n", dev->name); + if (netif_msg_drv(priv)) + printk(KERN_ERR "%s: Could not attach to PHY\n", + dev->name); return PTR_ERR(priv->phy); } - if (!request_mem_region(dev->mem_start, dev->mem_end - - dev->mem_start, dev->name)) { - printk("%s: failed to request registers\n", - dev->name); + mem = platform_get_resource_byname(priv->pdev, IORESOURCE_MEM, "regs"); + if (!request_mem_region(mem->start, mem->end - mem->start, dev->name)) { + if (netif_msg_drv(priv)) + printk(KERN_ERR "%s: failed to request registers\n", + dev->name); res = -ENXIO; goto fail_reserve; } - priv->regs = ioremap_nocache(dev->mem_start, dev->mem_end - - dev->mem_start); + priv->regs = ioremap(mem->start, mem->end - mem->start); if (!priv->regs) { - printk("%s: failed to remap registers\n", dev->name); + if (netif_msg_drv(priv)) + printk(KERN_ERR "%s: failed to remap registers\n", + dev->name); res = -ENXIO; goto fail_remap; } priv->rx_head = NULL; - size = sizeof(struct cpmac_desc) * (rx_ring_size + - CPMAC_TX_RING_SIZE); - priv->desc_ring = (struct cpmac_desc *)kmalloc(size, GFP_KERNEL); + size = priv->ring_size + CPMAC_TX_RING_SIZE; + priv->desc_ring = dma_alloc_coherent(&dev->dev, + sizeof(struct cpmac_desc) * size, + &priv->dma_ring, + GFP_KERNEL); if (!priv->desc_ring) { res = -ENOMEM; goto fail_alloc; } - memset((char *)priv->desc_ring, 0, size); - - priv->skb_pool = NULL; - priv->free_skbs = 0; priv->rx_head = &priv->desc_ring[CPMAC_TX_RING_SIZE]; + for (i = 0; i < size; i++) + priv->desc_ring[i].mapping = priv->dma_ring + sizeof(*desc) * i; -#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 20) - INIT_WORK(&priv->alloc_work, cpmac_alloc_skbs); -#else - INIT_WORK(&priv->alloc_work, cpmac_alloc_skbs, dev); -#endif - schedule_work(&priv->alloc_work); - flush_scheduled_work(); - - for (i = 0; i < rx_ring_size; i++) { - desc = &priv->rx_head[i]; - skb = cpmac_get_skb(dev); - if (!skb) { + for (i = 0, desc = &priv->rx_head[i]; i < priv->ring_size; i++, desc++) { + skb = netdev_alloc_skb(dev, CPMAC_SKB_SIZE); + if (unlikely(!skb)) { res = -ENOMEM; goto fail_desc; } + skb_reserve(skb, 2); desc->skb = skb; - desc->hw_data = virt_to_phys(skb->data); + desc->data_mapping = dma_map_single(&dev->dev, skb->data, + CPMAC_SKB_SIZE, + DMA_FROM_DEVICE); + desc->hw_data = (u32)desc->data_mapping; desc->buflen = CPMAC_SKB_SIZE; desc->dataflags = CPMAC_OWN; - desc->next = &priv->rx_head[(i + 1) % rx_ring_size]; - desc->hw_next = virt_to_phys(desc->next); - dma_cache_wback((u32)desc, 16); + desc->next = &priv->rx_head[(i + 1) % priv->ring_size]; + desc->hw_next = (u32)desc->next->mapping; } - if((res = request_irq(dev->irq, cpmac_irq, SA_INTERRUPT, - dev->name, dev))) { - printk("%s: failed to obtain irq\n", dev->name); + if ((res = request_irq(dev->irq, cpmac_irq, IRQF_SHARED, + dev->name, dev))) { + if (netif_msg_drv(priv)) + printk(KERN_ERR "%s: failed to obtain irq\n", + dev->name); goto fail_irq; } @@ -974,22 +917,21 @@ static int cpmac_open(struct net_device *dev) fail_irq: fail_desc: - for (i = 0; i < rx_ring_size; i++) - if (priv->rx_head[i].skb) + for (i = 0; i < priv->ring_size; i++) { + if (priv->rx_head[i].skb) { kfree_skb(priv->rx_head[i].skb); + dma_unmap_single(&dev->dev, + priv->rx_head[i].data_mapping, + CPMAC_SKB_SIZE, + DMA_FROM_DEVICE); + } + } fail_alloc: kfree(priv->desc_ring); - - for (skb = priv->skb_pool; skb; skb = priv->skb_pool) { - priv->skb_pool = skb->next; - kfree_skb(skb); - } - iounmap(priv->regs); fail_remap: - release_mem_region(dev->mem_start, dev->mem_end - - dev->mem_start); + release_mem_region(mem->start, mem->end - mem->start); fail_reserve: phy_disconnect(priv->phy); @@ -1000,8 +942,8 @@ fail_reserve: static int cpmac_stop(struct net_device *dev) { int i; - struct sk_buff *skb; struct cpmac_priv *priv = netdev_priv(dev); + struct resource *mem; netif_stop_queue(dev); @@ -1011,47 +953,42 @@ static int cpmac_stop(struct net_device *dev) cpmac_reset(dev); - for (i = 0; i < 8; i++) { - priv->regs->rx_ptr[i] = 0; - priv->regs->tx_ptr[i] = 0; - priv->regs->mbp = 0; - } + for (i = 0; i < 8; i++) + cpmac_write(priv->regs, CPMAC_TX_PTR(i), 0); + cpmac_write(priv->regs, CPMAC_RX_PTR(0), 0); + cpmac_write(priv->regs, CPMAC_MBP, 0); free_irq(dev->irq, dev); - release_mem_region(dev->mem_start, dev->mem_end - - dev->mem_start); - - cancel_delayed_work(&priv->alloc_work); - flush_scheduled_work(); - + iounmap(priv->regs); + mem = platform_get_resource_byname(priv->pdev, IORESOURCE_MEM, "regs"); + release_mem_region(mem->start, mem->end - mem->start); priv->rx_head = &priv->desc_ring[CPMAC_TX_RING_SIZE]; - for (i = 0; i < rx_ring_size; i++) - if (priv->rx_head[i].skb) + for (i = 0; i < priv->ring_size; i++) { + if (priv->rx_head[i].skb) { kfree_skb(priv->rx_head[i].skb); - - kfree(priv->desc_ring); - - for (skb = priv->skb_pool; skb; skb = priv->skb_pool) { - priv->skb_pool = skb->next; - kfree_skb(skb); + dma_unmap_single(&dev->dev, + priv->rx_head[i].data_mapping, + CPMAC_SKB_SIZE, + DMA_FROM_DEVICE); + } } + dma_free_coherent(&dev->dev, sizeof(struct cpmac_desc) * + (CPMAC_TX_RING_SIZE + priv->ring_size), + priv->desc_ring, priv->dma_ring); return 0; } -static int external_switch = 0; +static int external_switch; static int __devinit cpmac_probe(struct platform_device *pdev) { - int i, rc, phy_id; - struct resource *res; + int rc, phy_id; + struct resource *mem; struct cpmac_priv *priv; struct net_device *dev; struct plat_cpmac_data *pdata; - if (strcmp(pdev->name, "cpmac") != 0) - return -ENODEV; - pdata = pdev->dev.platform_data; for (phy_id = 0; phy_id < PHY_MAX_ADDR; phy_id++) { @@ -1063,10 +1000,10 @@ static int __devinit cpmac_probe(struct platform_device *pdev) } if (phy_id == PHY_MAX_ADDR) { - if (external_switch) { + if (external_switch || dumb_switch) phy_id = 0; - } else { - printk("cpmac: no PHY present\n"); + else { + printk(KERN_ERR "cpmac: no PHY present\n"); return -ENODEV; } } @@ -1074,69 +1011,59 @@ static int __devinit cpmac_probe(struct platform_device *pdev) dev = alloc_etherdev(sizeof(struct cpmac_priv)); if (!dev) { - printk(KERN_ERR "cpmac: Unable to allocate net_device structure!\n"); + printk(KERN_ERR "cpmac: Unable to allocate net_device\n"); return -ENOMEM; } - SET_MODULE_OWNER(dev); platform_set_drvdata(pdev, dev); priv = netdev_priv(dev); - res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "regs"); - if (!res) { - rc = -ENODEV; + priv->pdev = pdev; + mem = platform_get_resource_byname(pdev, IORESOURCE_MEM, "regs"); + if (!mem) { + rc = -ENODEV; goto fail; } - dev->mem_start = res->start; - dev->mem_end = res->end; dev->irq = platform_get_irq_byname(pdev, "irq"); - dev->mtu = 1500; dev->open = cpmac_open; dev->stop = cpmac_stop; dev->set_config = cpmac_config; dev->hard_start_xmit = cpmac_start_xmit; dev->do_ioctl = cpmac_ioctl; - dev->get_stats = cpmac_stats; - dev->change_mtu = cpmac_change_mtu; - dev->set_mac_address = cpmac_set_mac_address; dev->set_multicast_list = cpmac_set_multicast_list; dev->tx_timeout = cpmac_tx_timeout; dev->ethtool_ops = &cpmac_ethtool_ops; if (!disable_napi) { dev->poll = cpmac_poll; - dev->weight = min(rx_ring_size, 64); + dev->weight = 64; } - memset(priv, 0, sizeof(struct cpmac_priv)); spin_lock_init(&priv->lock); - priv->msg_enable = netif_msg_init(NETIF_MSG_WOL, 0x3fff); - priv->config = pdata; - priv->dev = dev; - memcpy(dev->dev_addr, priv->config->dev_addr, sizeof(dev->dev_addr)); + priv->msg_enable = netif_msg_init(debug_level, 0xff); + priv->ring_size = 64; + memcpy(dev->dev_addr, pdata->dev_addr, sizeof(dev->dev_addr)); if (phy_id == 31) { snprintf(priv->phy_name, BUS_ID_SIZE, PHY_ID_FMT, cpmac_mii.id, phy_id); - } else { +/* cpmac_write(cpmac_mii.priv, CPMAC_MDIO_PHYSEL(0), PHYSEL_LINKSEL + | PHYSEL_LINKINT | phy_id);*/ + } else snprintf(priv->phy_name, BUS_ID_SIZE, "fixed@%d:%d", 100, 1); - } if ((rc = register_netdev(dev))) { - printk("cpmac: error %i registering device %s\n", - rc, dev->name); + printk(KERN_ERR "cpmac: error %i registering device %s\n", rc, + dev->name); goto fail; } - printk("cpmac: device %s (regs: %p, irq: %d, phy: %s, mac: ", - dev->name, (u32 *)dev->mem_start, dev->irq, - priv->phy_name); - for (i = 0; i < 6; i++) { - printk("%02x", dev->dev_addr[i]); - if (i < 5) printk(":"); - else printk(")\n"); + if (netif_msg_probe(priv)) { + printk(KERN_INFO + "cpmac: device %s (regs: %p, irq: %d, phy: %s, mac: " + MAC_FMT ")\n", dev->name, (void *)mem->start, dev->irq, + priv->phy_name, MAC_ARG(dev->dev_addr)); } - return 0; fail: @@ -1155,18 +1082,18 @@ static int __devexit cpmac_remove(struct platform_device *pdev) static struct platform_driver cpmac_driver = { .driver.name = "cpmac", .probe = cpmac_probe, - .remove = cpmac_remove, + .remove = __devexit_p(cpmac_remove), }; int __devinit cpmac_init(void) { - volatile u32 mask; + u32 mask; int i, res; - cpmac_mii.priv = (struct cpmac_mdio_regs *) - ioremap_nocache(AR7_REGS_MDIO, sizeof(struct cpmac_mdio_regs)); + + cpmac_mii.priv = ioremap(AR7_REGS_MDIO, 256); if (!cpmac_mii.priv) { - printk("Can't ioremap mdio registers\n"); + printk(KERN_ERR "Can't ioremap mdio registers\n"); return -ENXIO; } @@ -1179,11 +1106,11 @@ int __devinit cpmac_init(void) cpmac_mii.reset(&cpmac_mii); - for (i = 0; i < 300000; i++) { - mask = ((struct cpmac_mdio_regs *)cpmac_mii.priv)->alive; - if (mask) + for (i = 0; i < 300000; i++) + if ((mask = cpmac_read(cpmac_mii.priv, CPMAC_MDIO_ALIVE))) break; - } + else + cpu_relax(); mask &= 0x7fffffff; if (mask & (mask - 1)) { @@ -1216,6 +1143,7 @@ void __devexit cpmac_exit(void) { platform_driver_unregister(&cpmac_driver); mdiobus_unregister(&cpmac_mii); + iounmap(cpmac_mii.priv); } module_init(cpmac_init);