/* * Ethernet driver for the Atmel AT91RM9200 (Thunder) * * Copyright (C) 2003 SAN People (Pty) Ltd * * Based on an earlier Atmel EMAC macrocell driver by Atmel and Lineo Inc. * Initial version by Rick Bronson 01/11/2003 * * Intel LXT971A PHY support by Christopher Bahns & David Knickerbocker * (Polaroid Corporation) * * Realtek RTL8201(B)L PHY support by Roman Avramenko * * 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. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "at91_ether.h" #include "macb.h" #define DRV_NAME "at91_ether" #define DRV_VERSION "1.0" #define LINK_POLL_INTERVAL (HZ) /* ........................... PHY INTERFACE ........................... */ /* * Enable the MDIO bit in MAC control register * When not called from an interrupt-handler, access to the PHY must be * protected by a spinlock. */ static void enable_mdi(struct at91_private *lp) { unsigned long ctl; ctl = macb_readl(lp, NCR); macb_writel(lp, NCR, ctl | MACB_BIT(MPE)); /* enable management port */ } /* * Disable the MDIO bit in the MAC control register */ static void disable_mdi(struct at91_private *lp) { unsigned long ctl; ctl = macb_readl(lp, NCR); macb_writel(lp, NCR, ctl & ~MACB_BIT(MPE)); /* disable management port */ } /* * Wait until the PHY operation is complete. */ static inline void at91_phy_wait(struct at91_private *lp) { unsigned long timeout = jiffies + 2; while (!(macb_readl(lp, NSR) & MACB_BIT(IDLE))) { if (time_after(jiffies, timeout)) { printk("at91_ether: MIO timeout\n"); break; } cpu_relax(); } } /* * Write value to the a PHY register * Note: MDI interface is assumed to already have been enabled. */ static void write_phy(struct at91_private *lp, unsigned char phy_addr, unsigned char address, unsigned int value) { macb_writel(lp, MAN, MACB_BF(SOF, MACB_MAN_SOF) | MACB_BF(CODE, MACB_MAN_CODE) | MACB_BF(RW, MACB_MAN_WRITE) | ((phy_addr & 0x1f) << 23) | (address << 18) | (value & ((1<mii)) { /* no link */ netif_carrier_off(dev); if (!silent) printk(KERN_INFO "%s: Link down.\n", dev->name); return; } /* Link up, or auto-negotiation still in progress */ read_phy(lp, lp->phy_address, MII_BMSR, &bmsr); read_phy(lp, lp->phy_address, MII_BMCR, &bmcr); if (bmcr & BMCR_ANENABLE) { /* AutoNegotiation is enabled */ if (!(bmsr & BMSR_ANEGCOMPLETE)) return; /* Do nothing - another interrupt generated when negotiation complete */ read_phy(lp, lp->phy_address, MII_LPA, &lpa); if ((lpa & LPA_100FULL) || (lpa & LPA_100HALF)) speed = SPEED_100; else speed = SPEED_10; if ((lpa & LPA_100FULL) || (lpa & LPA_10FULL)) duplex = DUPLEX_FULL; else duplex = DUPLEX_HALF; } else { speed = (bmcr & BMCR_SPEED100) ? SPEED_100 : SPEED_10; duplex = (bmcr & BMCR_FULLDPLX) ? DUPLEX_FULL : DUPLEX_HALF; } /* Update the MAC */ mac_cfg = macb_readl(lp, NCFGR) & ~(MACB_BIT(SPD) | MACB_BIT(FD)); if (speed == SPEED_100) { if (duplex == DUPLEX_FULL) /* 100 Full Duplex */ mac_cfg |= MACB_BIT(SPD) | MACB_BIT(FD); else /* 100 Half Duplex */ mac_cfg |= MACB_BIT(SPD); } else { if (duplex == DUPLEX_FULL) /* 10 Full Duplex */ mac_cfg |= MACB_BIT(FD); else {} /* 10 Half Duplex */ } macb_writel(lp, NCFGR, mac_cfg); if (!silent) printk(KERN_INFO "%s: Link now %i-%s\n", dev->name, speed, (duplex == DUPLEX_FULL) ? "FullDuplex" : "HalfDuplex"); netif_carrier_on(dev); } /* * Handle interrupts from the PHY */ static irqreturn_t at91ether_phy_interrupt(int irq, void *dev_id) { struct net_device *dev = (struct net_device *) dev_id; struct at91_private *lp = netdev_priv(dev); unsigned int phy; /* * This hander is triggered on both edges, but the PHY chips expect * level-triggering. We therefore have to check if the PHY actually has * an IRQ pending. */ enable_mdi(lp); if ((lp->phy_type == MII_DM9161_ID) || (lp->phy_type == MII_DM9161A_ID)) { read_phy(lp, lp->phy_address, MII_DSINTR_REG, &phy); /* ack interrupt in Davicom PHY */ if (!(phy & (1 << 0))) goto done; } else if (lp->phy_type == MII_LXT971A_ID) { read_phy(lp, lp->phy_address, MII_ISINTS_REG, &phy); /* ack interrupt in Intel PHY */ if (!(phy & (1 << 2))) goto done; } else if (lp->phy_type == MII_BCM5221_ID) { read_phy(lp, lp->phy_address, MII_BCMINTR_REG, &phy); /* ack interrupt in Broadcom PHY */ if (!(phy & (1 << 0))) goto done; } else if (lp->phy_type == MII_KS8721_ID) { read_phy(lp, lp->phy_address, MII_TPISTATUS, &phy); /* ack interrupt in Micrel PHY */ if (!(phy & ((1 << 2) | 1))) goto done; } else if (lp->phy_type == MII_T78Q21x3_ID) { /* ack interrupt in Teridian PHY */ read_phy(lp, lp->phy_address, MII_T78Q21INT_REG, &phy); if (!(phy & ((1 << 2) | 1))) goto done; } else if (lp->phy_type == MII_DP83848_ID) { read_phy(lp, lp->phy_address, MII_DPPHYSTS_REG, &phy); /* ack interrupt in DP83848 PHY */ if (!(phy & (1 << 7))) goto done; } update_linkspeed(dev, 0); done: disable_mdi(lp); return IRQ_HANDLED; } /* * Initialize and enable the PHY interrupt for link-state changes */ static void enable_phyirq(struct net_device *dev) { struct at91_private *lp = netdev_priv(dev); unsigned int dsintr, irq_number; int status; if (!gpio_is_valid(lp->board_data.phy_irq_pin)) { /* * PHY doesn't have an IRQ pin (RTL8201, DP83847, AC101L), * or board does not have it connected. */ mod_timer(&lp->check_timer, jiffies + LINK_POLL_INTERVAL); return; } irq_number = gpio_to_irq(lp->board_data.phy_irq_pin); status = request_irq(irq_number, at91ether_phy_interrupt, 0, dev->name, dev); if (status) { printk(KERN_ERR "at91_ether: PHY IRQ %d request failed - status %d!\n", irq_number, status); return; } spin_lock_irq(&lp->lock); enable_mdi(lp); if ((lp->phy_type == MII_DM9161_ID) || (lp->phy_type == MII_DM9161A_ID)) { /* for Davicom PHY */ read_phy(lp, lp->phy_address, MII_DSINTR_REG, &dsintr); dsintr = dsintr & ~0xf00; /* clear bits 8..11 */ write_phy(lp, lp->phy_address, MII_DSINTR_REG, dsintr); } else if (lp->phy_type == MII_LXT971A_ID) { /* for Intel PHY */ read_phy(lp, lp->phy_address, MII_ISINTE_REG, &dsintr); dsintr = dsintr | 0xf2; /* set bits 1, 4..7 */ write_phy(lp, lp->phy_address, MII_ISINTE_REG, dsintr); } else if (lp->phy_type == MII_BCM5221_ID) { /* for Broadcom PHY */ dsintr = (1 << 15) | ( 1 << 14); write_phy(lp, lp->phy_address, MII_BCMINTR_REG, dsintr); } else if (lp->phy_type == MII_KS8721_ID) { /* for Micrel PHY */ dsintr = (1 << 10) | ( 1 << 8); write_phy(lp, lp->phy_address, MII_TPISTATUS, dsintr); } else if (lp->phy_type == MII_T78Q21x3_ID) { /* for Teridian PHY */ read_phy(lp, lp->phy_address, MII_T78Q21INT_REG, &dsintr); dsintr = dsintr | 0x500; /* set bits 8, 10 */ write_phy(lp, lp->phy_address, MII_T78Q21INT_REG, dsintr); } else if (lp->phy_type == MII_DP83848_ID) { /* National Semiconductor DP83848 PHY */ read_phy(lp, lp->phy_address, MII_DPMISR_REG, &dsintr); dsintr = dsintr | 0x3c; /* set bits 2..5 */ write_phy(lp, lp->phy_address, MII_DPMISR_REG, dsintr); read_phy(lp, lp->phy_address, MII_DPMICR_REG, &dsintr); dsintr = dsintr | 0x3; /* set bits 0,1 */ write_phy(lp, lp->phy_address, MII_DPMICR_REG, dsintr); } disable_mdi(lp); spin_unlock_irq(&lp->lock); } /* * Disable the PHY interrupt */ static void disable_phyirq(struct net_device *dev) { struct at91_private *lp = netdev_priv(dev); unsigned int dsintr; unsigned int irq_number; if (!gpio_is_valid(lp->board_data.phy_irq_pin)) { del_timer_sync(&lp->check_timer); return; } spin_lock_irq(&lp->lock); enable_mdi(lp); if ((lp->phy_type == MII_DM9161_ID) || (lp->phy_type == MII_DM9161A_ID)) { /* for Davicom PHY */ read_phy(lp, lp->phy_address, MII_DSINTR_REG, &dsintr); dsintr = dsintr | 0xf00; /* set bits 8..11 */ write_phy(lp, lp->phy_address, MII_DSINTR_REG, dsintr); } else if (lp->phy_type == MII_LXT971A_ID) { /* for Intel PHY */ read_phy(lp, lp->phy_address, MII_ISINTE_REG, &dsintr); dsintr = dsintr & ~0xf2; /* clear bits 1, 4..7 */ write_phy(lp, lp->phy_address, MII_ISINTE_REG, dsintr); } else if (lp->phy_type == MII_BCM5221_ID) { /* for Broadcom PHY */ read_phy(lp, lp->phy_address, MII_BCMINTR_REG, &dsintr); dsintr = ~(1 << 14); write_phy(lp, lp->phy_address, MII_BCMINTR_REG, dsintr); } else if (lp->phy_type == MII_KS8721_ID) { /* for Micrel PHY */ read_phy(lp, lp->phy_address, MII_TPISTATUS, &dsintr); dsintr = ~((1 << 10) | (1 << 8)); write_phy(lp, lp->phy_address, MII_TPISTATUS, dsintr); } else if (lp->phy_type == MII_T78Q21x3_ID) { /* for Teridian PHY */ read_phy(lp, lp->phy_address, MII_T78Q21INT_REG, &dsintr); dsintr = dsintr & ~0x500; /* clear bits 8, 10 */ write_phy(lp, lp->phy_address, MII_T78Q21INT_REG, dsintr); } else if (lp->phy_type == MII_DP83848_ID) { /* National Semiconductor DP83848 PHY */ read_phy(lp, lp->phy_address, MII_DPMICR_REG, &dsintr); dsintr = dsintr & ~0x3; /* clear bits 0, 1 */ write_phy(lp, lp->phy_address, MII_DPMICR_REG, dsintr); read_phy(lp, lp->phy_address, MII_DPMISR_REG, &dsintr); dsintr = dsintr & ~0x3c; /* clear bits 2..5 */ write_phy(lp, lp->phy_address, MII_DPMISR_REG, dsintr); } disable_mdi(lp); spin_unlock_irq(&lp->lock); irq_number = gpio_to_irq(lp->board_data.phy_irq_pin); free_irq(irq_number, dev); /* Free interrupt handler */ } /* * Perform a software reset of the PHY. */ #if 0 static void reset_phy(struct net_device *dev) { struct at91_private *lp = netdev_priv(dev); unsigned int bmcr; spin_lock_irq(&lp->lock); enable_mdi(lp); /* Perform PHY reset */ write_phy(lp, lp->phy_address, MII_BMCR, BMCR_RESET); /* Wait until PHY reset is complete */ do { read_phy(lp, lp->phy_address, MII_BMCR, &bmcr); } while (!(bmcr & BMCR_RESET)); disable_mdi(lp); spin_unlock_irq(&lp->lock); } #endif static void at91ether_check_link(unsigned long dev_id) { struct net_device *dev = (struct net_device *) dev_id; struct at91_private *lp = netdev_priv(dev); enable_mdi(lp); update_linkspeed(dev, 1); disable_mdi(lp); mod_timer(&lp->check_timer, jiffies + LINK_POLL_INTERVAL); } /* * Perform any PHY-specific initialization. */ static void __init initialize_phy(struct at91_private *lp) { unsigned int val; spin_lock_irq(&lp->lock); enable_mdi(lp); if ((lp->phy_type == MII_DM9161_ID) || (lp->phy_type == MII_DM9161A_ID)) { read_phy(lp, lp->phy_address, MII_DSCR_REG, &val); if ((val & (1 << 10)) == 0) /* DSCR bit 10 is 0 -- fiber mode */ lp->phy_media = PORT_FIBRE; } else if (machine_is_csb337()) { /* mix link activity status into LED2 link state */ write_phy(lp, lp->phy_address, MII_LEDCTRL_REG, 0x0d22); } else if (machine_is_ecbat91()) write_phy(lp, lp->phy_address, MII_LEDCTRL_REG, 0x156A); disable_mdi(lp); spin_unlock_irq(&lp->lock); } /* ......................... ADDRESS MANAGEMENT ........................ */ /* * NOTE: Your bootloader must always set the MAC address correctly before * booting into Linux. * * - It must always set the MAC address after reset, even if it doesn't * happen to access the Ethernet while it's booting. Some versions of * U-Boot on the AT91RM9200-DK do not do this. * * - Likewise it must store the addresses in the correct byte order. * MicroMonitor (uMon) on the CSB337 does this incorrectly (and * continues to do so, for bug-compatibility). */ static short __init unpack_mac_address(struct net_device *dev, unsigned int hi, unsigned int lo) { char addr[6]; if (machine_is_csb337()) { addr[5] = (lo & 0xff); /* The CSB337 bootloader stores the MAC the wrong-way around */ addr[4] = (lo & 0xff00) >> 8; addr[3] = (lo & 0xff0000) >> 16; addr[2] = (lo & 0xff000000) >> 24; addr[1] = (hi & 0xff); addr[0] = (hi & 0xff00) >> 8; } else { addr[0] = (lo & 0xff); addr[1] = (lo & 0xff00) >> 8; addr[2] = (lo & 0xff0000) >> 16; addr[3] = (lo & 0xff000000) >> 24; addr[4] = (hi & 0xff); addr[5] = (hi & 0xff00) >> 8; } if (is_valid_ether_addr(addr)) { memcpy(dev->dev_addr, &addr, 6); return 1; } return 0; } /* * Set the ethernet MAC address in dev->dev_addr */ static void __init get_mac_address(struct net_device *dev) { struct at91_private *lp = netdev_priv(dev); /* Check Specific-Address 1 */ if (unpack_mac_address(dev, macb_readl(lp, SA1T), macb_readl(lp, SA1B))) return; /* Check Specific-Address 2 */ if (unpack_mac_address(dev, macb_readl(lp, SA2T), macb_readl(lp, SA2B))) return; /* Check Specific-Address 3 */ if (unpack_mac_address(dev, macb_readl(lp, SA3T), macb_readl(lp, SA3B))) return; /* Check Specific-Address 4 */ if (unpack_mac_address(dev, macb_readl(lp, SA4T), macb_readl(lp, SA4B))) return; printk(KERN_ERR "at91_ether: Your bootloader did not configure a MAC address.\n"); } /* * Program the hardware MAC address from dev->dev_addr. */ static void update_mac_address(struct net_device *dev) { struct at91_private *lp = netdev_priv(dev); macb_writel(lp, SA1B, (dev->dev_addr[3] << 24) | (dev->dev_addr[2] << 16) | (dev->dev_addr[1] << 8) | (dev->dev_addr[0])); macb_writel(lp, SA1T, (dev->dev_addr[5] << 8) | (dev->dev_addr[4])); macb_writel(lp, SA2B, 0); macb_writel(lp, SA2T, 0); } /* * Store the new hardware address in dev->dev_addr, and update the MAC. */ static int set_mac_address(struct net_device *dev, void* addr) { struct sockaddr *address = addr; if (!is_valid_ether_addr(address->sa_data)) return -EADDRNOTAVAIL; memcpy(dev->dev_addr, address->sa_data, dev->addr_len); update_mac_address(dev); printk("%s: Setting MAC address to %pM\n", dev->name, dev->dev_addr); return 0; } static int inline hash_bit_value(int bitnr, __u8 *addr) { if (addr[bitnr / 8] & (1 << (bitnr % 8))) return 1; return 0; } /* * The hash address register is 64 bits long and takes up two locations in the memory map. * The least significant bits are stored in EMAC_HSL and the most significant * bits in EMAC_HSH. * * The unicast hash enable and the multicast hash enable bits in the network configuration * register enable the reception of hash matched frames. The destination address is * reduced to a 6 bit index into the 64 bit hash register using the following hash function. * The hash function is an exclusive or of every sixth bit of the destination address. * hash_index[5] = da[5] ^ da[11] ^ da[17] ^ da[23] ^ da[29] ^ da[35] ^ da[41] ^ da[47] * hash_index[4] = da[4] ^ da[10] ^ da[16] ^ da[22] ^ da[28] ^ da[34] ^ da[40] ^ da[46] * hash_index[3] = da[3] ^ da[09] ^ da[15] ^ da[21] ^ da[27] ^ da[33] ^ da[39] ^ da[45] * hash_index[2] = da[2] ^ da[08] ^ da[14] ^ da[20] ^ da[26] ^ da[32] ^ da[38] ^ da[44] * hash_index[1] = da[1] ^ da[07] ^ da[13] ^ da[19] ^ da[25] ^ da[31] ^ da[37] ^ da[43] * hash_index[0] = da[0] ^ da[06] ^ da[12] ^ da[18] ^ da[24] ^ da[30] ^ da[36] ^ da[42] * da[0] represents the least significant bit of the first byte received, that is, the multicast/ * unicast indicator, and da[47] represents the most significant bit of the last byte * received. * If the hash index points to a bit that is set in the hash register then the frame will be * matched according to whether the frame is multicast or unicast. * A multicast match will be signalled if the multicast hash enable bit is set, da[0] is 1 and * the hash index points to a bit set in the hash register. * A unicast match will be signalled if the unicast hash enable bit is set, da[0] is 0 and the * hash index points to a bit set in the hash register. * To receive all multicast frames, the hash register should be set with all ones and the * multicast hash enable bit should be set in the network configuration register. */ /* * Return the hash index value for the specified address. */ static int hash_get_index(__u8 *addr) { int i, j, bitval; int hash_index = 0; for (j = 0; j < 6; j++) { for (i = 0, bitval = 0; i < 8; i++) bitval ^= hash_bit_value(i*6 + j, addr); hash_index |= (bitval << j); } return hash_index; } /* * Add multicast addresses to the internal multicast-hash table. */ static void at91ether_sethashtable(struct net_device *dev) { struct at91_private *lp = netdev_priv(dev); struct netdev_hw_addr *ha; unsigned long mc_filter[2]; unsigned int bitnr; mc_filter[0] = mc_filter[1] = 0; netdev_for_each_mc_addr(ha, dev) { bitnr = hash_get_index(ha->addr); mc_filter[bitnr >> 5] |= 1 << (bitnr & 31); } macb_writel(lp, HRB, mc_filter[0]); macb_writel(lp, HRT, mc_filter[1]); } /* * Enable/Disable promiscuous and multicast modes. */ static void at91ether_set_multicast_list(struct net_device *dev) { struct at91_private *lp = netdev_priv(dev); unsigned long cfg; cfg = macb_readl(lp, NCFGR); if (dev->flags & IFF_PROMISC) /* Enable promiscuous mode */ cfg |= MACB_BIT(CAF); else if (dev->flags & (~IFF_PROMISC)) /* Disable promiscuous mode */ cfg &= ~MACB_BIT(CAF); if (dev->flags & IFF_ALLMULTI) { /* Enable all multicast mode */ macb_writel(lp, HRT, -1); macb_writel(lp, HRB, -1); cfg |= MACB_BIT(NCFGR_MTI); } else if (!netdev_mc_empty(dev)) { /* Enable specific multicasts */ at91ether_sethashtable(dev); cfg |= MACB_BIT(NCFGR_MTI); } else if (dev->flags & (~IFF_ALLMULTI)) { /* Disable all multicast mode */ macb_writel(lp, HRT, 0); macb_writel(lp, HRB, 0); cfg &= ~MACB_BIT(NCFGR_MTI); } macb_writel(lp, NCFGR, cfg); } /* ......................... ETHTOOL SUPPORT ........................... */ static int mdio_read(struct net_device *dev, int phy_id, int location) { struct at91_private *lp = netdev_priv(dev); unsigned int value; read_phy(lp, phy_id, location, &value); return value; } static void mdio_write(struct net_device *dev, int phy_id, int location, int value) { struct at91_private *lp = netdev_priv(dev); write_phy(lp, phy_id, location, value); } static int at91ether_get_settings(struct net_device *dev, struct ethtool_cmd *cmd) { struct at91_private *lp = netdev_priv(dev); int ret; spin_lock_irq(&lp->lock); enable_mdi(lp); ret = mii_ethtool_gset(&lp->mii, cmd); disable_mdi(lp); spin_unlock_irq(&lp->lock); if (lp->phy_media == PORT_FIBRE) { /* override media type since mii.c doesn't know */ cmd->supported = SUPPORTED_FIBRE; cmd->port = PORT_FIBRE; } return ret; } static int at91ether_set_settings(struct net_device *dev, struct ethtool_cmd *cmd) { struct at91_private *lp = netdev_priv(dev); int ret; spin_lock_irq(&lp->lock); enable_mdi(lp); ret = mii_ethtool_sset(&lp->mii, cmd); disable_mdi(lp); spin_unlock_irq(&lp->lock); return ret; } static int at91ether_nwayreset(struct net_device *dev) { struct at91_private *lp = netdev_priv(dev); int ret; spin_lock_irq(&lp->lock); enable_mdi(lp); ret = mii_nway_restart(&lp->mii); disable_mdi(lp); spin_unlock_irq(&lp->lock); return ret; } static void at91ether_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info) { strlcpy(info->driver, DRV_NAME, sizeof(info->driver)); strlcpy(info->version, DRV_VERSION, sizeof(info->version)); strlcpy(info->bus_info, dev_name(dev->dev.parent), sizeof(info->bus_info)); } static const struct ethtool_ops at91ether_ethtool_ops = { .get_settings = at91ether_get_settings, .set_settings = at91ether_set_settings, .get_drvinfo = at91ether_get_drvinfo, .nway_reset = at91ether_nwayreset, .get_link = ethtool_op_get_link, }; static int at91ether_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) { struct at91_private *lp = netdev_priv(dev); int res; if (!netif_running(dev)) return -EINVAL; spin_lock_irq(&lp->lock); enable_mdi(lp); res = generic_mii_ioctl(&lp->mii, if_mii(rq), cmd, NULL); disable_mdi(lp); spin_unlock_irq(&lp->lock); return res; } /* ................................ MAC ................................ */ /* * Initialize and start the Receiver and Transmit subsystems */ static void at91ether_start(struct net_device *dev) { struct at91_private *lp = netdev_priv(dev); struct recv_desc_bufs *dlist, *dlist_phys; int i; unsigned long ctl; dlist = lp->dlist; dlist_phys = lp->dlist_phys; for (i = 0; i < MAX_RX_DESCR; i++) { dlist->descriptors[i].addr = (unsigned int) &dlist_phys->recv_buf[i][0]; dlist->descriptors[i].size = 0; } /* Set the Wrap bit on the last descriptor */ dlist->descriptors[i-1].addr |= MACB_BIT(RX_WRAP); /* Reset buffer index */ lp->rxBuffIndex = 0; /* Program address of descriptor list in Rx Buffer Queue register */ macb_writel(lp, RBQP, (unsigned long) dlist_phys); /* Enable Receive and Transmit */ ctl = macb_readl(lp, NCR); macb_writel(lp, NCR, ctl | MACB_BIT(RE) | MACB_BIT(TE)); } /* * Open the ethernet interface */ static int at91ether_open(struct net_device *dev) { struct at91_private *lp = netdev_priv(dev); unsigned long ctl; if (!is_valid_ether_addr(dev->dev_addr)) return -EADDRNOTAVAIL; clk_enable(lp->ether_clk); /* Re-enable Peripheral clock */ /* Clear internal statistics */ ctl = macb_readl(lp, NCR); macb_writel(lp, NCR, ctl | MACB_BIT(CLRSTAT)); /* Update the MAC address (incase user has changed it) */ update_mac_address(dev); /* Enable PHY interrupt */ enable_phyirq(dev); /* Enable MAC interrupts */ macb_writel(lp, IER, MACB_BIT(RCOMP) | MACB_BIT(RXUBR) | MACB_BIT(ISR_TUND) | MACB_BIT(ISR_RLE) | MACB_BIT(TCOMP) | MACB_BIT(ISR_ROVR) | MACB_BIT(HRESP)); /* Determine current link speed */ spin_lock_irq(&lp->lock); enable_mdi(lp); update_linkspeed(dev, 0); disable_mdi(lp); spin_unlock_irq(&lp->lock); at91ether_start(dev); netif_start_queue(dev); return 0; } /* * Close the interface */ static int at91ether_close(struct net_device *dev) { struct at91_private *lp = netdev_priv(dev); unsigned long ctl; /* Disable Receiver and Transmitter */ ctl = macb_readl(lp, NCR); macb_writel(lp, NCR, ctl & ~(MACB_BIT(TE) | MACB_BIT(RE))); /* Disable PHY interrupt */ disable_phyirq(dev); /* Disable MAC interrupts */ macb_writel(lp, IDR, MACB_BIT(RCOMP) | MACB_BIT(RXUBR) | MACB_BIT(ISR_TUND) | MACB_BIT(ISR_RLE) | MACB_BIT(TCOMP) | MACB_BIT(ISR_ROVR) | MACB_BIT(HRESP)); netif_stop_queue(dev); clk_disable(lp->ether_clk); /* Disable Peripheral clock */ return 0; } /* * Transmit packet. */ static int at91ether_start_xmit(struct sk_buff *skb, struct net_device *dev) { struct at91_private *lp = netdev_priv(dev); if (macb_readl(lp, TSR) & MACB_BIT(RM9200_BNQ)) { netif_stop_queue(dev); /* Store packet information (to free when Tx completed) */ lp->skb = skb; lp->skb_length = skb->len; lp->skb_physaddr = dma_map_single(NULL, skb->data, skb->len, DMA_TO_DEVICE); dev->stats.tx_bytes += skb->len; /* Set address of the data in the Transmit Address register */ macb_writel(lp, TAR, lp->skb_physaddr); /* Set length of the packet in the Transmit Control register */ macb_writel(lp, TCR, skb->len); } else { printk(KERN_ERR "at91_ether.c: at91ether_start_xmit() called, but device is busy!\n"); return NETDEV_TX_BUSY; /* if we return anything but zero, dev.c:1055 calls kfree_skb(skb) on this skb, he also reports -ENETDOWN and printk's, so either we free and return(0) or don't free and return 1 */ } return NETDEV_TX_OK; } /* * Update the current statistics from the internal statistics registers. */ static struct net_device_stats *at91ether_stats(struct net_device *dev) { struct at91_private *lp = netdev_priv(dev); int ale, lenerr, seqe, lcol, ecol; if (netif_running(dev)) { dev->stats.rx_packets += macb_readl(lp, FRO); /* Good frames received */ ale = macb_readl(lp, ALE); dev->stats.rx_frame_errors += ale; /* Alignment errors */ lenerr = macb_readl(lp, ELE) + macb_readl(lp, USF); dev->stats.rx_length_errors += lenerr; /* Excessive Length or Undersize Frame error */ seqe = macb_readl(lp, FCSE); dev->stats.rx_crc_errors += seqe; /* CRC error */ dev->stats.rx_fifo_errors += macb_readl(lp, RRE);/* Receive buffer not available */ dev->stats.rx_errors += (ale + lenerr + seqe + macb_readl(lp, RSE) + macb_readl(lp, RJA)); dev->stats.tx_packets += macb_readl(lp, FTO); /* Frames successfully transmitted */ dev->stats.tx_fifo_errors += macb_readl(lp, TUND); /* Transmit FIFO underruns */ dev->stats.tx_carrier_errors += macb_readl(lp, CSE); /* Carrier Sense errors */ dev->stats.tx_heartbeat_errors += macb_readl(lp, STE);/* Heartbeat error */ lcol = macb_readl(lp, LCOL); ecol = macb_readl(lp, EXCOL); dev->stats.tx_window_errors += lcol; /* Late collisions */ dev->stats.tx_aborted_errors += ecol; /* 16 collisions */ dev->stats.collisions += (macb_readl(lp, SCF) + macb_readl(lp, MCF) + lcol + ecol); } return &dev->stats; } /* * Extract received frame from buffer descriptors and sent to upper layers. * (Called from interrupt context) */ static void at91ether_rx(struct net_device *dev) { struct at91_private *lp = netdev_priv(dev); struct recv_desc_bufs *dlist; unsigned char *p_recv; struct sk_buff *skb; unsigned int pktlen; dlist = lp->dlist; while (dlist->descriptors[lp->rxBuffIndex].addr & MACB_BIT(RX_USED)) { p_recv = dlist->recv_buf[lp->rxBuffIndex]; pktlen = dlist->descriptors[lp->rxBuffIndex].size & 0x7ff; /* Length of frame including FCS */ skb = netdev_alloc_skb(dev, pktlen + 2); if (skb != NULL) { skb_reserve(skb, 2); memcpy(skb_put(skb, pktlen), p_recv, pktlen); skb->protocol = eth_type_trans(skb, dev); dev->stats.rx_bytes += pktlen; netif_rx(skb); } else { dev->stats.rx_dropped += 1; printk(KERN_NOTICE "%s: Memory squeeze, dropping packet.\n", dev->name); } if (dlist->descriptors[lp->rxBuffIndex].size & MACB_BIT(RX_MHASH_MATCH)) dev->stats.multicast++; dlist->descriptors[lp->rxBuffIndex].addr &= ~MACB_BIT(RX_USED); /* reset ownership bit */ if (lp->rxBuffIndex == MAX_RX_DESCR-1) /* wrap after last buffer */ lp->rxBuffIndex = 0; else lp->rxBuffIndex++; } } /* * MAC interrupt handler */ static irqreturn_t at91ether_interrupt(int irq, void *dev_id) { struct net_device *dev = (struct net_device *) dev_id; struct at91_private *lp = netdev_priv(dev); unsigned long intstatus, ctl; /* MAC Interrupt Status register indicates what interrupts are pending. It is automatically cleared once read. */ intstatus = macb_readl(lp, ISR); if (intstatus & MACB_BIT(RCOMP)) /* Receive complete */ at91ether_rx(dev); if (intstatus & MACB_BIT(TCOMP)) { /* Transmit complete */ /* The TCOM bit is set even if the transmission failed. */ if (intstatus & (MACB_BIT(ISR_TUND) | MACB_BIT(ISR_RLE))) dev->stats.tx_errors += 1; if (lp->skb) { dev_kfree_skb_irq(lp->skb); lp->skb = NULL; dma_unmap_single(NULL, lp->skb_physaddr, lp->skb_length, DMA_TO_DEVICE); } netif_wake_queue(dev); } /* Work-around for Errata #11 */ if (intstatus & MACB_BIT(RXUBR)) { ctl = macb_readl(lp, NCR); macb_writel(lp, NCR, ctl & ~MACB_BIT(RE)); macb_writel(lp, NCR, ctl | MACB_BIT(RE)); } if (intstatus & MACB_BIT(ISR_ROVR)) printk("%s: ROVR error\n", dev->name); return IRQ_HANDLED; } #ifdef CONFIG_NET_POLL_CONTROLLER static void at91ether_poll_controller(struct net_device *dev) { unsigned long flags; local_irq_save(flags); at91ether_interrupt(dev->irq, dev); local_irq_restore(flags); } #endif static const struct net_device_ops at91ether_netdev_ops = { .ndo_open = at91ether_open, .ndo_stop = at91ether_close, .ndo_start_xmit = at91ether_start_xmit, .ndo_get_stats = at91ether_stats, .ndo_set_rx_mode = at91ether_set_multicast_list, .ndo_set_mac_address = set_mac_address, .ndo_do_ioctl = at91ether_ioctl, .ndo_validate_addr = eth_validate_addr, .ndo_change_mtu = eth_change_mtu, #ifdef CONFIG_NET_POLL_CONTROLLER .ndo_poll_controller = at91ether_poll_controller, #endif }; /* * Detect the PHY type, and its address. */ static int __init at91ether_phy_detect(struct at91_private *lp) { unsigned int phyid1, phyid2; unsigned long phy_id; unsigned short phy_address = 0; while (phy_address < PHY_MAX_ADDR) { /* Read the PHY ID registers */ enable_mdi(lp); read_phy(lp, phy_address, MII_PHYSID1, &phyid1); read_phy(lp, phy_address, MII_PHYSID2, &phyid2); disable_mdi(lp); phy_id = (phyid1 << 16) | (phyid2 & 0xfff0); switch (phy_id) { case MII_DM9161_ID: /* Davicom 9161: PHY_ID1 = 0x181, PHY_ID2 = B881 */ case MII_DM9161A_ID: /* Davicom 9161A: PHY_ID1 = 0x181, PHY_ID2 = B8A0 */ case MII_LXT971A_ID: /* Intel LXT971A: PHY_ID1 = 0x13, PHY_ID2 = 78E0 */ case MII_RTL8201_ID: /* Realtek RTL8201: PHY_ID1 = 0, PHY_ID2 = 0x8201 */ case MII_BCM5221_ID: /* Broadcom BCM5221: PHY_ID1 = 0x40, PHY_ID2 = 0x61e0 */ case MII_DP83847_ID: /* National Semiconductor DP83847: */ case MII_DP83848_ID: /* National Semiconductor DP83848: */ case MII_AC101L_ID: /* Altima AC101L: PHY_ID1 = 0x22, PHY_ID2 = 0x5520 */ case MII_KS8721_ID: /* Micrel KS8721: PHY_ID1 = 0x22, PHY_ID2 = 0x1610 */ case MII_T78Q21x3_ID: /* Teridian 78Q21x3: PHY_ID1 = 0x0E, PHY_ID2 = 7237 */ case MII_LAN83C185_ID: /* SMSC LAN83C185: PHY_ID1 = 0x0007, PHY_ID2 = 0xC0A1 */ /* store detected values */ lp->phy_type = phy_id; /* Type of PHY connected */ lp->phy_address = phy_address; /* MDI address of PHY */ return 1; } phy_address++; } return 0; /* not detected */ } /* * Detect MAC & PHY and perform ethernet interface initialization */ static int __init at91ether_probe(struct platform_device *pdev) { struct macb_platform_data *board_data = pdev->dev.platform_data; struct resource *regs; struct net_device *dev; struct at91_private *lp; int res; regs = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!regs) return -ENOENT; dev = alloc_etherdev(sizeof(struct at91_private)); if (!dev) return -ENOMEM; lp = netdev_priv(dev); lp->board_data = *board_data; spin_lock_init(&lp->lock); dev->base_addr = regs->start; /* physical base address */ lp->regs = ioremap(regs->start, regs->end - regs->start + 1); if (!lp->regs) { res = -ENOMEM; goto err_free_dev; } /* Clock */ lp->ether_clk = clk_get(&pdev->dev, "ether_clk"); if (IS_ERR(lp->ether_clk)) { res = PTR_ERR(lp->ether_clk); goto err_ioumap; } clk_enable(lp->ether_clk); /* Install the interrupt handler */ dev->irq = platform_get_irq(pdev, 0); if (request_irq(dev->irq, at91ether_interrupt, 0, dev->name, dev)) { res = -EBUSY; goto err_disable_clock; } /* Allocate memory for DMA Receive descriptors */ lp->dlist = (struct recv_desc_bufs *) dma_alloc_coherent(NULL, sizeof(struct recv_desc_bufs), (dma_addr_t *) &lp->dlist_phys, GFP_KERNEL); if (lp->dlist == NULL) { res = -ENOMEM; goto err_free_irq; } ether_setup(dev); dev->netdev_ops = &at91ether_netdev_ops; dev->ethtool_ops = &at91ether_ethtool_ops; platform_set_drvdata(pdev, dev); SET_NETDEV_DEV(dev, &pdev->dev); get_mac_address(dev); /* Get ethernet address and store it in dev->dev_addr */ update_mac_address(dev); /* Program ethernet address into MAC */ macb_writel(lp, NCR, 0); if (board_data->is_rmii) macb_writel(lp, NCFGR, MACB_BF(CLK, MACB_CLK_DIV32) | MACB_BIT(BIG) | MACB_BIT(RM9200_RMII)); else macb_writel(lp, NCFGR, MACB_BF(CLK, MACB_CLK_DIV32) | MACB_BIT(BIG)); /* Detect PHY */ if (!at91ether_phy_detect(lp)) { printk(KERN_ERR "at91_ether: Could not detect ethernet PHY\n"); res = -ENODEV; goto err_free_dmamem; } initialize_phy(lp); lp->mii.dev = dev; /* Support for ethtool */ lp->mii.mdio_read = mdio_read; lp->mii.mdio_write = mdio_write; lp->mii.phy_id = lp->phy_address; lp->mii.phy_id_mask = 0x1f; lp->mii.reg_num_mask = 0x1f; /* Register the network interface */ res = register_netdev(dev); if (res) goto err_free_dmamem; /* Determine current link speed */ spin_lock_irq(&lp->lock); enable_mdi(lp); update_linkspeed(dev, 0); disable_mdi(lp); spin_unlock_irq(&lp->lock); netif_carrier_off(dev); /* will be enabled in open() */ /* If board has no PHY IRQ, use a timer to poll the PHY */ if (gpio_is_valid(lp->board_data.phy_irq_pin)) { gpio_request(board_data->phy_irq_pin, "ethernet_phy"); } else { /* If board has no PHY IRQ, use a timer to poll the PHY */ init_timer(&lp->check_timer); lp->check_timer.data = (unsigned long)dev; lp->check_timer.function = at91ether_check_link; } /* Display ethernet banner */ printk(KERN_INFO "%s: AT91 ethernet at 0x%08x int=%d %s%s (%pM)\n", dev->name, (uint) dev->base_addr, dev->irq, macb_readl(lp, NCFGR) & MACB_BIT(SPD) ? "100-" : "10-", macb_readl(lp, NCFGR) & MACB_BIT(FD) ? "FullDuplex" : "HalfDuplex", dev->dev_addr); if ((lp->phy_type == MII_DM9161_ID) || (lp->phy_type == MII_DM9161A_ID)) printk(KERN_INFO "%s: Davicom 9161 PHY %s\n", dev->name, (lp->phy_media == PORT_FIBRE) ? "(Fiber)" : "(Copper)"); else if (lp->phy_type == MII_LXT971A_ID) printk(KERN_INFO "%s: Intel LXT971A PHY\n", dev->name); else if (lp->phy_type == MII_RTL8201_ID) printk(KERN_INFO "%s: Realtek RTL8201(B)L PHY\n", dev->name); else if (lp->phy_type == MII_BCM5221_ID) printk(KERN_INFO "%s: Broadcom BCM5221 PHY\n", dev->name); else if (lp->phy_type == MII_DP83847_ID) printk(KERN_INFO "%s: National Semiconductor DP83847 PHY\n", dev->name); else if (lp->phy_type == MII_DP83848_ID) printk(KERN_INFO "%s: National Semiconductor DP83848 PHY\n", dev->name); else if (lp->phy_type == MII_AC101L_ID) printk(KERN_INFO "%s: Altima AC101L PHY\n", dev->name); else if (lp->phy_type == MII_KS8721_ID) printk(KERN_INFO "%s: Micrel KS8721 PHY\n", dev->name); else if (lp->phy_type == MII_T78Q21x3_ID) printk(KERN_INFO "%s: Teridian 78Q21x3 PHY\n", dev->name); else if (lp->phy_type == MII_LAN83C185_ID) printk(KERN_INFO "%s: SMSC LAN83C185 PHY\n", dev->name); clk_disable(lp->ether_clk); /* Disable Peripheral clock */ return 0; err_free_dmamem: platform_set_drvdata(pdev, NULL); dma_free_coherent(NULL, sizeof(struct recv_desc_bufs), lp->dlist, (dma_addr_t)lp->dlist_phys); err_free_irq: free_irq(dev->irq, dev); err_disable_clock: clk_disable(lp->ether_clk); clk_put(lp->ether_clk); err_ioumap: iounmap(lp->regs); err_free_dev: free_netdev(dev); return res; } static int __devexit at91ether_remove(struct platform_device *pdev) { struct net_device *dev = platform_get_drvdata(pdev); struct at91_private *lp = netdev_priv(dev); if (gpio_is_valid(lp->board_data.phy_irq_pin)) gpio_free(lp->board_data.phy_irq_pin); unregister_netdev(dev); free_irq(dev->irq, dev); dma_free_coherent(NULL, sizeof(struct recv_desc_bufs), lp->dlist, (dma_addr_t)lp->dlist_phys); clk_put(lp->ether_clk); platform_set_drvdata(pdev, NULL); free_netdev(dev); return 0; } #ifdef CONFIG_PM static int at91ether_suspend(struct platform_device *pdev, pm_message_t mesg) { struct net_device *net_dev = platform_get_drvdata(pdev); struct at91_private *lp = netdev_priv(net_dev); if (netif_running(net_dev)) { if (gpio_is_valid(lp->board_data.phy_irq_pin)) { int phy_irq = gpio_to_irq(lp->board_data.phy_irq_pin); disable_irq(phy_irq); } netif_stop_queue(net_dev); netif_device_detach(net_dev); clk_disable(lp->ether_clk); } return 0; } static int at91ether_resume(struct platform_device *pdev) { struct net_device *net_dev = platform_get_drvdata(pdev); struct at91_private *lp = netdev_priv(net_dev); if (netif_running(net_dev)) { clk_enable(lp->ether_clk); netif_device_attach(net_dev); netif_start_queue(net_dev); if (gpio_is_valid(lp->board_data.phy_irq_pin)) { int phy_irq = gpio_to_irq(lp->board_data.phy_irq_pin); enable_irq(phy_irq); } } return 0; } #else #define at91ether_suspend NULL #define at91ether_resume NULL #endif static struct platform_driver at91ether_driver = { .remove = __devexit_p(at91ether_remove), .suspend = at91ether_suspend, .resume = at91ether_resume, .driver = { .name = DRV_NAME, .owner = THIS_MODULE, }, }; static int __init at91ether_init(void) { return platform_driver_probe(&at91ether_driver, at91ether_probe); } static void __exit at91ether_exit(void) { platform_driver_unregister(&at91ether_driver); } module_init(at91ether_init) module_exit(at91ether_exit) MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("AT91RM9200 EMAC Ethernet driver"); MODULE_AUTHOR("Andrew Victor"); MODULE_ALIAS("platform:" DRV_NAME);