2009-10-14 22:13:45 +00:00
|
|
|
/*******************************************************************************
|
|
|
|
This is the driver for the ST MAC 10/100/1000 on-chip Ethernet controllers.
|
|
|
|
ST Ethernet IPs are built around a Synopsys IP Core.
|
|
|
|
|
|
|
|
Copyright (C) 2007-2009 STMicroelectronics Ltd
|
|
|
|
|
|
|
|
This program is free software; you can redistribute it and/or modify it
|
|
|
|
under the terms and conditions of the GNU General Public License,
|
|
|
|
version 2, as published by the Free Software Foundation.
|
|
|
|
|
|
|
|
This program is distributed in the hope 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.
|
|
|
|
|
|
|
|
The full GNU General Public License is included in this distribution in
|
|
|
|
the file called "COPYING".
|
|
|
|
|
|
|
|
Author: Giuseppe Cavallaro <peppe.cavallaro@st.com>
|
|
|
|
|
|
|
|
Documentation available at:
|
|
|
|
http://www.stlinux.com
|
|
|
|
Support available at:
|
|
|
|
https://bugzilla.stlinux.com/
|
|
|
|
*******************************************************************************/
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/etherdevice.h>
|
|
|
|
#include <linux/platform_device.h>
|
|
|
|
#include <linux/ip.h>
|
|
|
|
#include <linux/tcp.h>
|
|
|
|
#include <linux/skbuff.h>
|
|
|
|
#include <linux/ethtool.h>
|
|
|
|
#include <linux/if_ether.h>
|
|
|
|
#include <linux/crc32.h>
|
|
|
|
#include <linux/mii.h>
|
|
|
|
#include <linux/phy.h>
|
2011-08-16 06:29:00 +00:00
|
|
|
#include <linux/if.h>
|
2009-10-14 22:13:45 +00:00
|
|
|
#include <linux/if_vlan.h>
|
|
|
|
#include <linux/dma-mapping.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 08:04:11 +00:00
|
|
|
#include <linux/slab.h>
|
2011-05-22 20:47:17 +00:00
|
|
|
#include <linux/prefetch.h>
|
2009-10-14 22:13:45 +00:00
|
|
|
#include "stmmac.h"
|
|
|
|
|
|
|
|
#define STMMAC_RESOURCE_NAME "stmmaceth"
|
|
|
|
|
|
|
|
#undef STMMAC_DEBUG
|
|
|
|
/*#define STMMAC_DEBUG*/
|
|
|
|
#ifdef STMMAC_DEBUG
|
|
|
|
#define DBG(nlevel, klevel, fmt, args...) \
|
|
|
|
((void)(netif_msg_##nlevel(priv) && \
|
|
|
|
printk(KERN_##klevel fmt, ## args)))
|
|
|
|
#else
|
|
|
|
#define DBG(nlevel, klevel, fmt, args...) do { } while (0)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#undef STMMAC_RX_DEBUG
|
|
|
|
/*#define STMMAC_RX_DEBUG*/
|
|
|
|
#ifdef STMMAC_RX_DEBUG
|
|
|
|
#define RX_DBG(fmt, args...) printk(fmt, ## args)
|
|
|
|
#else
|
|
|
|
#define RX_DBG(fmt, args...) do { } while (0)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#undef STMMAC_XMIT_DEBUG
|
|
|
|
/*#define STMMAC_XMIT_DEBUG*/
|
|
|
|
#ifdef STMMAC_TX_DEBUG
|
|
|
|
#define TX_DBG(fmt, args...) printk(fmt, ## args)
|
|
|
|
#else
|
|
|
|
#define TX_DBG(fmt, args...) do { } while (0)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#define STMMAC_ALIGN(x) L1_CACHE_ALIGN(x)
|
|
|
|
#define JUMBO_LEN 9000
|
|
|
|
|
|
|
|
/* Module parameters */
|
|
|
|
#define TX_TIMEO 5000 /* default 5 seconds */
|
|
|
|
static int watchdog = TX_TIMEO;
|
|
|
|
module_param(watchdog, int, S_IRUGO | S_IWUSR);
|
|
|
|
MODULE_PARM_DESC(watchdog, "Transmit timeout in milliseconds");
|
|
|
|
|
|
|
|
static int debug = -1; /* -1: default, 0: no output, 16: all */
|
|
|
|
module_param(debug, int, S_IRUGO | S_IWUSR);
|
|
|
|
MODULE_PARM_DESC(debug, "Message Level (0: no output, 16: all)");
|
|
|
|
|
|
|
|
static int phyaddr = -1;
|
|
|
|
module_param(phyaddr, int, S_IRUGO);
|
|
|
|
MODULE_PARM_DESC(phyaddr, "Physical device address");
|
|
|
|
|
|
|
|
#define DMA_TX_SIZE 256
|
|
|
|
static int dma_txsize = DMA_TX_SIZE;
|
|
|
|
module_param(dma_txsize, int, S_IRUGO | S_IWUSR);
|
|
|
|
MODULE_PARM_DESC(dma_txsize, "Number of descriptors in the TX list");
|
|
|
|
|
|
|
|
#define DMA_RX_SIZE 256
|
|
|
|
static int dma_rxsize = DMA_RX_SIZE;
|
|
|
|
module_param(dma_rxsize, int, S_IRUGO | S_IWUSR);
|
|
|
|
MODULE_PARM_DESC(dma_rxsize, "Number of descriptors in the RX list");
|
|
|
|
|
|
|
|
static int flow_ctrl = FLOW_OFF;
|
|
|
|
module_param(flow_ctrl, int, S_IRUGO | S_IWUSR);
|
|
|
|
MODULE_PARM_DESC(flow_ctrl, "Flow control ability [on/off]");
|
|
|
|
|
|
|
|
static int pause = PAUSE_TIME;
|
|
|
|
module_param(pause, int, S_IRUGO | S_IWUSR);
|
|
|
|
MODULE_PARM_DESC(pause, "Flow Control Pause Time");
|
|
|
|
|
|
|
|
#define TC_DEFAULT 64
|
|
|
|
static int tc = TC_DEFAULT;
|
|
|
|
module_param(tc, int, S_IRUGO | S_IWUSR);
|
|
|
|
MODULE_PARM_DESC(tc, "DMA threshold control value");
|
|
|
|
|
|
|
|
/* Pay attention to tune this parameter; take care of both
|
|
|
|
* hardware capability and network stabitily/performance impact.
|
|
|
|
* Many tests showed that ~4ms latency seems to be good enough. */
|
|
|
|
#ifdef CONFIG_STMMAC_TIMER
|
|
|
|
#define DEFAULT_PERIODIC_RATE 256
|
|
|
|
static int tmrate = DEFAULT_PERIODIC_RATE;
|
|
|
|
module_param(tmrate, int, S_IRUGO | S_IWUSR);
|
|
|
|
MODULE_PARM_DESC(tmrate, "External timer freq. (default: 256Hz)");
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#define DMA_BUFFER_SIZE BUF_SIZE_2KiB
|
|
|
|
static int buf_sz = DMA_BUFFER_SIZE;
|
|
|
|
module_param(buf_sz, int, S_IRUGO | S_IWUSR);
|
|
|
|
MODULE_PARM_DESC(buf_sz, "DMA buffer size");
|
|
|
|
|
|
|
|
static const u32 default_msg_level = (NETIF_MSG_DRV | NETIF_MSG_PROBE |
|
|
|
|
NETIF_MSG_LINK | NETIF_MSG_IFUP |
|
|
|
|
NETIF_MSG_IFDOWN | NETIF_MSG_TIMER);
|
|
|
|
|
|
|
|
static irqreturn_t stmmac_interrupt(int irq, void *dev_id);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* stmmac_verify_args - verify the driver parameters.
|
|
|
|
* Description: it verifies if some wrong parameter is passed to the driver.
|
|
|
|
* Note that wrong parameters are replaced with the default values.
|
|
|
|
*/
|
|
|
|
static void stmmac_verify_args(void)
|
|
|
|
{
|
|
|
|
if (unlikely(watchdog < 0))
|
|
|
|
watchdog = TX_TIMEO;
|
|
|
|
if (unlikely(dma_rxsize < 0))
|
|
|
|
dma_rxsize = DMA_RX_SIZE;
|
|
|
|
if (unlikely(dma_txsize < 0))
|
|
|
|
dma_txsize = DMA_TX_SIZE;
|
|
|
|
if (unlikely((buf_sz < DMA_BUFFER_SIZE) || (buf_sz > BUF_SIZE_16KiB)))
|
|
|
|
buf_sz = DMA_BUFFER_SIZE;
|
|
|
|
if (unlikely(flow_ctrl > 1))
|
|
|
|
flow_ctrl = FLOW_AUTO;
|
|
|
|
else if (likely(flow_ctrl < 0))
|
|
|
|
flow_ctrl = FLOW_OFF;
|
|
|
|
if (unlikely((pause < 0) || (pause > 0xffff)))
|
|
|
|
pause = PAUSE_TIME;
|
|
|
|
}
|
|
|
|
|
|
|
|
#if defined(STMMAC_XMIT_DEBUG) || defined(STMMAC_RX_DEBUG)
|
|
|
|
static void print_pkt(unsigned char *buf, int len)
|
|
|
|
{
|
|
|
|
int j;
|
|
|
|
pr_info("len = %d byte, buf addr: 0x%p", len, buf);
|
|
|
|
for (j = 0; j < len; j++) {
|
|
|
|
if ((j % 16) == 0)
|
|
|
|
pr_info("\n %03x:", j);
|
|
|
|
pr_info(" %02x", buf[j]);
|
|
|
|
}
|
|
|
|
pr_info("\n");
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* minimum number of free TX descriptors required to wake up TX process */
|
|
|
|
#define STMMAC_TX_THRESH(x) (x->dma_tx_size/4)
|
|
|
|
|
|
|
|
static inline u32 stmmac_tx_avail(struct stmmac_priv *priv)
|
|
|
|
{
|
|
|
|
return priv->dirty_tx + priv->dma_tx_size - priv->cur_tx - 1;
|
|
|
|
}
|
|
|
|
|
2010-11-24 02:37:58 +00:00
|
|
|
/* On some ST platforms, some HW system configuraton registers have to be
|
|
|
|
* set according to the link speed negotiated.
|
|
|
|
*/
|
|
|
|
static inline void stmmac_hw_fix_mac_speed(struct stmmac_priv *priv)
|
|
|
|
{
|
|
|
|
struct phy_device *phydev = priv->phydev;
|
|
|
|
|
|
|
|
if (likely(priv->plat->fix_mac_speed))
|
|
|
|
priv->plat->fix_mac_speed(priv->plat->bsp_priv,
|
|
|
|
phydev->speed);
|
|
|
|
}
|
|
|
|
|
2009-10-14 22:13:45 +00:00
|
|
|
/**
|
|
|
|
* stmmac_adjust_link
|
|
|
|
* @dev: net device structure
|
|
|
|
* Description: it adjusts the link parameters.
|
|
|
|
*/
|
|
|
|
static void stmmac_adjust_link(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct stmmac_priv *priv = netdev_priv(dev);
|
|
|
|
struct phy_device *phydev = priv->phydev;
|
|
|
|
unsigned long flags;
|
|
|
|
int new_state = 0;
|
|
|
|
unsigned int fc = priv->flow_ctrl, pause_time = priv->pause;
|
|
|
|
|
|
|
|
if (phydev == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
DBG(probe, DEBUG, "stmmac_adjust_link: called. address %d link %d\n",
|
|
|
|
phydev->addr, phydev->link);
|
|
|
|
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
if (phydev->link) {
|
2010-08-23 20:40:42 +00:00
|
|
|
u32 ctrl = readl(priv->ioaddr + MAC_CTRL_REG);
|
2009-10-14 22:13:45 +00:00
|
|
|
|
|
|
|
/* Now we make sure that we can be in full duplex mode.
|
|
|
|
* If not, we operate in half-duplex mode. */
|
|
|
|
if (phydev->duplex != priv->oldduplex) {
|
|
|
|
new_state = 1;
|
|
|
|
if (!(phydev->duplex))
|
2010-01-06 23:07:17 +00:00
|
|
|
ctrl &= ~priv->hw->link.duplex;
|
2009-10-14 22:13:45 +00:00
|
|
|
else
|
2010-01-06 23:07:17 +00:00
|
|
|
ctrl |= priv->hw->link.duplex;
|
2009-10-14 22:13:45 +00:00
|
|
|
priv->oldduplex = phydev->duplex;
|
|
|
|
}
|
|
|
|
/* Flow Control operation */
|
|
|
|
if (phydev->pause)
|
2010-08-23 20:40:42 +00:00
|
|
|
priv->hw->mac->flow_ctrl(priv->ioaddr, phydev->duplex,
|
2010-01-06 23:07:17 +00:00
|
|
|
fc, pause_time);
|
2009-10-14 22:13:45 +00:00
|
|
|
|
|
|
|
if (phydev->speed != priv->speed) {
|
|
|
|
new_state = 1;
|
|
|
|
switch (phydev->speed) {
|
|
|
|
case 1000:
|
2010-11-24 02:37:58 +00:00
|
|
|
if (likely(priv->plat->has_gmac))
|
2010-01-06 23:07:17 +00:00
|
|
|
ctrl &= ~priv->hw->link.port;
|
2010-11-24 02:37:58 +00:00
|
|
|
stmmac_hw_fix_mac_speed(priv);
|
2009-10-14 22:13:45 +00:00
|
|
|
break;
|
|
|
|
case 100:
|
|
|
|
case 10:
|
2010-11-24 02:37:58 +00:00
|
|
|
if (priv->plat->has_gmac) {
|
2010-01-06 23:07:17 +00:00
|
|
|
ctrl |= priv->hw->link.port;
|
2009-10-14 22:13:45 +00:00
|
|
|
if (phydev->speed == SPEED_100) {
|
2010-01-06 23:07:17 +00:00
|
|
|
ctrl |= priv->hw->link.speed;
|
2009-10-14 22:13:45 +00:00
|
|
|
} else {
|
2010-01-06 23:07:17 +00:00
|
|
|
ctrl &= ~(priv->hw->link.speed);
|
2009-10-14 22:13:45 +00:00
|
|
|
}
|
|
|
|
} else {
|
2010-01-06 23:07:17 +00:00
|
|
|
ctrl &= ~priv->hw->link.port;
|
2009-10-14 22:13:45 +00:00
|
|
|
}
|
2010-11-24 02:37:58 +00:00
|
|
|
stmmac_hw_fix_mac_speed(priv);
|
2009-10-14 22:13:45 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
if (netif_msg_link(priv))
|
|
|
|
pr_warning("%s: Speed (%d) is not 10"
|
|
|
|
" or 100!\n", dev->name, phydev->speed);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
priv->speed = phydev->speed;
|
|
|
|
}
|
|
|
|
|
2010-08-23 20:40:42 +00:00
|
|
|
writel(ctrl, priv->ioaddr + MAC_CTRL_REG);
|
2009-10-14 22:13:45 +00:00
|
|
|
|
|
|
|
if (!priv->oldlink) {
|
|
|
|
new_state = 1;
|
|
|
|
priv->oldlink = 1;
|
|
|
|
}
|
|
|
|
} else if (priv->oldlink) {
|
|
|
|
new_state = 1;
|
|
|
|
priv->oldlink = 0;
|
|
|
|
priv->speed = 0;
|
|
|
|
priv->oldduplex = -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (new_state && netif_msg_link(priv))
|
|
|
|
phy_print_status(phydev);
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
|
|
|
|
DBG(probe, DEBUG, "stmmac_adjust_link: exiting\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* stmmac_init_phy - PHY initialization
|
|
|
|
* @dev: net device structure
|
|
|
|
* Description: it initializes the driver's PHY state, and attaches the PHY
|
|
|
|
* to the mac driver.
|
|
|
|
* Return value:
|
|
|
|
* 0 on success
|
|
|
|
*/
|
|
|
|
static int stmmac_init_phy(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct stmmac_priv *priv = netdev_priv(dev);
|
|
|
|
struct phy_device *phydev;
|
2010-01-06 23:07:11 +00:00
|
|
|
char phy_id[MII_BUS_ID_SIZE + 3];
|
|
|
|
char bus_id[MII_BUS_ID_SIZE];
|
2009-10-14 22:13:45 +00:00
|
|
|
|
|
|
|
priv->oldlink = 0;
|
|
|
|
priv->speed = 0;
|
|
|
|
priv->oldduplex = -1;
|
|
|
|
|
2010-11-24 02:37:58 +00:00
|
|
|
snprintf(bus_id, MII_BUS_ID_SIZE, "%x", priv->plat->bus_id);
|
2010-01-06 23:07:11 +00:00
|
|
|
snprintf(phy_id, MII_BUS_ID_SIZE + 3, PHY_ID_FMT, bus_id,
|
2011-07-20 00:05:23 +00:00
|
|
|
priv->plat->phy_addr);
|
2009-10-14 22:13:45 +00:00
|
|
|
pr_debug("stmmac_init_phy: trying to attach to %s\n", phy_id);
|
|
|
|
|
|
|
|
phydev = phy_connect(dev, phy_id, &stmmac_adjust_link, 0,
|
2011-07-20 00:05:23 +00:00
|
|
|
priv->plat->interface);
|
2009-10-14 22:13:45 +00:00
|
|
|
|
|
|
|
if (IS_ERR(phydev)) {
|
|
|
|
pr_err("%s: Could not attach to PHY\n", dev->name);
|
|
|
|
return PTR_ERR(phydev);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Broken HW is sometimes missing the pull-up resistor on the
|
|
|
|
* MDIO line, which results in reads to non-existent devices returning
|
|
|
|
* 0 rather than 0xffff. Catch this here and treat 0 as a non-existent
|
|
|
|
* device as well.
|
|
|
|
* Note: phydev->phy_id is the result of reading the UID PHY registers.
|
|
|
|
*/
|
|
|
|
if (phydev->phy_id == 0) {
|
|
|
|
phy_disconnect(phydev);
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
pr_debug("stmmac_init_phy: %s: attached to PHY (UID 0x%x)"
|
2011-07-20 00:05:23 +00:00
|
|
|
" Link = %d\n", dev->name, phydev->phy_id, phydev->link);
|
2009-10-14 22:13:45 +00:00
|
|
|
|
|
|
|
priv->phydev = phydev;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-10-25 18:58:14 +00:00
|
|
|
static inline void stmmac_enable_mac(void __iomem *ioaddr)
|
2009-10-14 22:13:45 +00:00
|
|
|
{
|
|
|
|
u32 value = readl(ioaddr + MAC_CTRL_REG);
|
|
|
|
|
2010-10-25 18:58:14 +00:00
|
|
|
value |= MAC_RNABLE_RX | MAC_ENABLE_TX;
|
2009-10-14 22:13:45 +00:00
|
|
|
writel(value, ioaddr + MAC_CTRL_REG);
|
|
|
|
}
|
|
|
|
|
2010-10-25 18:58:14 +00:00
|
|
|
static inline void stmmac_disable_mac(void __iomem *ioaddr)
|
2009-10-14 22:13:45 +00:00
|
|
|
{
|
|
|
|
u32 value = readl(ioaddr + MAC_CTRL_REG);
|
|
|
|
|
2010-10-25 18:58:14 +00:00
|
|
|
value &= ~(MAC_ENABLE_TX | MAC_RNABLE_RX);
|
2009-10-14 22:13:45 +00:00
|
|
|
writel(value, ioaddr + MAC_CTRL_REG);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* display_ring
|
|
|
|
* @p: pointer to the ring.
|
|
|
|
* @size: size of the ring.
|
|
|
|
* Description: display all the descriptors within the ring.
|
|
|
|
*/
|
|
|
|
static void display_ring(struct dma_desc *p, int size)
|
|
|
|
{
|
|
|
|
struct tmp_s {
|
|
|
|
u64 a;
|
|
|
|
unsigned int b;
|
|
|
|
unsigned int c;
|
|
|
|
};
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < size; i++) {
|
|
|
|
struct tmp_s *x = (struct tmp_s *)(p + i);
|
|
|
|
pr_info("\t%d [0x%x]: DES0=0x%x DES1=0x%x BUF1=0x%x BUF2=0x%x",
|
|
|
|
i, (unsigned int)virt_to_phys(&p[i]),
|
|
|
|
(unsigned int)(x->a), (unsigned int)((x->a) >> 32),
|
|
|
|
x->b, x->c);
|
|
|
|
pr_info("\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* init_dma_desc_rings - init the RX/TX descriptor rings
|
|
|
|
* @dev: net device structure
|
|
|
|
* Description: this function initializes the DMA RX/TX descriptors
|
|
|
|
* and allocates the socket buffers.
|
|
|
|
*/
|
|
|
|
static void init_dma_desc_rings(struct net_device *dev)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct stmmac_priv *priv = netdev_priv(dev);
|
|
|
|
struct sk_buff *skb;
|
|
|
|
unsigned int txsize = priv->dma_tx_size;
|
|
|
|
unsigned int rxsize = priv->dma_rx_size;
|
|
|
|
unsigned int bfsize = priv->dma_buf_sz;
|
2009-11-22 22:59:56 +00:00
|
|
|
int buff2_needed = 0, dis_ic = 0;
|
2009-10-14 22:13:45 +00:00
|
|
|
|
|
|
|
/* Set the Buffer size according to the MTU;
|
|
|
|
* indeed, in case of jumbo we need to bump-up the buffer sizes.
|
|
|
|
*/
|
|
|
|
if (unlikely(dev->mtu >= BUF_SIZE_8KiB))
|
|
|
|
bfsize = BUF_SIZE_16KiB;
|
|
|
|
else if (unlikely(dev->mtu >= BUF_SIZE_4KiB))
|
|
|
|
bfsize = BUF_SIZE_8KiB;
|
|
|
|
else if (unlikely(dev->mtu >= BUF_SIZE_2KiB))
|
|
|
|
bfsize = BUF_SIZE_4KiB;
|
|
|
|
else if (unlikely(dev->mtu >= DMA_BUFFER_SIZE))
|
|
|
|
bfsize = BUF_SIZE_2KiB;
|
|
|
|
else
|
|
|
|
bfsize = DMA_BUFFER_SIZE;
|
|
|
|
|
2009-11-22 22:59:56 +00:00
|
|
|
#ifdef CONFIG_STMMAC_TIMER
|
|
|
|
/* Disable interrupts on completion for the reception if timer is on */
|
|
|
|
if (likely(priv->tm->enable))
|
|
|
|
dis_ic = 1;
|
|
|
|
#endif
|
2009-10-14 22:13:45 +00:00
|
|
|
/* If the MTU exceeds 8k so use the second buffer in the chain */
|
|
|
|
if (bfsize >= BUF_SIZE_8KiB)
|
|
|
|
buff2_needed = 1;
|
|
|
|
|
|
|
|
DBG(probe, INFO, "stmmac: txsize %d, rxsize %d, bfsize %d\n",
|
|
|
|
txsize, rxsize, bfsize);
|
|
|
|
|
|
|
|
priv->rx_skbuff_dma = kmalloc(rxsize * sizeof(dma_addr_t), GFP_KERNEL);
|
|
|
|
priv->rx_skbuff =
|
|
|
|
kmalloc(sizeof(struct sk_buff *) * rxsize, GFP_KERNEL);
|
|
|
|
priv->dma_rx =
|
|
|
|
(struct dma_desc *)dma_alloc_coherent(priv->device,
|
|
|
|
rxsize *
|
|
|
|
sizeof(struct dma_desc),
|
|
|
|
&priv->dma_rx_phy,
|
|
|
|
GFP_KERNEL);
|
|
|
|
priv->tx_skbuff = kmalloc(sizeof(struct sk_buff *) * txsize,
|
|
|
|
GFP_KERNEL);
|
|
|
|
priv->dma_tx =
|
|
|
|
(struct dma_desc *)dma_alloc_coherent(priv->device,
|
|
|
|
txsize *
|
|
|
|
sizeof(struct dma_desc),
|
|
|
|
&priv->dma_tx_phy,
|
|
|
|
GFP_KERNEL);
|
|
|
|
|
|
|
|
if ((priv->dma_rx == NULL) || (priv->dma_tx == NULL)) {
|
|
|
|
pr_err("%s:ERROR allocating the DMA Tx/Rx desc\n", __func__);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
DBG(probe, INFO, "stmmac (%s) DMA desc rings: virt addr (Rx %p, "
|
|
|
|
"Tx %p)\n\tDMA phy addr (Rx 0x%08x, Tx 0x%08x)\n",
|
|
|
|
dev->name, priv->dma_rx, priv->dma_tx,
|
|
|
|
(unsigned int)priv->dma_rx_phy, (unsigned int)priv->dma_tx_phy);
|
|
|
|
|
|
|
|
/* RX INITIALIZATION */
|
|
|
|
DBG(probe, INFO, "stmmac: SKB addresses:\n"
|
|
|
|
"skb\t\tskb data\tdma data\n");
|
|
|
|
|
|
|
|
for (i = 0; i < rxsize; i++) {
|
|
|
|
struct dma_desc *p = priv->dma_rx + i;
|
|
|
|
|
|
|
|
skb = netdev_alloc_skb_ip_align(dev, bfsize);
|
|
|
|
if (unlikely(skb == NULL)) {
|
|
|
|
pr_err("%s: Rx init fails; skb is NULL\n", __func__);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
priv->rx_skbuff[i] = skb;
|
|
|
|
priv->rx_skbuff_dma[i] = dma_map_single(priv->device, skb->data,
|
|
|
|
bfsize, DMA_FROM_DEVICE);
|
|
|
|
|
|
|
|
p->des2 = priv->rx_skbuff_dma[i];
|
|
|
|
if (unlikely(buff2_needed))
|
|
|
|
p->des3 = p->des2 + BUF_SIZE_8KiB;
|
|
|
|
DBG(probe, INFO, "[%p]\t[%p]\t[%x]\n", priv->rx_skbuff[i],
|
|
|
|
priv->rx_skbuff[i]->data, priv->rx_skbuff_dma[i]);
|
|
|
|
}
|
|
|
|
priv->cur_rx = 0;
|
|
|
|
priv->dirty_rx = (unsigned int)(i - rxsize);
|
|
|
|
priv->dma_buf_sz = bfsize;
|
|
|
|
buf_sz = bfsize;
|
|
|
|
|
|
|
|
/* TX INITIALIZATION */
|
|
|
|
for (i = 0; i < txsize; i++) {
|
|
|
|
priv->tx_skbuff[i] = NULL;
|
|
|
|
priv->dma_tx[i].des2 = 0;
|
|
|
|
}
|
|
|
|
priv->dirty_tx = 0;
|
|
|
|
priv->cur_tx = 0;
|
|
|
|
|
|
|
|
/* Clear the Rx/Tx descriptors */
|
2010-01-06 23:07:17 +00:00
|
|
|
priv->hw->desc->init_rx_desc(priv->dma_rx, rxsize, dis_ic);
|
|
|
|
priv->hw->desc->init_tx_desc(priv->dma_tx, txsize);
|
2009-10-14 22:13:45 +00:00
|
|
|
|
|
|
|
if (netif_msg_hw(priv)) {
|
|
|
|
pr_info("RX descriptor ring:\n");
|
|
|
|
display_ring(priv->dma_rx, rxsize);
|
|
|
|
pr_info("TX descriptor ring:\n");
|
|
|
|
display_ring(priv->dma_tx, txsize);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void dma_free_rx_skbufs(struct stmmac_priv *priv)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < priv->dma_rx_size; i++) {
|
|
|
|
if (priv->rx_skbuff[i]) {
|
|
|
|
dma_unmap_single(priv->device, priv->rx_skbuff_dma[i],
|
|
|
|
priv->dma_buf_sz, DMA_FROM_DEVICE);
|
|
|
|
dev_kfree_skb_any(priv->rx_skbuff[i]);
|
|
|
|
}
|
|
|
|
priv->rx_skbuff[i] = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void dma_free_tx_skbufs(struct stmmac_priv *priv)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < priv->dma_tx_size; i++) {
|
|
|
|
if (priv->tx_skbuff[i] != NULL) {
|
|
|
|
struct dma_desc *p = priv->dma_tx + i;
|
|
|
|
if (p->des2)
|
|
|
|
dma_unmap_single(priv->device, p->des2,
|
2010-01-06 23:07:17 +00:00
|
|
|
priv->hw->desc->get_tx_len(p),
|
|
|
|
DMA_TO_DEVICE);
|
2009-10-14 22:13:45 +00:00
|
|
|
dev_kfree_skb_any(priv->tx_skbuff[i]);
|
|
|
|
priv->tx_skbuff[i] = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void free_dma_desc_resources(struct stmmac_priv *priv)
|
|
|
|
{
|
|
|
|
/* Release the DMA TX/RX socket buffers */
|
|
|
|
dma_free_rx_skbufs(priv);
|
|
|
|
dma_free_tx_skbufs(priv);
|
|
|
|
|
|
|
|
/* Free the region of consistent memory previously allocated for
|
|
|
|
* the DMA */
|
|
|
|
dma_free_coherent(priv->device,
|
|
|
|
priv->dma_tx_size * sizeof(struct dma_desc),
|
|
|
|
priv->dma_tx, priv->dma_tx_phy);
|
|
|
|
dma_free_coherent(priv->device,
|
|
|
|
priv->dma_rx_size * sizeof(struct dma_desc),
|
|
|
|
priv->dma_rx, priv->dma_rx_phy);
|
|
|
|
kfree(priv->rx_skbuff_dma);
|
|
|
|
kfree(priv->rx_skbuff);
|
|
|
|
kfree(priv->tx_skbuff);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* stmmac_dma_operation_mode - HW DMA operation mode
|
|
|
|
* @priv : pointer to the private device structure.
|
|
|
|
* Description: it sets the DMA operation mode: tx/rx DMA thresholds
|
2010-09-17 03:23:40 +00:00
|
|
|
* or Store-And-Forward capability.
|
2009-10-14 22:13:45 +00:00
|
|
|
*/
|
|
|
|
static void stmmac_dma_operation_mode(struct stmmac_priv *priv)
|
|
|
|
{
|
2011-07-17 20:54:09 +00:00
|
|
|
if (likely(priv->plat->force_sf_dma_mode ||
|
|
|
|
((priv->plat->tx_coe) && (!priv->no_csum_insertion)))) {
|
|
|
|
/*
|
|
|
|
* In case of GMAC, SF mode can be enabled
|
|
|
|
* to perform the TX COE in HW. This depends on:
|
2010-09-17 03:23:40 +00:00
|
|
|
* 1) TX COE if actually supported
|
|
|
|
* 2) There is no bugged Jumbo frame support
|
|
|
|
* that needs to not insert csum in the TDES.
|
|
|
|
*/
|
|
|
|
priv->hw->dma->dma_mode(priv->ioaddr,
|
|
|
|
SF_DMA_MODE, SF_DMA_MODE);
|
|
|
|
tc = SF_DMA_MODE;
|
|
|
|
} else
|
|
|
|
priv->hw->dma->dma_mode(priv->ioaddr, tc, SF_DMA_MODE);
|
2009-10-14 22:13:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* stmmac_tx:
|
|
|
|
* @priv: private driver structure
|
|
|
|
* Description: it reclaims resources after transmission completes.
|
|
|
|
*/
|
|
|
|
static void stmmac_tx(struct stmmac_priv *priv)
|
|
|
|
{
|
|
|
|
unsigned int txsize = priv->dma_tx_size;
|
|
|
|
|
|
|
|
while (priv->dirty_tx != priv->cur_tx) {
|
|
|
|
int last;
|
|
|
|
unsigned int entry = priv->dirty_tx % txsize;
|
|
|
|
struct sk_buff *skb = priv->tx_skbuff[entry];
|
|
|
|
struct dma_desc *p = priv->dma_tx + entry;
|
|
|
|
|
|
|
|
/* Check if the descriptor is owned by the DMA. */
|
2010-01-06 23:07:17 +00:00
|
|
|
if (priv->hw->desc->get_tx_owner(p))
|
2009-10-14 22:13:45 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
/* Verify tx error by looking at the last segment */
|
2010-01-06 23:07:17 +00:00
|
|
|
last = priv->hw->desc->get_tx_ls(p);
|
2009-10-14 22:13:45 +00:00
|
|
|
if (likely(last)) {
|
|
|
|
int tx_error =
|
2010-01-06 23:07:17 +00:00
|
|
|
priv->hw->desc->tx_status(&priv->dev->stats,
|
|
|
|
&priv->xstats, p,
|
2010-08-23 20:40:42 +00:00
|
|
|
priv->ioaddr);
|
2009-10-14 22:13:45 +00:00
|
|
|
if (likely(tx_error == 0)) {
|
|
|
|
priv->dev->stats.tx_packets++;
|
|
|
|
priv->xstats.tx_pkt_n++;
|
|
|
|
} else
|
|
|
|
priv->dev->stats.tx_errors++;
|
|
|
|
}
|
|
|
|
TX_DBG("%s: curr %d, dirty %d\n", __func__,
|
|
|
|
priv->cur_tx, priv->dirty_tx);
|
|
|
|
|
|
|
|
if (likely(p->des2))
|
|
|
|
dma_unmap_single(priv->device, p->des2,
|
2010-01-06 23:07:17 +00:00
|
|
|
priv->hw->desc->get_tx_len(p),
|
2009-10-14 22:13:45 +00:00
|
|
|
DMA_TO_DEVICE);
|
|
|
|
if (unlikely(p->des3))
|
|
|
|
p->des3 = 0;
|
|
|
|
|
|
|
|
if (likely(skb != NULL)) {
|
|
|
|
/*
|
|
|
|
* If there's room in the queue (limit it to size)
|
|
|
|
* we add this skb back into the pool,
|
|
|
|
* if it's the right size.
|
|
|
|
*/
|
|
|
|
if ((skb_queue_len(&priv->rx_recycle) <
|
|
|
|
priv->dma_rx_size) &&
|
|
|
|
skb_recycle_check(skb, priv->dma_buf_sz))
|
|
|
|
__skb_queue_head(&priv->rx_recycle, skb);
|
|
|
|
else
|
|
|
|
dev_kfree_skb(skb);
|
|
|
|
|
|
|
|
priv->tx_skbuff[entry] = NULL;
|
|
|
|
}
|
|
|
|
|
2010-01-06 23:07:17 +00:00
|
|
|
priv->hw->desc->release_tx_desc(p);
|
2009-10-14 22:13:45 +00:00
|
|
|
|
|
|
|
entry = (++priv->dirty_tx) % txsize;
|
|
|
|
}
|
|
|
|
if (unlikely(netif_queue_stopped(priv->dev) &&
|
|
|
|
stmmac_tx_avail(priv) > STMMAC_TX_THRESH(priv))) {
|
|
|
|
netif_tx_lock(priv->dev);
|
|
|
|
if (netif_queue_stopped(priv->dev) &&
|
|
|
|
stmmac_tx_avail(priv) > STMMAC_TX_THRESH(priv)) {
|
|
|
|
TX_DBG("%s: restart transmit\n", __func__);
|
|
|
|
netif_wake_queue(priv->dev);
|
|
|
|
}
|
|
|
|
netif_tx_unlock(priv->dev);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void stmmac_enable_irq(struct stmmac_priv *priv)
|
|
|
|
{
|
2009-11-22 22:59:56 +00:00
|
|
|
#ifdef CONFIG_STMMAC_TIMER
|
|
|
|
if (likely(priv->tm->enable))
|
|
|
|
priv->tm->timer_start(tmrate);
|
|
|
|
else
|
2009-10-14 22:13:45 +00:00
|
|
|
#endif
|
2010-08-23 20:40:42 +00:00
|
|
|
priv->hw->dma->enable_dma_irq(priv->ioaddr);
|
2009-10-14 22:13:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void stmmac_disable_irq(struct stmmac_priv *priv)
|
|
|
|
{
|
2009-11-22 22:59:56 +00:00
|
|
|
#ifdef CONFIG_STMMAC_TIMER
|
|
|
|
if (likely(priv->tm->enable))
|
|
|
|
priv->tm->timer_stop();
|
|
|
|
else
|
2009-10-14 22:13:45 +00:00
|
|
|
#endif
|
2010-08-23 20:40:42 +00:00
|
|
|
priv->hw->dma->disable_dma_irq(priv->ioaddr);
|
2009-10-14 22:13:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int stmmac_has_work(struct stmmac_priv *priv)
|
|
|
|
{
|
|
|
|
unsigned int has_work = 0;
|
|
|
|
int rxret, tx_work = 0;
|
|
|
|
|
2010-01-06 23:07:17 +00:00
|
|
|
rxret = priv->hw->desc->get_rx_owner(priv->dma_rx +
|
2009-10-14 22:13:45 +00:00
|
|
|
(priv->cur_rx % priv->dma_rx_size));
|
|
|
|
|
|
|
|
if (priv->dirty_tx != priv->cur_tx)
|
|
|
|
tx_work = 1;
|
|
|
|
|
|
|
|
if (likely(!rxret || tx_work))
|
|
|
|
has_work = 1;
|
|
|
|
|
|
|
|
return has_work;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void _stmmac_schedule(struct stmmac_priv *priv)
|
|
|
|
{
|
|
|
|
if (likely(stmmac_has_work(priv))) {
|
|
|
|
stmmac_disable_irq(priv);
|
|
|
|
napi_schedule(&priv->napi);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_STMMAC_TIMER
|
|
|
|
void stmmac_schedule(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct stmmac_priv *priv = netdev_priv(dev);
|
|
|
|
|
|
|
|
priv->xstats.sched_timer_n++;
|
|
|
|
|
|
|
|
_stmmac_schedule(priv);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void stmmac_no_timer_started(unsigned int x)
|
|
|
|
{;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void stmmac_no_timer_stopped(void)
|
|
|
|
{;
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/**
|
|
|
|
* stmmac_tx_err:
|
|
|
|
* @priv: pointer to the private device structure
|
|
|
|
* Description: it cleans the descriptors and restarts the transmission
|
|
|
|
* in case of errors.
|
|
|
|
*/
|
|
|
|
static void stmmac_tx_err(struct stmmac_priv *priv)
|
|
|
|
{
|
2010-08-23 20:40:42 +00:00
|
|
|
|
2009-10-14 22:13:45 +00:00
|
|
|
netif_stop_queue(priv->dev);
|
|
|
|
|
2010-08-23 20:40:42 +00:00
|
|
|
priv->hw->dma->stop_tx(priv->ioaddr);
|
2009-10-14 22:13:45 +00:00
|
|
|
dma_free_tx_skbufs(priv);
|
2010-01-06 23:07:17 +00:00
|
|
|
priv->hw->desc->init_tx_desc(priv->dma_tx, priv->dma_tx_size);
|
2009-10-14 22:13:45 +00:00
|
|
|
priv->dirty_tx = 0;
|
|
|
|
priv->cur_tx = 0;
|
2010-08-23 20:40:42 +00:00
|
|
|
priv->hw->dma->start_tx(priv->ioaddr);
|
2009-10-14 22:13:45 +00:00
|
|
|
|
|
|
|
priv->dev->stats.tx_errors++;
|
|
|
|
netif_wake_queue(priv->dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-01-06 23:07:18 +00:00
|
|
|
static void stmmac_dma_interrupt(struct stmmac_priv *priv)
|
|
|
|
{
|
|
|
|
int status;
|
|
|
|
|
2010-08-23 20:40:42 +00:00
|
|
|
status = priv->hw->dma->dma_interrupt(priv->ioaddr, &priv->xstats);
|
2010-01-06 23:07:18 +00:00
|
|
|
if (likely(status == handle_tx_rx))
|
|
|
|
_stmmac_schedule(priv);
|
|
|
|
|
|
|
|
else if (unlikely(status == tx_hard_error_bump_tc)) {
|
|
|
|
/* Try to bump up the dma threshold on this failure */
|
|
|
|
if (unlikely(tc != SF_DMA_MODE) && (tc <= 256)) {
|
|
|
|
tc += 64;
|
2010-08-23 20:40:42 +00:00
|
|
|
priv->hw->dma->dma_mode(priv->ioaddr, tc, SF_DMA_MODE);
|
2010-01-06 23:07:18 +00:00
|
|
|
priv->xstats.threshold = tc;
|
2009-10-14 22:13:45 +00:00
|
|
|
}
|
2010-01-06 23:07:18 +00:00
|
|
|
} else if (unlikely(status == tx_hard_error))
|
|
|
|
stmmac_tx_err(priv);
|
2009-10-14 22:13:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* stmmac_open - open entry point of the driver
|
|
|
|
* @dev : pointer to the device structure.
|
|
|
|
* Description:
|
|
|
|
* This function is the open entry point of the driver.
|
|
|
|
* Return value:
|
|
|
|
* 0 on success and an appropriate (-)ve integer as defined in errno.h
|
|
|
|
* file on failure.
|
|
|
|
*/
|
|
|
|
static int stmmac_open(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct stmmac_priv *priv = netdev_priv(dev);
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* Check that the MAC address is valid. If its not, refuse
|
|
|
|
* to bring the device up. The user must specify an
|
|
|
|
* address using the following linux command:
|
|
|
|
* ifconfig eth0 hw ether xx:xx:xx:xx:xx:xx */
|
|
|
|
if (!is_valid_ether_addr(dev->dev_addr)) {
|
|
|
|
random_ether_addr(dev->dev_addr);
|
|
|
|
pr_warning("%s: generated random MAC address %pM\n", dev->name,
|
|
|
|
dev->dev_addr);
|
|
|
|
}
|
|
|
|
|
|
|
|
stmmac_verify_args();
|
|
|
|
|
|
|
|
#ifdef CONFIG_STMMAC_TIMER
|
2009-11-22 22:59:56 +00:00
|
|
|
priv->tm = kzalloc(sizeof(struct stmmac_timer *), GFP_KERNEL);
|
2009-10-14 22:13:45 +00:00
|
|
|
if (unlikely(priv->tm == NULL)) {
|
2010-03-24 07:57:36 +00:00
|
|
|
pr_err("%s: ERROR: timer memory alloc failed\n", __func__);
|
2009-10-14 22:13:45 +00:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
priv->tm->freq = tmrate;
|
|
|
|
|
2009-11-22 22:59:56 +00:00
|
|
|
/* Test if the external timer can be actually used.
|
|
|
|
* In case of failure continue without timer. */
|
2009-10-14 22:13:45 +00:00
|
|
|
if (unlikely((stmmac_open_ext_timer(dev, priv->tm)) < 0)) {
|
2009-11-22 22:59:56 +00:00
|
|
|
pr_warning("stmmaceth: cannot attach the external timer.\n");
|
2009-10-14 22:13:45 +00:00
|
|
|
priv->tm->freq = 0;
|
|
|
|
priv->tm->timer_start = stmmac_no_timer_started;
|
|
|
|
priv->tm->timer_stop = stmmac_no_timer_stopped;
|
2009-11-22 22:59:56 +00:00
|
|
|
} else
|
|
|
|
priv->tm->enable = 1;
|
2009-10-14 22:13:45 +00:00
|
|
|
#endif
|
2011-04-10 23:16:45 +00:00
|
|
|
ret = stmmac_init_phy(dev);
|
|
|
|
if (unlikely(ret)) {
|
|
|
|
pr_err("%s: Cannot attach to PHY (error: %d)\n", __func__, ret);
|
|
|
|
goto open_error;
|
|
|
|
}
|
2009-10-14 22:13:45 +00:00
|
|
|
|
|
|
|
/* Create and initialize the TX/RX descriptors chains. */
|
|
|
|
priv->dma_tx_size = STMMAC_ALIGN(dma_txsize);
|
|
|
|
priv->dma_rx_size = STMMAC_ALIGN(dma_rxsize);
|
|
|
|
priv->dma_buf_sz = STMMAC_ALIGN(buf_sz);
|
|
|
|
init_dma_desc_rings(dev);
|
|
|
|
|
|
|
|
/* DMA initialization and SW reset */
|
2011-04-10 23:16:45 +00:00
|
|
|
ret = priv->hw->dma->init(priv->ioaddr, priv->plat->pbl,
|
|
|
|
priv->dma_tx_phy, priv->dma_rx_phy);
|
|
|
|
if (ret < 0) {
|
2009-10-14 22:13:45 +00:00
|
|
|
pr_err("%s: DMA initialization failed\n", __func__);
|
2011-04-10 23:16:45 +00:00
|
|
|
goto open_error;
|
2009-10-14 22:13:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Copy the MAC addr into the HW */
|
2010-08-23 20:40:42 +00:00
|
|
|
priv->hw->mac->set_umac_addr(priv->ioaddr, dev->dev_addr, 0);
|
2010-01-06 23:07:15 +00:00
|
|
|
/* If required, perform hw setup of the bus. */
|
2010-11-24 02:37:58 +00:00
|
|
|
if (priv->plat->bus_setup)
|
|
|
|
priv->plat->bus_setup(priv->ioaddr);
|
2009-10-14 22:13:45 +00:00
|
|
|
/* Initialize the MAC Core */
|
2010-08-23 20:40:42 +00:00
|
|
|
priv->hw->mac->core_init(priv->ioaddr);
|
2009-10-14 22:13:45 +00:00
|
|
|
|
2010-09-17 03:23:40 +00:00
|
|
|
priv->rx_coe = priv->hw->mac->rx_coe(priv->ioaddr);
|
|
|
|
if (priv->rx_coe)
|
|
|
|
pr_info("stmmac: Rx Checksum Offload Engine supported\n");
|
2010-11-24 02:37:58 +00:00
|
|
|
if (priv->plat->tx_coe)
|
2010-09-17 03:23:40 +00:00
|
|
|
pr_info("\tTX Checksum insertion supported\n");
|
2011-04-09 02:46:55 +00:00
|
|
|
netdev_update_features(dev);
|
2010-09-17 03:23:40 +00:00
|
|
|
|
2011-04-10 23:16:45 +00:00
|
|
|
/* Request the IRQ lines */
|
|
|
|
ret = request_irq(dev->irq, stmmac_interrupt,
|
|
|
|
IRQF_SHARED, dev->name, dev);
|
|
|
|
if (unlikely(ret < 0)) {
|
|
|
|
pr_err("%s: ERROR: allocating the IRQ %d (error: %d)\n",
|
|
|
|
__func__, dev->irq, ret);
|
|
|
|
goto open_error;
|
|
|
|
}
|
|
|
|
|
2009-10-14 22:13:45 +00:00
|
|
|
/* Enable the MAC Rx/Tx */
|
2010-10-25 18:58:14 +00:00
|
|
|
stmmac_enable_mac(priv->ioaddr);
|
2009-10-14 22:13:45 +00:00
|
|
|
|
|
|
|
/* Set the HW DMA mode and the COE */
|
|
|
|
stmmac_dma_operation_mode(priv);
|
|
|
|
|
|
|
|
/* Extra statistics */
|
|
|
|
memset(&priv->xstats, 0, sizeof(struct stmmac_extra_stats));
|
|
|
|
priv->xstats.threshold = tc;
|
|
|
|
|
|
|
|
/* Start the ball rolling... */
|
|
|
|
DBG(probe, DEBUG, "%s: DMA RX/TX processes started...\n", dev->name);
|
2010-08-23 20:40:42 +00:00
|
|
|
priv->hw->dma->start_tx(priv->ioaddr);
|
|
|
|
priv->hw->dma->start_rx(priv->ioaddr);
|
2009-10-14 22:13:45 +00:00
|
|
|
|
|
|
|
#ifdef CONFIG_STMMAC_TIMER
|
|
|
|
priv->tm->timer_start(tmrate);
|
|
|
|
#endif
|
|
|
|
/* Dump DMA/MAC registers */
|
|
|
|
if (netif_msg_hw(priv)) {
|
2010-08-23 20:40:42 +00:00
|
|
|
priv->hw->mac->dump_regs(priv->ioaddr);
|
|
|
|
priv->hw->dma->dump_regs(priv->ioaddr);
|
2009-10-14 22:13:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (priv->phydev)
|
|
|
|
phy_start(priv->phydev);
|
|
|
|
|
|
|
|
napi_enable(&priv->napi);
|
|
|
|
skb_queue_head_init(&priv->rx_recycle);
|
|
|
|
netif_start_queue(dev);
|
2011-04-10 23:16:45 +00:00
|
|
|
|
2009-10-14 22:13:45 +00:00
|
|
|
return 0;
|
2011-04-10 23:16:45 +00:00
|
|
|
|
|
|
|
open_error:
|
|
|
|
#ifdef CONFIG_STMMAC_TIMER
|
|
|
|
kfree(priv->tm);
|
|
|
|
#endif
|
|
|
|
if (priv->phydev)
|
|
|
|
phy_disconnect(priv->phydev);
|
|
|
|
|
|
|
|
return ret;
|
2009-10-14 22:13:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* stmmac_release - close entry point of the driver
|
|
|
|
* @dev : device pointer.
|
|
|
|
* Description:
|
|
|
|
* This is the stop entry point of the driver.
|
|
|
|
*/
|
|
|
|
static int stmmac_release(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct stmmac_priv *priv = netdev_priv(dev);
|
|
|
|
|
|
|
|
/* Stop and disconnect the PHY */
|
|
|
|
if (priv->phydev) {
|
|
|
|
phy_stop(priv->phydev);
|
|
|
|
phy_disconnect(priv->phydev);
|
|
|
|
priv->phydev = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
netif_stop_queue(dev);
|
|
|
|
|
|
|
|
#ifdef CONFIG_STMMAC_TIMER
|
|
|
|
/* Stop and release the timer */
|
|
|
|
stmmac_close_ext_timer();
|
|
|
|
if (priv->tm != NULL)
|
|
|
|
kfree(priv->tm);
|
|
|
|
#endif
|
|
|
|
napi_disable(&priv->napi);
|
|
|
|
skb_queue_purge(&priv->rx_recycle);
|
|
|
|
|
|
|
|
/* Free the IRQ lines */
|
|
|
|
free_irq(dev->irq, dev);
|
|
|
|
|
|
|
|
/* Stop TX/RX DMA and clear the descriptors */
|
2010-08-23 20:40:42 +00:00
|
|
|
priv->hw->dma->stop_tx(priv->ioaddr);
|
|
|
|
priv->hw->dma->stop_rx(priv->ioaddr);
|
2009-10-14 22:13:45 +00:00
|
|
|
|
|
|
|
/* Release and free the Rx/Tx resources */
|
|
|
|
free_dma_desc_resources(priv);
|
|
|
|
|
2010-10-25 18:58:14 +00:00
|
|
|
/* Disable the MAC Rx/Tx */
|
|
|
|
stmmac_disable_mac(priv->ioaddr);
|
2009-10-14 22:13:45 +00:00
|
|
|
|
|
|
|
netif_carrier_off(dev);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned int stmmac_handle_jumbo_frames(struct sk_buff *skb,
|
|
|
|
struct net_device *dev,
|
|
|
|
int csum_insertion)
|
|
|
|
{
|
|
|
|
struct stmmac_priv *priv = netdev_priv(dev);
|
|
|
|
unsigned int nopaged_len = skb_headlen(skb);
|
|
|
|
unsigned int txsize = priv->dma_tx_size;
|
|
|
|
unsigned int entry = priv->cur_tx % txsize;
|
|
|
|
struct dma_desc *desc = priv->dma_tx + entry;
|
|
|
|
|
|
|
|
if (nopaged_len > BUF_SIZE_8KiB) {
|
|
|
|
|
|
|
|
int buf2_size = nopaged_len - BUF_SIZE_8KiB;
|
|
|
|
|
|
|
|
desc->des2 = dma_map_single(priv->device, skb->data,
|
|
|
|
BUF_SIZE_8KiB, DMA_TO_DEVICE);
|
|
|
|
desc->des3 = desc->des2 + BUF_SIZE_4KiB;
|
2010-01-06 23:07:17 +00:00
|
|
|
priv->hw->desc->prepare_tx_desc(desc, 1, BUF_SIZE_8KiB,
|
|
|
|
csum_insertion);
|
2009-10-14 22:13:45 +00:00
|
|
|
|
|
|
|
entry = (++priv->cur_tx) % txsize;
|
|
|
|
desc = priv->dma_tx + entry;
|
|
|
|
|
|
|
|
desc->des2 = dma_map_single(priv->device,
|
|
|
|
skb->data + BUF_SIZE_8KiB,
|
|
|
|
buf2_size, DMA_TO_DEVICE);
|
|
|
|
desc->des3 = desc->des2 + BUF_SIZE_4KiB;
|
2010-01-06 23:07:17 +00:00
|
|
|
priv->hw->desc->prepare_tx_desc(desc, 0, buf2_size,
|
|
|
|
csum_insertion);
|
|
|
|
priv->hw->desc->set_tx_owner(desc);
|
2009-10-14 22:13:45 +00:00
|
|
|
priv->tx_skbuff[entry] = NULL;
|
|
|
|
} else {
|
|
|
|
desc->des2 = dma_map_single(priv->device, skb->data,
|
|
|
|
nopaged_len, DMA_TO_DEVICE);
|
|
|
|
desc->des3 = desc->des2 + BUF_SIZE_4KiB;
|
2010-01-06 23:07:17 +00:00
|
|
|
priv->hw->desc->prepare_tx_desc(desc, 1, nopaged_len,
|
|
|
|
csum_insertion);
|
2009-10-14 22:13:45 +00:00
|
|
|
}
|
|
|
|
return entry;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* stmmac_xmit:
|
|
|
|
* @skb : the socket buffer
|
|
|
|
* @dev : device pointer
|
|
|
|
* Description : Tx entry point of the driver.
|
|
|
|
*/
|
|
|
|
static netdev_tx_t stmmac_xmit(struct sk_buff *skb, struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct stmmac_priv *priv = netdev_priv(dev);
|
|
|
|
unsigned int txsize = priv->dma_tx_size;
|
|
|
|
unsigned int entry;
|
|
|
|
int i, csum_insertion = 0;
|
|
|
|
int nfrags = skb_shinfo(skb)->nr_frags;
|
|
|
|
struct dma_desc *desc, *first;
|
|
|
|
|
|
|
|
if (unlikely(stmmac_tx_avail(priv) < nfrags + 1)) {
|
|
|
|
if (!netif_queue_stopped(dev)) {
|
|
|
|
netif_stop_queue(dev);
|
|
|
|
/* This is a hard error, log it. */
|
|
|
|
pr_err("%s: BUG! Tx Ring full when queue awake\n",
|
|
|
|
__func__);
|
|
|
|
}
|
|
|
|
return NETDEV_TX_BUSY;
|
|
|
|
}
|
|
|
|
|
|
|
|
entry = priv->cur_tx % txsize;
|
|
|
|
|
|
|
|
#ifdef STMMAC_XMIT_DEBUG
|
|
|
|
if ((skb->len > ETH_FRAME_LEN) || nfrags)
|
|
|
|
pr_info("stmmac xmit:\n"
|
|
|
|
"\tskb addr %p - len: %d - nopaged_len: %d\n"
|
|
|
|
"\tn_frags: %d - ip_summed: %d - %s gso\n",
|
|
|
|
skb, skb->len, skb_headlen(skb), nfrags, skb->ip_summed,
|
|
|
|
!skb_is_gso(skb) ? "isn't" : "is");
|
|
|
|
#endif
|
|
|
|
|
2011-04-09 02:46:55 +00:00
|
|
|
csum_insertion = (skb->ip_summed == CHECKSUM_PARTIAL);
|
2009-10-14 22:13:45 +00:00
|
|
|
|
|
|
|
desc = priv->dma_tx + entry;
|
|
|
|
first = desc;
|
|
|
|
|
|
|
|
#ifdef STMMAC_XMIT_DEBUG
|
|
|
|
if ((nfrags > 0) || (skb->len > ETH_FRAME_LEN))
|
|
|
|
pr_debug("stmmac xmit: skb len: %d, nopaged_len: %d,\n"
|
|
|
|
"\t\tn_frags: %d, ip_summed: %d\n",
|
|
|
|
skb->len, skb_headlen(skb), nfrags, skb->ip_summed);
|
|
|
|
#endif
|
|
|
|
priv->tx_skbuff[entry] = skb;
|
|
|
|
if (unlikely(skb->len >= BUF_SIZE_4KiB)) {
|
|
|
|
entry = stmmac_handle_jumbo_frames(skb, dev, csum_insertion);
|
|
|
|
desc = priv->dma_tx + entry;
|
|
|
|
} else {
|
|
|
|
unsigned int nopaged_len = skb_headlen(skb);
|
|
|
|
desc->des2 = dma_map_single(priv->device, skb->data,
|
|
|
|
nopaged_len, DMA_TO_DEVICE);
|
2010-01-06 23:07:17 +00:00
|
|
|
priv->hw->desc->prepare_tx_desc(desc, 1, nopaged_len,
|
|
|
|
csum_insertion);
|
2009-10-14 22:13:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < nfrags; i++) {
|
|
|
|
skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
|
|
|
|
int len = frag->size;
|
|
|
|
|
|
|
|
entry = (++priv->cur_tx) % txsize;
|
|
|
|
desc = priv->dma_tx + entry;
|
|
|
|
|
|
|
|
TX_DBG("\t[entry %d] segment len: %d\n", entry, len);
|
|
|
|
desc->des2 = dma_map_page(priv->device, frag->page,
|
|
|
|
frag->page_offset,
|
|
|
|
len, DMA_TO_DEVICE);
|
|
|
|
priv->tx_skbuff[entry] = NULL;
|
2010-01-06 23:07:17 +00:00
|
|
|
priv->hw->desc->prepare_tx_desc(desc, 0, len, csum_insertion);
|
2011-07-17 20:54:08 +00:00
|
|
|
wmb();
|
2010-01-06 23:07:17 +00:00
|
|
|
priv->hw->desc->set_tx_owner(desc);
|
2009-10-14 22:13:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Interrupt on completition only for the latest segment */
|
2010-01-06 23:07:17 +00:00
|
|
|
priv->hw->desc->close_tx_desc(desc);
|
2009-11-22 22:59:56 +00:00
|
|
|
|
2009-10-14 22:13:45 +00:00
|
|
|
#ifdef CONFIG_STMMAC_TIMER
|
2009-11-22 22:59:56 +00:00
|
|
|
/* Clean IC while using timer */
|
|
|
|
if (likely(priv->tm->enable))
|
2010-01-06 23:07:17 +00:00
|
|
|
priv->hw->desc->clear_tx_ic(desc);
|
2009-10-14 22:13:45 +00:00
|
|
|
#endif
|
2011-07-17 20:54:08 +00:00
|
|
|
|
|
|
|
wmb();
|
|
|
|
|
2009-10-14 22:13:45 +00:00
|
|
|
/* To avoid raise condition */
|
2010-01-06 23:07:17 +00:00
|
|
|
priv->hw->desc->set_tx_owner(first);
|
2009-10-14 22:13:45 +00:00
|
|
|
|
|
|
|
priv->cur_tx++;
|
|
|
|
|
|
|
|
#ifdef STMMAC_XMIT_DEBUG
|
|
|
|
if (netif_msg_pktdata(priv)) {
|
|
|
|
pr_info("stmmac xmit: current=%d, dirty=%d, entry=%d, "
|
|
|
|
"first=%p, nfrags=%d\n",
|
|
|
|
(priv->cur_tx % txsize), (priv->dirty_tx % txsize),
|
|
|
|
entry, first, nfrags);
|
|
|
|
display_ring(priv->dma_tx, txsize);
|
|
|
|
pr_info(">>> frame to be transmitted: ");
|
|
|
|
print_pkt(skb->data, skb->len);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
if (unlikely(stmmac_tx_avail(priv) <= (MAX_SKB_FRAGS + 1))) {
|
|
|
|
TX_DBG("%s: stop transmitted packets\n", __func__);
|
|
|
|
netif_stop_queue(dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
dev->stats.tx_bytes += skb->len;
|
|
|
|
|
2011-06-12 02:19:06 +00:00
|
|
|
skb_tx_timestamp(skb);
|
|
|
|
|
2011-06-19 03:31:43 +00:00
|
|
|
priv->hw->dma->enable_dma_transmission(priv->ioaddr);
|
|
|
|
|
2009-10-14 22:13:45 +00:00
|
|
|
return NETDEV_TX_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void stmmac_rx_refill(struct stmmac_priv *priv)
|
|
|
|
{
|
|
|
|
unsigned int rxsize = priv->dma_rx_size;
|
|
|
|
int bfsize = priv->dma_buf_sz;
|
|
|
|
struct dma_desc *p = priv->dma_rx;
|
|
|
|
|
|
|
|
for (; priv->cur_rx - priv->dirty_rx > 0; priv->dirty_rx++) {
|
|
|
|
unsigned int entry = priv->dirty_rx % rxsize;
|
|
|
|
if (likely(priv->rx_skbuff[entry] == NULL)) {
|
|
|
|
struct sk_buff *skb;
|
|
|
|
|
|
|
|
skb = __skb_dequeue(&priv->rx_recycle);
|
|
|
|
if (skb == NULL)
|
|
|
|
skb = netdev_alloc_skb_ip_align(priv->dev,
|
|
|
|
bfsize);
|
|
|
|
|
|
|
|
if (unlikely(skb == NULL))
|
|
|
|
break;
|
|
|
|
|
|
|
|
priv->rx_skbuff[entry] = skb;
|
|
|
|
priv->rx_skbuff_dma[entry] =
|
|
|
|
dma_map_single(priv->device, skb->data, bfsize,
|
|
|
|
DMA_FROM_DEVICE);
|
|
|
|
|
|
|
|
(p + entry)->des2 = priv->rx_skbuff_dma[entry];
|
2010-11-24 02:37:58 +00:00
|
|
|
if (unlikely(priv->plat->has_gmac)) {
|
2009-10-14 22:13:45 +00:00
|
|
|
if (bfsize >= BUF_SIZE_8KiB)
|
|
|
|
(p + entry)->des3 =
|
|
|
|
(p + entry)->des2 + BUF_SIZE_8KiB;
|
|
|
|
}
|
|
|
|
RX_DBG(KERN_INFO "\trefill entry #%d\n", entry);
|
|
|
|
}
|
2011-07-17 20:54:08 +00:00
|
|
|
wmb();
|
2010-01-06 23:07:17 +00:00
|
|
|
priv->hw->desc->set_rx_owner(p + entry);
|
2009-10-14 22:13:45 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int stmmac_rx(struct stmmac_priv *priv, int limit)
|
|
|
|
{
|
|
|
|
unsigned int rxsize = priv->dma_rx_size;
|
|
|
|
unsigned int entry = priv->cur_rx % rxsize;
|
|
|
|
unsigned int next_entry;
|
|
|
|
unsigned int count = 0;
|
|
|
|
struct dma_desc *p = priv->dma_rx + entry;
|
|
|
|
struct dma_desc *p_next;
|
|
|
|
|
|
|
|
#ifdef STMMAC_RX_DEBUG
|
|
|
|
if (netif_msg_hw(priv)) {
|
|
|
|
pr_debug(">>> stmmac_rx: descriptor ring:\n");
|
|
|
|
display_ring(priv->dma_rx, rxsize);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
count = 0;
|
2010-01-06 23:07:17 +00:00
|
|
|
while (!priv->hw->desc->get_rx_owner(p)) {
|
2009-10-14 22:13:45 +00:00
|
|
|
int status;
|
|
|
|
|
|
|
|
if (count >= limit)
|
|
|
|
break;
|
|
|
|
|
|
|
|
count++;
|
|
|
|
|
|
|
|
next_entry = (++priv->cur_rx) % rxsize;
|
|
|
|
p_next = priv->dma_rx + next_entry;
|
|
|
|
prefetch(p_next);
|
|
|
|
|
|
|
|
/* read the status of the incoming frame */
|
2010-01-06 23:07:17 +00:00
|
|
|
status = (priv->hw->desc->rx_status(&priv->dev->stats,
|
|
|
|
&priv->xstats, p));
|
2009-10-14 22:13:45 +00:00
|
|
|
if (unlikely(status == discard_frame))
|
|
|
|
priv->dev->stats.rx_errors++;
|
|
|
|
else {
|
|
|
|
struct sk_buff *skb;
|
2010-07-27 00:09:47 +00:00
|
|
|
int frame_len;
|
2009-10-14 22:13:45 +00:00
|
|
|
|
2010-07-27 00:09:47 +00:00
|
|
|
frame_len = priv->hw->desc->get_rx_frame_len(p);
|
|
|
|
/* ACS is set; GMAC core strips PAD/FCS for IEEE 802.3
|
|
|
|
* Type frames (LLC/LLC-SNAP) */
|
|
|
|
if (unlikely(status != llc_snap))
|
|
|
|
frame_len -= ETH_FCS_LEN;
|
2009-10-14 22:13:45 +00:00
|
|
|
#ifdef STMMAC_RX_DEBUG
|
|
|
|
if (frame_len > ETH_FRAME_LEN)
|
|
|
|
pr_debug("\tRX frame size %d, COE status: %d\n",
|
|
|
|
frame_len, status);
|
|
|
|
|
|
|
|
if (netif_msg_hw(priv))
|
|
|
|
pr_debug("\tdesc: %p [entry %d] buff=0x%x\n",
|
|
|
|
p, entry, p->des2);
|
|
|
|
#endif
|
|
|
|
skb = priv->rx_skbuff[entry];
|
|
|
|
if (unlikely(!skb)) {
|
|
|
|
pr_err("%s: Inconsistent Rx descriptor chain\n",
|
|
|
|
priv->dev->name);
|
|
|
|
priv->dev->stats.rx_dropped++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
prefetch(skb->data - NET_IP_ALIGN);
|
|
|
|
priv->rx_skbuff[entry] = NULL;
|
|
|
|
|
|
|
|
skb_put(skb, frame_len);
|
|
|
|
dma_unmap_single(priv->device,
|
|
|
|
priv->rx_skbuff_dma[entry],
|
|
|
|
priv->dma_buf_sz, DMA_FROM_DEVICE);
|
|
|
|
#ifdef STMMAC_RX_DEBUG
|
|
|
|
if (netif_msg_pktdata(priv)) {
|
|
|
|
pr_info(" frame received (%dbytes)", frame_len);
|
|
|
|
print_pkt(skb->data, frame_len);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
skb->protocol = eth_type_trans(skb, priv->dev);
|
|
|
|
|
|
|
|
if (unlikely(status == csum_none)) {
|
|
|
|
/* always for the old mac 10/100 */
|
2010-09-02 20:07:41 +00:00
|
|
|
skb_checksum_none_assert(skb);
|
2009-10-14 22:13:45 +00:00
|
|
|
netif_receive_skb(skb);
|
|
|
|
} else {
|
|
|
|
skb->ip_summed = CHECKSUM_UNNECESSARY;
|
|
|
|
napi_gro_receive(&priv->napi, skb);
|
|
|
|
}
|
|
|
|
|
|
|
|
priv->dev->stats.rx_packets++;
|
|
|
|
priv->dev->stats.rx_bytes += frame_len;
|
|
|
|
}
|
|
|
|
entry = next_entry;
|
|
|
|
p = p_next; /* use prefetched values */
|
|
|
|
}
|
|
|
|
|
|
|
|
stmmac_rx_refill(priv);
|
|
|
|
|
|
|
|
priv->xstats.rx_pkt_n += count;
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* stmmac_poll - stmmac poll method (NAPI)
|
|
|
|
* @napi : pointer to the napi structure.
|
|
|
|
* @budget : maximum number of packets that the current CPU can receive from
|
|
|
|
* all interfaces.
|
|
|
|
* Description :
|
|
|
|
* This function implements the the reception process.
|
|
|
|
* Also it runs the TX completion thread
|
|
|
|
*/
|
|
|
|
static int stmmac_poll(struct napi_struct *napi, int budget)
|
|
|
|
{
|
|
|
|
struct stmmac_priv *priv = container_of(napi, struct stmmac_priv, napi);
|
|
|
|
int work_done = 0;
|
|
|
|
|
|
|
|
priv->xstats.poll_n++;
|
|
|
|
stmmac_tx(priv);
|
|
|
|
work_done = stmmac_rx(priv, budget);
|
|
|
|
|
|
|
|
if (work_done < budget) {
|
|
|
|
napi_complete(napi);
|
|
|
|
stmmac_enable_irq(priv);
|
|
|
|
}
|
|
|
|
return work_done;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* stmmac_tx_timeout
|
|
|
|
* @dev : Pointer to net device structure
|
|
|
|
* Description: this function is called when a packet transmission fails to
|
|
|
|
* complete within a reasonable tmrate. The driver will mark the error in the
|
|
|
|
* netdev structure and arrange for the device to be reset to a sane state
|
|
|
|
* in order to transmit a new packet.
|
|
|
|
*/
|
|
|
|
static void stmmac_tx_timeout(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct stmmac_priv *priv = netdev_priv(dev);
|
|
|
|
|
|
|
|
/* Clear Tx resources and restart transmitting again */
|
|
|
|
stmmac_tx_err(priv);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Configuration changes (passed on by ifconfig) */
|
|
|
|
static int stmmac_config(struct net_device *dev, struct ifmap *map)
|
|
|
|
{
|
|
|
|
if (dev->flags & IFF_UP) /* can't act on a running interface */
|
|
|
|
return -EBUSY;
|
|
|
|
|
|
|
|
/* Don't allow changing the I/O address */
|
|
|
|
if (map->base_addr != dev->base_addr) {
|
|
|
|
pr_warning("%s: can't change I/O address\n", dev->name);
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Don't allow changing the IRQ */
|
|
|
|
if (map->irq != dev->irq) {
|
|
|
|
pr_warning("%s: can't change IRQ number %d\n",
|
|
|
|
dev->name, dev->irq);
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ignore other fields */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2011-08-16 06:29:00 +00:00
|
|
|
* stmmac_set_rx_mode - entry point for multicast addressing
|
2009-10-14 22:13:45 +00:00
|
|
|
* @dev : pointer to the device structure
|
|
|
|
* Description:
|
|
|
|
* This function is a driver entry point which gets called by the kernel
|
|
|
|
* whenever multicast addresses must be enabled/disabled.
|
|
|
|
* Return value:
|
|
|
|
* void.
|
|
|
|
*/
|
2011-08-16 06:29:00 +00:00
|
|
|
static void stmmac_set_rx_mode(struct net_device *dev)
|
2009-10-14 22:13:45 +00:00
|
|
|
{
|
|
|
|
struct stmmac_priv *priv = netdev_priv(dev);
|
|
|
|
|
|
|
|
spin_lock(&priv->lock);
|
2010-01-06 23:07:17 +00:00
|
|
|
priv->hw->mac->set_filter(dev);
|
2009-10-14 22:13:45 +00:00
|
|
|
spin_unlock(&priv->lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* stmmac_change_mtu - entry point to change MTU size for the device.
|
|
|
|
* @dev : device pointer.
|
|
|
|
* @new_mtu : the new MTU size for the device.
|
|
|
|
* Description: the Maximum Transfer Unit (MTU) is used by the network layer
|
|
|
|
* to drive packet transmission. Ethernet has an MTU of 1500 octets
|
|
|
|
* (ETH_DATA_LEN). This value can be changed with ifconfig.
|
|
|
|
* Return value:
|
|
|
|
* 0 on success and an appropriate (-)ve integer as defined in errno.h
|
|
|
|
* file on failure.
|
|
|
|
*/
|
|
|
|
static int stmmac_change_mtu(struct net_device *dev, int new_mtu)
|
|
|
|
{
|
|
|
|
struct stmmac_priv *priv = netdev_priv(dev);
|
|
|
|
int max_mtu;
|
|
|
|
|
|
|
|
if (netif_running(dev)) {
|
|
|
|
pr_err("%s: must be stopped to change its MTU\n", dev->name);
|
|
|
|
return -EBUSY;
|
|
|
|
}
|
|
|
|
|
2010-11-24 02:37:58 +00:00
|
|
|
if (priv->plat->has_gmac)
|
2009-10-14 22:13:45 +00:00
|
|
|
max_mtu = JUMBO_LEN;
|
|
|
|
else
|
|
|
|
max_mtu = ETH_DATA_LEN;
|
|
|
|
|
|
|
|
if ((new_mtu < 46) || (new_mtu > max_mtu)) {
|
|
|
|
pr_err("%s: invalid MTU, max MTU is: %d\n", dev->name, max_mtu);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2011-04-09 02:46:55 +00:00
|
|
|
dev->mtu = new_mtu;
|
|
|
|
netdev_update_features(dev);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static u32 stmmac_fix_features(struct net_device *dev, u32 features)
|
|
|
|
{
|
|
|
|
struct stmmac_priv *priv = netdev_priv(dev);
|
|
|
|
|
|
|
|
if (!priv->rx_coe)
|
|
|
|
features &= ~NETIF_F_RXCSUM;
|
|
|
|
if (!priv->plat->tx_coe)
|
|
|
|
features &= ~NETIF_F_ALL_CSUM;
|
|
|
|
|
2010-09-17 03:23:40 +00:00
|
|
|
/* Some GMAC devices have a bugged Jumbo frame support that
|
|
|
|
* needs to have the Tx COE disabled for oversized frames
|
|
|
|
* (due to limited buffer sizes). In this case we disable
|
|
|
|
* the TX csum insertionin the TDES and not use SF. */
|
2011-04-09 02:46:55 +00:00
|
|
|
if (priv->plat->bugged_jumbo && (dev->mtu > ETH_DATA_LEN))
|
|
|
|
features &= ~NETIF_F_ALL_CSUM;
|
2010-09-17 03:23:40 +00:00
|
|
|
|
2011-04-09 02:46:55 +00:00
|
|
|
return features;
|
2009-10-14 22:13:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static irqreturn_t stmmac_interrupt(int irq, void *dev_id)
|
|
|
|
{
|
|
|
|
struct net_device *dev = (struct net_device *)dev_id;
|
|
|
|
struct stmmac_priv *priv = netdev_priv(dev);
|
|
|
|
|
|
|
|
if (unlikely(!dev)) {
|
|
|
|
pr_err("%s: invalid dev pointer\n", __func__);
|
|
|
|
return IRQ_NONE;
|
|
|
|
}
|
|
|
|
|
2010-11-24 02:37:58 +00:00
|
|
|
if (priv->plat->has_gmac)
|
2009-10-14 22:13:45 +00:00
|
|
|
/* To handle GMAC own interrupts */
|
2010-08-23 20:40:42 +00:00
|
|
|
priv->hw->mac->host_irq_status((void __iomem *) dev->base_addr);
|
2010-01-06 23:07:18 +00:00
|
|
|
|
|
|
|
stmmac_dma_interrupt(priv);
|
2009-10-14 22:13:45 +00:00
|
|
|
|
|
|
|
return IRQ_HANDLED;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_NET_POLL_CONTROLLER
|
|
|
|
/* Polling receive - used by NETCONSOLE and other diagnostic tools
|
|
|
|
* to allow network I/O with interrupts disabled. */
|
|
|
|
static void stmmac_poll_controller(struct net_device *dev)
|
|
|
|
{
|
|
|
|
disable_irq(dev->irq);
|
|
|
|
stmmac_interrupt(dev->irq, dev);
|
|
|
|
enable_irq(dev->irq);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/**
|
|
|
|
* stmmac_ioctl - Entry point for the Ioctl
|
|
|
|
* @dev: Device pointer.
|
|
|
|
* @rq: An IOCTL specefic structure, that can contain a pointer to
|
|
|
|
* a proprietary structure used to pass information to the driver.
|
|
|
|
* @cmd: IOCTL command
|
|
|
|
* Description:
|
|
|
|
* Currently there are no special functionality supported in IOCTL, just the
|
|
|
|
* phy_mii_ioctl(...) can be invoked.
|
|
|
|
*/
|
|
|
|
static int stmmac_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
|
|
|
|
{
|
|
|
|
struct stmmac_priv *priv = netdev_priv(dev);
|
2010-07-17 08:48:55 +00:00
|
|
|
int ret;
|
2009-10-14 22:13:45 +00:00
|
|
|
|
|
|
|
if (!netif_running(dev))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2010-07-17 08:48:55 +00:00
|
|
|
if (!priv->phydev)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
spin_lock(&priv->lock);
|
|
|
|
ret = phy_mii_ioctl(priv->phydev, rq, cmd);
|
|
|
|
spin_unlock(&priv->lock);
|
|
|
|
|
2009-10-14 22:13:45 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct net_device_ops stmmac_netdev_ops = {
|
|
|
|
.ndo_open = stmmac_open,
|
|
|
|
.ndo_start_xmit = stmmac_xmit,
|
|
|
|
.ndo_stop = stmmac_release,
|
|
|
|
.ndo_change_mtu = stmmac_change_mtu,
|
2011-04-09 02:46:55 +00:00
|
|
|
.ndo_fix_features = stmmac_fix_features,
|
2011-08-16 06:29:00 +00:00
|
|
|
.ndo_set_rx_mode = stmmac_set_rx_mode,
|
2009-10-14 22:13:45 +00:00
|
|
|
.ndo_tx_timeout = stmmac_tx_timeout,
|
|
|
|
.ndo_do_ioctl = stmmac_ioctl,
|
|
|
|
.ndo_set_config = stmmac_config,
|
|
|
|
#ifdef CONFIG_NET_POLL_CONTROLLER
|
|
|
|
.ndo_poll_controller = stmmac_poll_controller,
|
|
|
|
#endif
|
|
|
|
.ndo_set_mac_address = eth_mac_addr,
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* stmmac_probe - Initialization of the adapter .
|
|
|
|
* @dev : device pointer
|
|
|
|
* Description: The function initializes the network device structure for
|
|
|
|
* the STMMAC driver. It also calls the low level routines
|
|
|
|
* in order to init the HW (i.e. the DMA engine)
|
|
|
|
*/
|
|
|
|
static int stmmac_probe(struct net_device *dev)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
struct stmmac_priv *priv = netdev_priv(dev);
|
|
|
|
|
|
|
|
ether_setup(dev);
|
|
|
|
|
|
|
|
dev->netdev_ops = &stmmac_netdev_ops;
|
|
|
|
stmmac_set_ethtool_ops(dev);
|
|
|
|
|
2011-04-09 02:46:55 +00:00
|
|
|
dev->hw_features = NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM;
|
|
|
|
dev->features |= dev->hw_features | NETIF_F_HIGHDMA;
|
2009-10-14 22:13:45 +00:00
|
|
|
dev->watchdog_timeo = msecs_to_jiffies(watchdog);
|
|
|
|
#ifdef STMMAC_VLAN_TAG_USED
|
|
|
|
/* Both mac100 and gmac support receive VLAN tag detection */
|
|
|
|
dev->features |= NETIF_F_HW_VLAN_RX;
|
|
|
|
#endif
|
|
|
|
priv->msg_enable = netif_msg_init(debug, default_msg_level);
|
|
|
|
|
|
|
|
if (flow_ctrl)
|
|
|
|
priv->flow_ctrl = FLOW_AUTO; /* RX/TX pause on */
|
|
|
|
|
|
|
|
priv->pause = pause;
|
|
|
|
netif_napi_add(dev, &priv->napi, stmmac_poll, 64);
|
|
|
|
|
|
|
|
/* Get the MAC address */
|
2010-08-23 20:40:42 +00:00
|
|
|
priv->hw->mac->get_umac_addr((void __iomem *) dev->base_addr,
|
|
|
|
dev->dev_addr, 0);
|
2009-10-14 22:13:45 +00:00
|
|
|
|
|
|
|
if (!is_valid_ether_addr(dev->dev_addr))
|
|
|
|
pr_warning("\tno valid MAC address;"
|
|
|
|
"please, use ifconfig or nwhwconfig!\n");
|
|
|
|
|
2010-11-29 22:52:52 +00:00
|
|
|
spin_lock_init(&priv->lock);
|
|
|
|
|
2009-10-14 22:13:45 +00:00
|
|
|
ret = register_netdev(dev);
|
|
|
|
if (ret) {
|
|
|
|
pr_err("%s: ERROR %i registering the device\n",
|
|
|
|
__func__, ret);
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
DBG(probe, DEBUG, "%s: Scatter/Gather: %s - HW checksums: %s\n",
|
|
|
|
dev->name, (dev->features & NETIF_F_SG) ? "on" : "off",
|
2010-11-30 06:38:00 +00:00
|
|
|
(dev->features & NETIF_F_IP_CSUM) ? "on" : "off");
|
2009-10-14 22:13:45 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* stmmac_mac_device_setup
|
|
|
|
* @dev : device pointer
|
|
|
|
* Description: select and initialise the mac device (mac100 or Gmac).
|
|
|
|
*/
|
|
|
|
static int stmmac_mac_device_setup(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct stmmac_priv *priv = netdev_priv(dev);
|
|
|
|
|
|
|
|
struct mac_device_info *device;
|
|
|
|
|
2011-08-16 06:29:00 +00:00
|
|
|
if (priv->plat->has_gmac) {
|
|
|
|
dev->priv_flags |= IFF_UNICAST_FLT;
|
2010-08-23 20:40:42 +00:00
|
|
|
device = dwmac1000_setup(priv->ioaddr);
|
2011-08-16 06:29:00 +00:00
|
|
|
} else {
|
2010-08-23 20:40:42 +00:00
|
|
|
device = dwmac100_setup(priv->ioaddr);
|
2011-08-16 06:29:00 +00:00
|
|
|
}
|
2010-04-13 20:21:15 +00:00
|
|
|
|
2010-07-22 01:16:48 +00:00
|
|
|
if (!device)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2010-11-24 02:37:58 +00:00
|
|
|
if (priv->plat->enh_desc) {
|
2010-04-13 20:21:15 +00:00
|
|
|
device->desc = &enh_desc_ops;
|
|
|
|
pr_info("\tEnhanced descriptor structure\n");
|
|
|
|
} else
|
2010-04-13 20:21:12 +00:00
|
|
|
device->desc = &ndesc_ops;
|
2009-10-14 22:13:45 +00:00
|
|
|
|
2010-01-06 23:07:17 +00:00
|
|
|
priv->hw = device;
|
2009-10-14 22:13:45 +00:00
|
|
|
|
2011-02-14 01:00:05 +00:00
|
|
|
if (device_can_wakeup(priv->device)) {
|
2010-09-25 04:27:41 +00:00
|
|
|
priv->wolopts = WAKE_MAGIC; /* Magic Frame as default */
|
2011-02-14 01:00:05 +00:00
|
|
|
enable_irq_wake(dev->irq);
|
|
|
|
}
|
2009-10-14 22:13:45 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* stmmac_dvr_probe
|
|
|
|
* @pdev: platform device pointer
|
|
|
|
* Description: the driver is initialized through platform_device.
|
|
|
|
*/
|
|
|
|
static int stmmac_dvr_probe(struct platform_device *pdev)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
struct resource *res;
|
2010-08-23 20:40:42 +00:00
|
|
|
void __iomem *addr = NULL;
|
2009-10-14 22:13:45 +00:00
|
|
|
struct net_device *ndev = NULL;
|
2010-11-24 02:38:05 +00:00
|
|
|
struct stmmac_priv *priv = NULL;
|
2009-10-14 22:13:45 +00:00
|
|
|
struct plat_stmmacenet_data *plat_dat;
|
|
|
|
|
|
|
|
pr_info("STMMAC driver:\n\tplatform registration... ");
|
|
|
|
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
2010-12-20 21:34:56 +00:00
|
|
|
if (!res)
|
|
|
|
return -ENODEV;
|
2010-09-17 03:23:40 +00:00
|
|
|
pr_info("\tdone!\n");
|
2009-10-14 22:13:45 +00:00
|
|
|
|
2010-04-08 04:50:08 +00:00
|
|
|
if (!request_mem_region(res->start, resource_size(res),
|
2009-10-14 22:13:45 +00:00
|
|
|
pdev->name)) {
|
|
|
|
pr_err("%s: ERROR: memory allocation failed"
|
|
|
|
"cannot get the I/O addr 0x%x\n",
|
|
|
|
__func__, (unsigned int)res->start);
|
2010-12-20 21:34:56 +00:00
|
|
|
return -EBUSY;
|
2009-10-14 22:13:45 +00:00
|
|
|
}
|
|
|
|
|
2010-03-22 02:11:11 +00:00
|
|
|
addr = ioremap(res->start, resource_size(res));
|
2009-10-14 22:13:45 +00:00
|
|
|
if (!addr) {
|
2010-03-22 02:11:11 +00:00
|
|
|
pr_err("%s: ERROR: memory mapping failed\n", __func__);
|
2009-10-14 22:13:45 +00:00
|
|
|
ret = -ENOMEM;
|
2010-12-20 21:34:56 +00:00
|
|
|
goto out_release_region;
|
2009-10-14 22:13:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
ndev = alloc_etherdev(sizeof(struct stmmac_priv));
|
|
|
|
if (!ndev) {
|
|
|
|
pr_err("%s: ERROR: allocating the device\n", __func__);
|
|
|
|
ret = -ENOMEM;
|
2010-12-20 21:34:56 +00:00
|
|
|
goto out_unmap;
|
2009-10-14 22:13:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
SET_NETDEV_DEV(ndev, &pdev->dev);
|
|
|
|
|
|
|
|
/* Get the MAC information */
|
|
|
|
ndev->irq = platform_get_irq_byname(pdev, "macirq");
|
|
|
|
if (ndev->irq == -ENXIO) {
|
|
|
|
pr_err("%s: ERROR: MAC IRQ configuration "
|
|
|
|
"information not found\n", __func__);
|
2010-12-20 21:34:56 +00:00
|
|
|
ret = -ENXIO;
|
|
|
|
goto out_free_ndev;
|
2009-10-14 22:13:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
priv = netdev_priv(ndev);
|
|
|
|
priv->device = &(pdev->dev);
|
|
|
|
priv->dev = ndev;
|
2010-01-06 23:07:14 +00:00
|
|
|
plat_dat = pdev->dev.platform_data;
|
2010-11-24 02:37:58 +00:00
|
|
|
|
|
|
|
priv->plat = plat_dat;
|
|
|
|
|
2010-08-23 20:40:42 +00:00
|
|
|
priv->ioaddr = addr;
|
2009-10-14 22:13:45 +00:00
|
|
|
|
2010-09-25 04:27:41 +00:00
|
|
|
/* PMT module is not integrated in all the MAC devices. */
|
|
|
|
if (plat_dat->pmt) {
|
|
|
|
pr_info("\tPMT module supported\n");
|
|
|
|
device_set_wakeup_capable(&pdev->dev, 1);
|
|
|
|
}
|
|
|
|
|
2009-10-14 22:13:45 +00:00
|
|
|
platform_set_drvdata(pdev, ndev);
|
|
|
|
|
|
|
|
/* Set the I/O base addr */
|
|
|
|
ndev->base_addr = (unsigned long)addr;
|
|
|
|
|
2010-11-24 02:38:05 +00:00
|
|
|
/* Custom initialisation */
|
|
|
|
if (priv->plat->init) {
|
|
|
|
ret = priv->plat->init(pdev);
|
|
|
|
if (unlikely(ret))
|
2010-12-20 21:34:56 +00:00
|
|
|
goto out_free_ndev;
|
2010-11-24 02:38:05 +00:00
|
|
|
}
|
2010-01-06 23:07:14 +00:00
|
|
|
|
2009-10-14 22:13:45 +00:00
|
|
|
/* MAC HW revice detection */
|
|
|
|
ret = stmmac_mac_device_setup(ndev);
|
|
|
|
if (ret < 0)
|
2010-12-20 21:34:56 +00:00
|
|
|
goto out_plat_exit;
|
2009-10-14 22:13:45 +00:00
|
|
|
|
|
|
|
/* Network Device Registration */
|
|
|
|
ret = stmmac_probe(ndev);
|
|
|
|
if (ret < 0)
|
2010-12-20 21:34:56 +00:00
|
|
|
goto out_plat_exit;
|
2009-10-14 22:13:45 +00:00
|
|
|
|
2011-07-20 00:05:23 +00:00
|
|
|
/* Override with kernel parameters if supplied XXX CRS XXX
|
|
|
|
* this needs to have multiple instances */
|
|
|
|
if ((phyaddr >= 0) && (phyaddr <= 31))
|
|
|
|
priv->plat->phy_addr = phyaddr;
|
2009-10-14 22:13:45 +00:00
|
|
|
|
|
|
|
pr_info("\t%s - (dev. name: %s - id: %d, IRQ #%d\n"
|
2010-08-31 04:55:17 +00:00
|
|
|
"\tIO base addr: 0x%p)\n", ndev->name, pdev->name,
|
|
|
|
pdev->id, ndev->irq, addr);
|
2009-10-14 22:13:45 +00:00
|
|
|
|
|
|
|
/* MDIO bus Registration */
|
2010-11-24 02:37:58 +00:00
|
|
|
pr_debug("\tMDIO bus (id: %d)...", priv->plat->bus_id);
|
2009-10-14 22:13:45 +00:00
|
|
|
ret = stmmac_mdio_register(ndev);
|
|
|
|
if (ret < 0)
|
2010-12-20 21:34:56 +00:00
|
|
|
goto out_unregister;
|
2009-10-14 22:13:45 +00:00
|
|
|
pr_debug("registered!\n");
|
2010-12-20 21:34:56 +00:00
|
|
|
return 0;
|
2009-10-14 22:13:45 +00:00
|
|
|
|
2010-12-20 21:34:56 +00:00
|
|
|
out_unregister:
|
|
|
|
unregister_netdev(ndev);
|
|
|
|
out_plat_exit:
|
|
|
|
if (priv->plat->exit)
|
|
|
|
priv->plat->exit(pdev);
|
|
|
|
out_free_ndev:
|
|
|
|
free_netdev(ndev);
|
|
|
|
platform_set_drvdata(pdev, NULL);
|
|
|
|
out_unmap:
|
|
|
|
iounmap(addr);
|
|
|
|
out_release_region:
|
|
|
|
release_mem_region(res->start, resource_size(res));
|
2009-10-14 22:13:45 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* stmmac_dvr_remove
|
|
|
|
* @pdev: platform device pointer
|
|
|
|
* Description: this function resets the TX/RX processes, disables the MAC RX/TX
|
|
|
|
* changes the link status, releases the DMA descriptor rings,
|
|
|
|
* unregisters the MDIO bus and unmaps the allocated memory.
|
|
|
|
*/
|
|
|
|
static int stmmac_dvr_remove(struct platform_device *pdev)
|
|
|
|
{
|
|
|
|
struct net_device *ndev = platform_get_drvdata(pdev);
|
2010-01-06 23:07:18 +00:00
|
|
|
struct stmmac_priv *priv = netdev_priv(ndev);
|
2009-10-14 22:13:45 +00:00
|
|
|
struct resource *res;
|
|
|
|
|
|
|
|
pr_info("%s:\n\tremoving driver", __func__);
|
|
|
|
|
2010-08-23 20:40:42 +00:00
|
|
|
priv->hw->dma->stop_rx(priv->ioaddr);
|
|
|
|
priv->hw->dma->stop_tx(priv->ioaddr);
|
2009-10-14 22:13:45 +00:00
|
|
|
|
2010-10-25 18:58:14 +00:00
|
|
|
stmmac_disable_mac(priv->ioaddr);
|
2009-10-14 22:13:45 +00:00
|
|
|
|
|
|
|
netif_carrier_off(ndev);
|
|
|
|
|
|
|
|
stmmac_mdio_unregister(ndev);
|
|
|
|
|
2010-11-24 02:38:05 +00:00
|
|
|
if (priv->plat->exit)
|
|
|
|
priv->plat->exit(pdev);
|
|
|
|
|
2009-10-14 22:13:45 +00:00
|
|
|
platform_set_drvdata(pdev, NULL);
|
|
|
|
unregister_netdev(ndev);
|
|
|
|
|
2010-08-23 20:40:42 +00:00
|
|
|
iounmap((void *)priv->ioaddr);
|
2009-10-14 22:13:45 +00:00
|
|
|
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
2010-03-22 02:11:11 +00:00
|
|
|
release_mem_region(res->start, resource_size(res));
|
2009-10-14 22:13:45 +00:00
|
|
|
|
|
|
|
free_netdev(ndev);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_PM
|
2010-11-24 02:38:11 +00:00
|
|
|
static int stmmac_suspend(struct device *dev)
|
2009-10-14 22:13:45 +00:00
|
|
|
{
|
2010-11-24 02:38:11 +00:00
|
|
|
struct net_device *ndev = dev_get_drvdata(dev);
|
|
|
|
struct stmmac_priv *priv = netdev_priv(ndev);
|
2009-10-14 22:13:45 +00:00
|
|
|
int dis_ic = 0;
|
|
|
|
|
2010-11-24 02:38:11 +00:00
|
|
|
if (!ndev || !netif_running(ndev))
|
2009-10-14 22:13:45 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
spin_lock(&priv->lock);
|
|
|
|
|
2010-11-24 02:38:11 +00:00
|
|
|
netif_device_detach(ndev);
|
|
|
|
netif_stop_queue(ndev);
|
|
|
|
if (priv->phydev)
|
|
|
|
phy_stop(priv->phydev);
|
2009-10-14 22:13:45 +00:00
|
|
|
|
|
|
|
#ifdef CONFIG_STMMAC_TIMER
|
2010-11-24 02:38:11 +00:00
|
|
|
priv->tm->timer_stop();
|
|
|
|
if (likely(priv->tm->enable))
|
|
|
|
dis_ic = 1;
|
2009-10-14 22:13:45 +00:00
|
|
|
#endif
|
2010-11-24 02:38:11 +00:00
|
|
|
napi_disable(&priv->napi);
|
|
|
|
|
|
|
|
/* Stop TX/RX DMA */
|
|
|
|
priv->hw->dma->stop_tx(priv->ioaddr);
|
|
|
|
priv->hw->dma->stop_rx(priv->ioaddr);
|
|
|
|
/* Clear the Rx/Tx descriptors */
|
|
|
|
priv->hw->desc->init_rx_desc(priv->dma_rx, priv->dma_rx_size,
|
|
|
|
dis_ic);
|
|
|
|
priv->hw->desc->init_tx_desc(priv->dma_tx, priv->dma_tx_size);
|
|
|
|
|
|
|
|
/* Enable Power down mode by programming the PMT regs */
|
|
|
|
if (device_may_wakeup(priv->device))
|
|
|
|
priv->hw->mac->pmt(priv->ioaddr, priv->wolopts);
|
|
|
|
else
|
|
|
|
stmmac_disable_mac(priv->ioaddr);
|
2009-10-14 22:13:45 +00:00
|
|
|
|
|
|
|
spin_unlock(&priv->lock);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-11-24 02:38:11 +00:00
|
|
|
static int stmmac_resume(struct device *dev)
|
2009-10-14 22:13:45 +00:00
|
|
|
{
|
2010-11-24 02:38:11 +00:00
|
|
|
struct net_device *ndev = dev_get_drvdata(dev);
|
|
|
|
struct stmmac_priv *priv = netdev_priv(ndev);
|
2009-10-14 22:13:45 +00:00
|
|
|
|
2010-11-24 02:38:11 +00:00
|
|
|
if (!netif_running(ndev))
|
2009-10-14 22:13:45 +00:00
|
|
|
return 0;
|
|
|
|
|
2010-09-06 03:02:11 +00:00
|
|
|
spin_lock(&priv->lock);
|
|
|
|
|
2009-10-14 22:13:45 +00:00
|
|
|
/* Power Down bit, into the PM register, is cleared
|
|
|
|
* automatically as soon as a magic packet or a Wake-up frame
|
|
|
|
* is received. Anyway, it's better to manually clear
|
|
|
|
* this bit because it can generate problems while resuming
|
|
|
|
* from another devices (e.g. serial console). */
|
2010-11-24 02:38:11 +00:00
|
|
|
if (device_may_wakeup(priv->device))
|
2010-09-25 04:27:41 +00:00
|
|
|
priv->hw->mac->pmt(priv->ioaddr, 0);
|
2009-10-14 22:13:45 +00:00
|
|
|
|
2010-11-24 02:38:11 +00:00
|
|
|
netif_device_attach(ndev);
|
2009-10-14 22:13:45 +00:00
|
|
|
|
|
|
|
/* Enable the MAC and DMA */
|
2010-10-25 18:58:14 +00:00
|
|
|
stmmac_enable_mac(priv->ioaddr);
|
2010-08-23 20:40:42 +00:00
|
|
|
priv->hw->dma->start_tx(priv->ioaddr);
|
|
|
|
priv->hw->dma->start_rx(priv->ioaddr);
|
2009-10-14 22:13:45 +00:00
|
|
|
|
|
|
|
#ifdef CONFIG_STMMAC_TIMER
|
2010-11-24 02:38:11 +00:00
|
|
|
if (likely(priv->tm->enable))
|
|
|
|
priv->tm->timer_start(tmrate);
|
2009-10-14 22:13:45 +00:00
|
|
|
#endif
|
|
|
|
napi_enable(&priv->napi);
|
|
|
|
|
|
|
|
if (priv->phydev)
|
|
|
|
phy_start(priv->phydev);
|
|
|
|
|
2010-11-24 02:38:11 +00:00
|
|
|
netif_start_queue(ndev);
|
2009-10-14 22:13:45 +00:00
|
|
|
|
|
|
|
spin_unlock(&priv->lock);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-11-24 02:38:11 +00:00
|
|
|
static int stmmac_freeze(struct device *dev)
|
|
|
|
{
|
|
|
|
struct net_device *ndev = dev_get_drvdata(dev);
|
|
|
|
|
|
|
|
if (!ndev || !netif_running(ndev))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return stmmac_release(ndev);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int stmmac_restore(struct device *dev)
|
|
|
|
{
|
|
|
|
struct net_device *ndev = dev_get_drvdata(dev);
|
|
|
|
|
|
|
|
if (!ndev || !netif_running(ndev))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return stmmac_open(ndev);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct dev_pm_ops stmmac_pm_ops = {
|
2009-10-14 22:13:45 +00:00
|
|
|
.suspend = stmmac_suspend,
|
|
|
|
.resume = stmmac_resume,
|
2010-11-24 02:38:11 +00:00
|
|
|
.freeze = stmmac_freeze,
|
|
|
|
.thaw = stmmac_restore,
|
|
|
|
.restore = stmmac_restore,
|
|
|
|
};
|
|
|
|
#else
|
|
|
|
static const struct dev_pm_ops stmmac_pm_ops;
|
|
|
|
#endif /* CONFIG_PM */
|
2009-10-14 22:13:45 +00:00
|
|
|
|
2010-11-24 02:38:11 +00:00
|
|
|
static struct platform_driver stmmac_driver = {
|
|
|
|
.probe = stmmac_dvr_probe,
|
|
|
|
.remove = stmmac_dvr_remove,
|
|
|
|
.driver = {
|
|
|
|
.name = STMMAC_RESOURCE_NAME,
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.pm = &stmmac_pm_ops,
|
|
|
|
},
|
2009-10-14 22:13:45 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* stmmac_init_module - Entry point for the driver
|
|
|
|
* Description: This function is the entry point for the driver.
|
|
|
|
*/
|
|
|
|
static int __init stmmac_init_module(void)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = platform_driver_register(&stmmac_driver);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* stmmac_cleanup_module - Cleanup routine for the driver
|
|
|
|
* Description: This function is the cleanup routine for the driver.
|
|
|
|
*/
|
|
|
|
static void __exit stmmac_cleanup_module(void)
|
|
|
|
{
|
|
|
|
platform_driver_unregister(&stmmac_driver);
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifndef MODULE
|
|
|
|
static int __init stmmac_cmdline_opt(char *str)
|
|
|
|
{
|
|
|
|
char *opt;
|
|
|
|
|
|
|
|
if (!str || !*str)
|
|
|
|
return -EINVAL;
|
|
|
|
while ((opt = strsep(&str, ",")) != NULL) {
|
2011-07-20 00:05:22 +00:00
|
|
|
if (!strncmp(opt, "debug:", 6)) {
|
|
|
|
if (strict_strtoul(opt + 6, 0, (unsigned long *)&debug))
|
|
|
|
goto err;
|
|
|
|
} else if (!strncmp(opt, "phyaddr:", 8)) {
|
|
|
|
if (strict_strtoul(opt + 8, 0,
|
|
|
|
(unsigned long *)&phyaddr))
|
|
|
|
goto err;
|
|
|
|
} else if (!strncmp(opt, "dma_txsize:", 11)) {
|
|
|
|
if (strict_strtoul(opt + 11, 0,
|
|
|
|
(unsigned long *)&dma_txsize))
|
|
|
|
goto err;
|
|
|
|
} else if (!strncmp(opt, "dma_rxsize:", 11)) {
|
|
|
|
if (strict_strtoul(opt + 11, 0,
|
|
|
|
(unsigned long *)&dma_rxsize))
|
|
|
|
goto err;
|
|
|
|
} else if (!strncmp(opt, "buf_sz:", 7)) {
|
|
|
|
if (strict_strtoul(opt + 7, 0,
|
|
|
|
(unsigned long *)&buf_sz))
|
|
|
|
goto err;
|
|
|
|
} else if (!strncmp(opt, "tc:", 3)) {
|
|
|
|
if (strict_strtoul(opt + 3, 0, (unsigned long *)&tc))
|
|
|
|
goto err;
|
|
|
|
} else if (!strncmp(opt, "watchdog:", 9)) {
|
|
|
|
if (strict_strtoul(opt + 9, 0,
|
|
|
|
(unsigned long *)&watchdog))
|
|
|
|
goto err;
|
|
|
|
} else if (!strncmp(opt, "flow_ctrl:", 10)) {
|
|
|
|
if (strict_strtoul(opt + 10, 0,
|
|
|
|
(unsigned long *)&flow_ctrl))
|
|
|
|
goto err;
|
|
|
|
} else if (!strncmp(opt, "pause:", 6)) {
|
|
|
|
if (strict_strtoul(opt + 6, 0, (unsigned long *)&pause))
|
|
|
|
goto err;
|
2009-10-14 22:13:45 +00:00
|
|
|
#ifdef CONFIG_STMMAC_TIMER
|
2011-07-20 00:05:22 +00:00
|
|
|
} else if (!strncmp(opt, "tmrate:", 7)) {
|
|
|
|
if (strict_strtoul(opt + 7, 0,
|
|
|
|
(unsigned long *)&tmrate))
|
|
|
|
goto err;
|
2009-10-14 22:13:45 +00:00
|
|
|
#endif
|
2011-07-20 00:05:22 +00:00
|
|
|
}
|
2009-10-14 22:13:45 +00:00
|
|
|
}
|
|
|
|
return 0;
|
2011-07-20 00:05:22 +00:00
|
|
|
|
|
|
|
err:
|
|
|
|
pr_err("%s: ERROR broken module parameter conversion", __func__);
|
|
|
|
return -EINVAL;
|
2009-10-14 22:13:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
__setup("stmmaceth=", stmmac_cmdline_opt);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
module_init(stmmac_init_module);
|
|
|
|
module_exit(stmmac_cleanup_module);
|
|
|
|
|
|
|
|
MODULE_DESCRIPTION("STMMAC 10/100/1000 Ethernet driver");
|
|
|
|
MODULE_AUTHOR("Giuseppe Cavallaro <peppe.cavallaro@st.com>");
|
|
|
|
MODULE_LICENSE("GPL");
|