M7350/kernel/drivers/net/ethernet/cadence/at91_ether.c

483 lines
12 KiB
C
Raw Normal View History

2024-09-09 08:52:07 +00:00
/*
* 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
*
* 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 <linux/module.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/skbuff.h>
#include <linux/dma-mapping.h>
#include <linux/ethtool.h>
#include <linux/platform_data/macb.h>
#include <linux/platform_device.h>
#include <linux/clk.h>
#include <linux/gfp.h>
2024-09-09 08:57:42 +00:00
#include <linux/phy.h>
#include <linux/io.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/of_net.h>
2024-09-09 08:52:07 +00:00
2024-09-09 08:57:42 +00:00
#include "macb.h"
2024-09-09 08:52:07 +00:00
2024-09-09 08:57:42 +00:00
/* 1518 rounded up */
#define MAX_RBUFF_SZ 0x600
/* max number of receive buffers */
#define MAX_RX_DESCR 9
2024-09-09 08:52:07 +00:00
2024-09-09 08:57:42 +00:00
/* Initialize and start the Receiver and Transmit subsystems */
static int at91ether_start(struct net_device *dev)
2024-09-09 08:52:07 +00:00
{
2024-09-09 08:57:42 +00:00
struct macb *lp = netdev_priv(dev);
dma_addr_t addr;
u32 ctl;
int i;
2024-09-09 08:52:07 +00:00
2024-09-09 08:57:42 +00:00
lp->rx_ring = dma_alloc_coherent(&lp->pdev->dev,
(MAX_RX_DESCR *
sizeof(struct macb_dma_desc)),
&lp->rx_ring_dma, GFP_KERNEL);
if (!lp->rx_ring)
return -ENOMEM;
2024-09-09 08:52:07 +00:00
2024-09-09 08:57:42 +00:00
lp->rx_buffers = dma_alloc_coherent(&lp->pdev->dev,
MAX_RX_DESCR * MAX_RBUFF_SZ,
&lp->rx_buffers_dma, GFP_KERNEL);
if (!lp->rx_buffers) {
dma_free_coherent(&lp->pdev->dev,
MAX_RX_DESCR * sizeof(struct macb_dma_desc),
lp->rx_ring, lp->rx_ring_dma);
lp->rx_ring = NULL;
return -ENOMEM;
2024-09-09 08:52:07 +00:00
}
2024-09-09 08:57:42 +00:00
addr = lp->rx_buffers_dma;
2024-09-09 08:52:07 +00:00
for (i = 0; i < MAX_RX_DESCR; i++) {
2024-09-09 08:57:42 +00:00
lp->rx_ring[i].addr = addr;
lp->rx_ring[i].ctrl = 0;
addr += MAX_RBUFF_SZ;
2024-09-09 08:52:07 +00:00
}
/* Set the Wrap bit on the last descriptor */
2024-09-09 08:57:42 +00:00
lp->rx_ring[MAX_RX_DESCR - 1].addr |= MACB_BIT(RX_WRAP);
2024-09-09 08:52:07 +00:00
/* Reset buffer index */
2024-09-09 08:57:42 +00:00
lp->rx_tail = 0;
2024-09-09 08:52:07 +00:00
/* Program address of descriptor list in Rx Buffer Queue register */
2024-09-09 08:57:42 +00:00
macb_writel(lp, RBQP, lp->rx_ring_dma);
2024-09-09 08:52:07 +00:00
/* Enable Receive and Transmit */
2024-09-09 08:57:42 +00:00
ctl = macb_readl(lp, NCR);
macb_writel(lp, NCR, ctl | MACB_BIT(RE) | MACB_BIT(TE));
return 0;
2024-09-09 08:52:07 +00:00
}
2024-09-09 08:57:42 +00:00
/* Open the ethernet interface */
2024-09-09 08:52:07 +00:00
static int at91ether_open(struct net_device *dev)
{
2024-09-09 08:57:42 +00:00
struct macb *lp = netdev_priv(dev);
u32 ctl;
int ret;
2024-09-09 08:52:07 +00:00
/* Clear internal statistics */
2024-09-09 08:57:42 +00:00
ctl = macb_readl(lp, NCR);
macb_writel(lp, NCR, ctl | MACB_BIT(CLRSTAT));
2024-09-09 08:52:07 +00:00
2024-09-09 08:57:42 +00:00
macb_set_hwaddr(lp);
2024-09-09 08:52:07 +00:00
2024-09-09 08:57:42 +00:00
ret = at91ether_start(dev);
if (ret)
return ret;
2024-09-09 08:52:07 +00:00
/* Enable MAC interrupts */
2024-09-09 08:57:42 +00:00
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));
/* schedule a link state check */
phy_start(lp->phy_dev);
2024-09-09 08:52:07 +00:00
netif_start_queue(dev);
2024-09-09 08:57:42 +00:00
2024-09-09 08:52:07 +00:00
return 0;
}
2024-09-09 08:57:42 +00:00
/* Close the interface */
2024-09-09 08:52:07 +00:00
static int at91ether_close(struct net_device *dev)
{
2024-09-09 08:57:42 +00:00
struct macb *lp = netdev_priv(dev);
u32 ctl;
2024-09-09 08:52:07 +00:00
/* Disable Receiver and Transmitter */
2024-09-09 08:57:42 +00:00
ctl = macb_readl(lp, NCR);
macb_writel(lp, NCR, ctl & ~(MACB_BIT(TE) | MACB_BIT(RE)));
2024-09-09 08:52:07 +00:00
/* Disable MAC interrupts */
2024-09-09 08:57:42 +00:00
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));
2024-09-09 08:52:07 +00:00
netif_stop_queue(dev);
2024-09-09 08:57:42 +00:00
dma_free_coherent(&lp->pdev->dev,
MAX_RX_DESCR * sizeof(struct macb_dma_desc),
lp->rx_ring, lp->rx_ring_dma);
lp->rx_ring = NULL;
dma_free_coherent(&lp->pdev->dev,
MAX_RX_DESCR * MAX_RBUFF_SZ,
lp->rx_buffers, lp->rx_buffers_dma);
lp->rx_buffers = NULL;
2024-09-09 08:52:07 +00:00
return 0;
}
2024-09-09 08:57:42 +00:00
/* Transmit packet */
2024-09-09 08:52:07 +00:00
static int at91ether_start_xmit(struct sk_buff *skb, struct net_device *dev)
{
2024-09-09 08:57:42 +00:00
struct macb *lp = netdev_priv(dev);
2024-09-09 08:52:07 +00:00
2024-09-09 08:57:42 +00:00
if (macb_readl(lp, TSR) & MACB_BIT(RM9200_BNQ)) {
2024-09-09 08:52:07 +00:00
netif_stop_queue(dev);
/* Store packet information (to free when Tx completed) */
lp->skb = skb;
lp->skb_length = skb->len;
2024-09-09 08:57:42 +00:00
lp->skb_physaddr = dma_map_single(NULL, skb->data, skb->len,
DMA_TO_DEVICE);
2024-09-09 08:52:07 +00:00
/* Set address of the data in the Transmit Address register */
2024-09-09 08:57:42 +00:00
macb_writel(lp, TAR, lp->skb_physaddr);
2024-09-09 08:52:07 +00:00
/* Set length of the packet in the Transmit Control register */
2024-09-09 08:57:42 +00:00
macb_writel(lp, TCR, skb->len);
2024-09-09 08:52:07 +00:00
} else {
2024-09-09 08:57:42 +00:00
netdev_err(dev, "%s called, but device is busy!\n", __func__);
return NETDEV_TX_BUSY;
2024-09-09 08:52:07 +00:00
}
return NETDEV_TX_OK;
}
2024-09-09 08:57:42 +00:00
/* Extract received frame from buffer descriptors and sent to upper layers.
2024-09-09 08:52:07 +00:00
* (Called from interrupt context)
*/
static void at91ether_rx(struct net_device *dev)
{
2024-09-09 08:57:42 +00:00
struct macb *lp = netdev_priv(dev);
2024-09-09 08:52:07 +00:00
unsigned char *p_recv;
struct sk_buff *skb;
unsigned int pktlen;
2024-09-09 08:57:42 +00:00
while (lp->rx_ring[lp->rx_tail].addr & MACB_BIT(RX_USED)) {
p_recv = lp->rx_buffers + lp->rx_tail * MAX_RBUFF_SZ;
pktlen = MACB_BF(RX_FRMLEN, lp->rx_ring[lp->rx_tail].ctrl);
2024-09-09 08:52:07 +00:00
skb = netdev_alloc_skb(dev, pktlen + 2);
2024-09-09 08:57:42 +00:00
if (skb) {
2024-09-09 08:52:07 +00:00
skb_reserve(skb, 2);
memcpy(skb_put(skb, pktlen), p_recv, pktlen);
skb->protocol = eth_type_trans(skb, dev);
2024-09-09 08:57:42 +00:00
lp->stats.rx_packets++;
lp->stats.rx_bytes += pktlen;
2024-09-09 08:52:07 +00:00
netif_rx(skb);
2024-09-09 08:57:42 +00:00
} else {
lp->stats.rx_dropped++;
2024-09-09 08:52:07 +00:00
}
2024-09-09 08:57:42 +00:00
if (lp->rx_ring[lp->rx_tail].ctrl & MACB_BIT(RX_MHASH_MATCH))
lp->stats.multicast++;
/* reset ownership bit */
lp->rx_ring[lp->rx_tail].addr &= ~MACB_BIT(RX_USED);
2024-09-09 08:52:07 +00:00
2024-09-09 08:57:42 +00:00
/* wrap after last buffer */
if (lp->rx_tail == MAX_RX_DESCR - 1)
lp->rx_tail = 0;
2024-09-09 08:52:07 +00:00
else
2024-09-09 08:57:42 +00:00
lp->rx_tail++;
2024-09-09 08:52:07 +00:00
}
}
2024-09-09 08:57:42 +00:00
/* MAC interrupt handler */
2024-09-09 08:52:07 +00:00
static irqreturn_t at91ether_interrupt(int irq, void *dev_id)
{
2024-09-09 08:57:42 +00:00
struct net_device *dev = dev_id;
struct macb *lp = netdev_priv(dev);
u32 intstatus, ctl;
2024-09-09 08:52:07 +00:00
/* MAC Interrupt Status register indicates what interrupts are pending.
2024-09-09 08:57:42 +00:00
* It is automatically cleared once read.
*/
intstatus = macb_readl(lp, ISR);
2024-09-09 08:52:07 +00:00
2024-09-09 08:57:42 +00:00
/* Receive complete */
if (intstatus & MACB_BIT(RCOMP))
2024-09-09 08:52:07 +00:00
at91ether_rx(dev);
2024-09-09 08:57:42 +00:00
/* Transmit complete */
if (intstatus & MACB_BIT(TCOMP)) {
/* The TCOM bit is set even if the transmission failed */
if (intstatus & (MACB_BIT(ISR_TUND) | MACB_BIT(ISR_RLE)))
lp->stats.tx_errors++;
2024-09-09 08:52:07 +00:00
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);
2024-09-09 08:57:42 +00:00
lp->stats.tx_packets++;
lp->stats.tx_bytes += lp->skb_length;
2024-09-09 08:52:07 +00:00
}
netif_wake_queue(dev);
}
2024-09-09 08:57:42 +00:00
/* Work-around for EMAC Errata section 41.3.1 */
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));
2024-09-09 08:52:07 +00:00
}
2024-09-09 08:57:42 +00:00
if (intstatus & MACB_BIT(ISR_ROVR))
netdev_err(dev, "ROVR error\n");
2024-09-09 08:52:07 +00:00
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,
2024-09-09 08:57:42 +00:00
.ndo_get_stats = macb_get_stats,
.ndo_set_rx_mode = macb_set_rx_mode,
.ndo_set_mac_address = eth_mac_addr,
.ndo_do_ioctl = macb_ioctl,
2024-09-09 08:52:07 +00:00
.ndo_validate_addr = eth_validate_addr,
.ndo_change_mtu = eth_change_mtu,
#ifdef CONFIG_NET_POLL_CONTROLLER
.ndo_poll_controller = at91ether_poll_controller,
#endif
};
2024-09-09 08:57:42 +00:00
#if defined(CONFIG_OF)
static const struct of_device_id at91ether_dt_ids[] = {
{ .compatible = "cdns,at91rm9200-emac" },
{ .compatible = "cdns,emac" },
{ /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, at91ether_dt_ids);
#endif
/* Detect MAC & PHY and perform ethernet interface initialization */
static int __init at91ether_probe(struct platform_device *pdev)
2024-09-09 08:52:07 +00:00
{
2024-09-09 08:57:42 +00:00
struct macb_platform_data *board_data = dev_get_platdata(&pdev->dev);
struct resource *regs;
2024-09-09 08:52:07 +00:00
struct net_device *dev;
2024-09-09 08:57:42 +00:00
struct phy_device *phydev;
struct macb *lp;
2024-09-09 08:52:07 +00:00
int res;
2024-09-09 08:57:42 +00:00
u32 reg;
const char *mac;
regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!regs)
return -ENOENT;
2024-09-09 08:52:07 +00:00
2024-09-09 08:57:42 +00:00
dev = alloc_etherdev(sizeof(struct macb));
2024-09-09 08:52:07 +00:00
if (!dev)
return -ENOMEM;
2024-09-09 08:57:42 +00:00
lp = netdev_priv(dev);
lp->pdev = pdev;
lp->dev = dev;
spin_lock_init(&lp->lock);
2024-09-09 08:52:07 +00:00
2024-09-09 08:57:42 +00:00
/* physical base address */
dev->base_addr = regs->start;
lp->regs = devm_ioremap(&pdev->dev, regs->start, resource_size(regs));
if (!lp->regs) {
res = -ENOMEM;
goto err_free_dev;
2024-09-09 08:52:07 +00:00
}
2024-09-09 08:57:42 +00:00
/* Clock */
lp->pclk = devm_clk_get(&pdev->dev, "ether_clk");
if (IS_ERR(lp->pclk)) {
res = PTR_ERR(lp->pclk);
goto err_free_dev;
2024-09-09 08:52:07 +00:00
}
2024-09-09 08:57:42 +00:00
clk_enable(lp->pclk);
2024-09-09 08:52:07 +00:00
2024-09-09 08:57:42 +00:00
lp->hclk = ERR_PTR(-ENOENT);
lp->tx_clk = ERR_PTR(-ENOENT);
2024-09-09 08:52:07 +00:00
2024-09-09 08:57:42 +00:00
/* Install the interrupt handler */
dev->irq = platform_get_irq(pdev, 0);
res = devm_request_irq(&pdev->dev, dev->irq, at91ether_interrupt, 0, dev->name, dev);
if (res)
goto err_disable_clock;
2024-09-09 08:52:07 +00:00
2024-09-09 08:57:42 +00:00
dev->netdev_ops = &at91ether_netdev_ops;
dev->ethtool_ops = &macb_ethtool_ops;
platform_set_drvdata(pdev, dev);
2024-09-09 08:52:07 +00:00
SET_NETDEV_DEV(dev, &pdev->dev);
2024-09-09 08:57:42 +00:00
mac = of_get_mac_address(pdev->dev.of_node);
if (mac)
memcpy(lp->dev->dev_addr, mac, ETH_ALEN);
else
macb_get_hwaddr(lp);
2024-09-09 08:52:07 +00:00
2024-09-09 08:57:42 +00:00
res = of_get_phy_mode(pdev->dev.of_node);
if (res < 0) {
if (board_data && board_data->is_rmii)
lp->phy_interface = PHY_INTERFACE_MODE_RMII;
else
lp->phy_interface = PHY_INTERFACE_MODE_MII;
} else {
lp->phy_interface = res;
}
2024-09-09 08:52:07 +00:00
2024-09-09 08:57:42 +00:00
macb_writel(lp, NCR, 0);
reg = MACB_BF(CLK, MACB_CLK_DIV32) | MACB_BIT(BIG);
if (lp->phy_interface == PHY_INTERFACE_MODE_RMII)
reg |= MACB_BIT(RM9200_RMII);
macb_writel(lp, NCFGR, reg);
2024-09-09 08:52:07 +00:00
/* Register the network interface */
res = register_netdev(dev);
2024-09-09 08:57:42 +00:00
if (res)
goto err_disable_clock;
2024-09-09 08:52:07 +00:00
2024-09-09 08:57:42 +00:00
res = macb_mii_init(lp);
if (res)
goto err_out_unregister_netdev;
2024-09-09 08:52:07 +00:00
2024-09-09 08:57:42 +00:00
/* will be enabled in open() */
netif_carrier_off(dev);
2024-09-09 08:52:07 +00:00
2024-09-09 08:57:42 +00:00
phydev = lp->phy_dev;
netdev_info(dev, "attached PHY driver [%s] (mii_bus:phy_addr=%s, irq=%d)\n",
phydev->drv->name, dev_name(&phydev->dev),
phydev->irq);
2024-09-09 08:52:07 +00:00
2024-09-09 08:57:42 +00:00
/* Display ethernet banner */
netdev_info(dev, "AT91 ethernet at 0x%08lx int=%d (%pM)\n",
dev->base_addr, dev->irq, dev->dev_addr);
2024-09-09 08:52:07 +00:00
2024-09-09 08:57:42 +00:00
return 0;
2024-09-09 08:52:07 +00:00
2024-09-09 08:57:42 +00:00
err_out_unregister_netdev:
unregister_netdev(dev);
err_disable_clock:
clk_disable(lp->pclk);
err_free_dev:
free_netdev(dev);
return res;
2024-09-09 08:52:07 +00:00
}
2024-09-09 08:57:42 +00:00
static int at91ether_remove(struct platform_device *pdev)
2024-09-09 08:52:07 +00:00
{
struct net_device *dev = platform_get_drvdata(pdev);
2024-09-09 08:57:42 +00:00
struct macb *lp = netdev_priv(dev);
2024-09-09 08:52:07 +00:00
2024-09-09 08:57:42 +00:00
if (lp->phy_dev)
phy_disconnect(lp->phy_dev);
2024-09-09 08:52:07 +00:00
2024-09-09 08:57:42 +00:00
mdiobus_unregister(lp->mii_bus);
kfree(lp->mii_bus->irq);
mdiobus_free(lp->mii_bus);
2024-09-09 08:52:07 +00:00
unregister_netdev(dev);
2024-09-09 08:57:42 +00:00
clk_disable(lp->pclk);
2024-09-09 08:52:07 +00:00
free_netdev(dev);
2024-09-09 08:57:42 +00:00
2024-09-09 08:52:07 +00:00
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);
2024-09-09 08:57:42 +00:00
struct macb *lp = netdev_priv(net_dev);
2024-09-09 08:52:07 +00:00
if (netif_running(net_dev)) {
netif_stop_queue(net_dev);
netif_device_detach(net_dev);
2024-09-09 08:57:42 +00:00
clk_disable(lp->pclk);
2024-09-09 08:52:07 +00:00
}
return 0;
}
static int at91ether_resume(struct platform_device *pdev)
{
struct net_device *net_dev = platform_get_drvdata(pdev);
2024-09-09 08:57:42 +00:00
struct macb *lp = netdev_priv(net_dev);
2024-09-09 08:52:07 +00:00
if (netif_running(net_dev)) {
2024-09-09 08:57:42 +00:00
clk_enable(lp->pclk);
2024-09-09 08:52:07 +00:00
netif_device_attach(net_dev);
netif_start_queue(net_dev);
}
return 0;
}
#else
#define at91ether_suspend NULL
#define at91ether_resume NULL
#endif
static struct platform_driver at91ether_driver = {
2024-09-09 08:57:42 +00:00
.remove = at91ether_remove,
2024-09-09 08:52:07 +00:00
.suspend = at91ether_suspend,
.resume = at91ether_resume,
.driver = {
2024-09-09 08:57:42 +00:00
.name = "at91_ether",
2024-09-09 08:52:07 +00:00
.owner = THIS_MODULE,
2024-09-09 08:57:42 +00:00
.of_match_table = of_match_ptr(at91ether_dt_ids),
2024-09-09 08:52:07 +00:00
},
};
2024-09-09 08:57:42 +00:00
module_platform_driver_probe(at91ether_driver, at91ether_probe);
2024-09-09 08:52:07 +00:00
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("AT91RM9200 EMAC Ethernet driver");
MODULE_AUTHOR("Andrew Victor");
2024-09-09 08:57:42 +00:00
MODULE_ALIAS("platform:at91_ether");