2008-06-10 06:33:56 +07:00
|
|
|
/*
|
|
|
|
* SuperH Ethernet device driver
|
|
|
|
*
|
2008-06-30 09:08:17 +07:00
|
|
|
* Copyright (C) 2006-2008 Nobuhiro Iwamatsu
|
2009-05-25 06:54:21 +07:00
|
|
|
* Copyright (C) 2008-2009 Renesas Solutions Corp.
|
2008-06-10 06:33:56 +07:00
|
|
|
*
|
|
|
|
* 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".
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/dma-mapping.h>
|
|
|
|
#include <linux/etherdevice.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/platform_device.h>
|
|
|
|
#include <linux/mdio-bitbang.h>
|
|
|
|
#include <linux/netdevice.h>
|
|
|
|
#include <linux/phy.h>
|
|
|
|
#include <linux/cache.h>
|
|
|
|
#include <linux/io.h>
|
2009-10-09 07:20:04 +07:00
|
|
|
#include <linux/pm_runtime.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 15:04:11 +07:00
|
|
|
#include <linux/slab.h>
|
2009-10-26 20:49:50 +07:00
|
|
|
#include <asm/cacheflush.h>
|
2008-06-10 06:33:56 +07:00
|
|
|
|
|
|
|
#include "sh_eth.h"
|
|
|
|
|
2009-05-25 06:54:21 +07:00
|
|
|
/* There is CPU dependent code */
|
2009-05-25 06:54:30 +07:00
|
|
|
#if defined(CONFIG_CPU_SUBTYPE_SH7724)
|
|
|
|
#define SH_ETH_RESET_DEFAULT 1
|
|
|
|
static void sh_eth_set_duplex(struct net_device *ndev)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
u32 ioaddr = ndev->base_addr;
|
|
|
|
|
|
|
|
if (mdp->duplex) /* Full */
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(readl(ioaddr + ECMR) | ECMR_DM, ioaddr + ECMR);
|
2009-05-25 06:54:30 +07:00
|
|
|
else /* Half */
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(readl(ioaddr + ECMR) & ~ECMR_DM, ioaddr + ECMR);
|
2009-05-25 06:54:30 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void sh_eth_set_rate(struct net_device *ndev)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
u32 ioaddr = ndev->base_addr;
|
|
|
|
|
|
|
|
switch (mdp->speed) {
|
|
|
|
case 10: /* 10BASE */
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(readl(ioaddr + ECMR) & ~ECMR_RTM, ioaddr + ECMR);
|
2009-05-25 06:54:30 +07:00
|
|
|
break;
|
|
|
|
case 100:/* 100BASE */
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(readl(ioaddr + ECMR) | ECMR_RTM, ioaddr + ECMR);
|
2009-05-25 06:54:30 +07:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* SH7724 */
|
|
|
|
static struct sh_eth_cpu_data sh_eth_my_cpu_data = {
|
|
|
|
.set_duplex = sh_eth_set_duplex,
|
|
|
|
.set_rate = sh_eth_set_rate,
|
|
|
|
|
|
|
|
.ecsr_value = ECSR_PSRTO | ECSR_LCHNG | ECSR_ICD,
|
|
|
|
.ecsipr_value = ECSIPR_PSRTOIP | ECSIPR_LCHNGIP | ECSIPR_ICDIP,
|
|
|
|
.eesipr_value = DMAC_M_RFRMER | DMAC_M_ECI | 0x01ff009f,
|
|
|
|
|
|
|
|
.tx_check = EESR_FTC | EESR_CND | EESR_DLC | EESR_CD | EESR_RTO,
|
|
|
|
.eesr_err_check = EESR_TWB | EESR_TABT | EESR_RABT | EESR_RDE |
|
|
|
|
EESR_RFRMER | EESR_TFE | EESR_TDE | EESR_ECI,
|
|
|
|
.tx_error_check = EESR_TWB | EESR_TABT | EESR_TDE | EESR_TFE,
|
|
|
|
|
|
|
|
.apr = 1,
|
|
|
|
.mpr = 1,
|
|
|
|
.tpauser = 1,
|
|
|
|
.hw_swap = 1,
|
2009-12-16 12:16:55 +07:00
|
|
|
.rpadir = 1,
|
|
|
|
.rpadir_value = 0x00020000, /* NET_IP_ALIGN assumed to be 2 */
|
2009-05-25 06:54:30 +07:00
|
|
|
};
|
2010-07-06 01:32:50 +07:00
|
|
|
#elif defined(CONFIG_CPU_SUBTYPE_SH7757)
|
|
|
|
#define SH_ETH_RESET_DEFAULT 1
|
|
|
|
static void sh_eth_set_duplex(struct net_device *ndev)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
u32 ioaddr = ndev->base_addr;
|
|
|
|
|
|
|
|
if (mdp->duplex) /* Full */
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(readl(ioaddr + ECMR) | ECMR_DM, ioaddr + ECMR);
|
2010-07-06 01:32:50 +07:00
|
|
|
else /* Half */
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(readl(ioaddr + ECMR) & ~ECMR_DM, ioaddr + ECMR);
|
2010-07-06 01:32:50 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void sh_eth_set_rate(struct net_device *ndev)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
u32 ioaddr = ndev->base_addr;
|
|
|
|
|
|
|
|
switch (mdp->speed) {
|
|
|
|
case 10: /* 10BASE */
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(0, ioaddr + RTRATE);
|
2010-07-06 01:32:50 +07:00
|
|
|
break;
|
|
|
|
case 100:/* 100BASE */
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(1, ioaddr + RTRATE);
|
2010-07-06 01:32:50 +07:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* SH7757 */
|
|
|
|
static struct sh_eth_cpu_data sh_eth_my_cpu_data = {
|
|
|
|
.set_duplex = sh_eth_set_duplex,
|
|
|
|
.set_rate = sh_eth_set_rate,
|
|
|
|
|
|
|
|
.eesipr_value = DMAC_M_RFRMER | DMAC_M_ECI | 0x003fffff,
|
|
|
|
.rmcr_value = 0x00000001,
|
|
|
|
|
|
|
|
.tx_check = EESR_FTC | EESR_CND | EESR_DLC | EESR_CD | EESR_RTO,
|
|
|
|
.eesr_err_check = EESR_TWB | EESR_TABT | EESR_RABT | EESR_RDE |
|
|
|
|
EESR_RFRMER | EESR_TFE | EESR_TDE | EESR_ECI,
|
|
|
|
.tx_error_check = EESR_TWB | EESR_TABT | EESR_TDE | EESR_TFE,
|
|
|
|
|
|
|
|
.apr = 1,
|
|
|
|
.mpr = 1,
|
|
|
|
.tpauser = 1,
|
|
|
|
.hw_swap = 1,
|
|
|
|
.no_ade = 1,
|
|
|
|
};
|
2009-05-25 06:54:30 +07:00
|
|
|
|
|
|
|
#elif defined(CONFIG_CPU_SUBTYPE_SH7763)
|
2009-05-25 06:54:21 +07:00
|
|
|
#define SH_ETH_HAS_TSU 1
|
|
|
|
static void sh_eth_chip_reset(struct net_device *ndev)
|
|
|
|
{
|
|
|
|
/* reset device */
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(ARSTR_ARSTR, ARSTR);
|
2009-05-25 06:54:21 +07:00
|
|
|
mdelay(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void sh_eth_reset(struct net_device *ndev)
|
|
|
|
{
|
|
|
|
u32 ioaddr = ndev->base_addr;
|
|
|
|
int cnt = 100;
|
|
|
|
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(EDSR_ENALL, ioaddr + EDSR);
|
|
|
|
writel(readl(ioaddr + EDMR) | EDMR_SRST, ioaddr + EDMR);
|
2009-05-25 06:54:21 +07:00
|
|
|
while (cnt > 0) {
|
2010-11-01 16:29:24 +07:00
|
|
|
if (!(readl(ioaddr + EDMR) & 0x3))
|
2009-05-25 06:54:21 +07:00
|
|
|
break;
|
|
|
|
mdelay(1);
|
|
|
|
cnt--;
|
|
|
|
}
|
2009-12-30 08:43:45 +07:00
|
|
|
if (cnt == 0)
|
2009-05-25 06:54:21 +07:00
|
|
|
printk(KERN_ERR "Device reset fail\n");
|
|
|
|
|
|
|
|
/* Table Init */
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(0x0, ioaddr + TDLAR);
|
|
|
|
writel(0x0, ioaddr + TDFAR);
|
|
|
|
writel(0x0, ioaddr + TDFXR);
|
|
|
|
writel(0x0, ioaddr + TDFFR);
|
|
|
|
writel(0x0, ioaddr + RDLAR);
|
|
|
|
writel(0x0, ioaddr + RDFAR);
|
|
|
|
writel(0x0, ioaddr + RDFXR);
|
|
|
|
writel(0x0, ioaddr + RDFFR);
|
2009-05-25 06:54:21 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void sh_eth_set_duplex(struct net_device *ndev)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
u32 ioaddr = ndev->base_addr;
|
|
|
|
|
|
|
|
if (mdp->duplex) /* Full */
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(readl(ioaddr + ECMR) | ECMR_DM, ioaddr + ECMR);
|
2009-05-25 06:54:21 +07:00
|
|
|
else /* Half */
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(readl(ioaddr + ECMR) & ~ECMR_DM, ioaddr + ECMR);
|
2009-05-25 06:54:21 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void sh_eth_set_rate(struct net_device *ndev)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
u32 ioaddr = ndev->base_addr;
|
|
|
|
|
|
|
|
switch (mdp->speed) {
|
|
|
|
case 10: /* 10BASE */
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(GECMR_10, ioaddr + GECMR);
|
2009-05-25 06:54:21 +07:00
|
|
|
break;
|
|
|
|
case 100:/* 100BASE */
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(GECMR_100, ioaddr + GECMR);
|
2009-05-25 06:54:21 +07:00
|
|
|
break;
|
|
|
|
case 1000: /* 1000BASE */
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(GECMR_1000, ioaddr + GECMR);
|
2009-05-25 06:54:21 +07:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* sh7763 */
|
|
|
|
static struct sh_eth_cpu_data sh_eth_my_cpu_data = {
|
|
|
|
.chip_reset = sh_eth_chip_reset,
|
|
|
|
.set_duplex = sh_eth_set_duplex,
|
|
|
|
.set_rate = sh_eth_set_rate,
|
|
|
|
|
|
|
|
.ecsr_value = ECSR_ICD | ECSR_MPD,
|
|
|
|
.ecsipr_value = ECSIPR_LCHNGIP | ECSIPR_ICDIP | ECSIPR_MPDIP,
|
|
|
|
.eesipr_value = DMAC_M_RFRMER | DMAC_M_ECI | 0x003fffff,
|
|
|
|
|
|
|
|
.tx_check = EESR_TC1 | EESR_FTC,
|
|
|
|
.eesr_err_check = EESR_TWB1 | EESR_TWB | EESR_TABT | EESR_RABT | \
|
|
|
|
EESR_RDE | EESR_RFRMER | EESR_TFE | EESR_TDE | \
|
|
|
|
EESR_ECI,
|
|
|
|
.tx_error_check = EESR_TWB1 | EESR_TWB | EESR_TABT | EESR_TDE | \
|
|
|
|
EESR_TFE,
|
|
|
|
|
|
|
|
.apr = 1,
|
|
|
|
.mpr = 1,
|
|
|
|
.tpauser = 1,
|
|
|
|
.bculr = 1,
|
|
|
|
.hw_swap = 1,
|
|
|
|
.no_trimd = 1,
|
|
|
|
.no_ade = 1,
|
|
|
|
};
|
|
|
|
|
|
|
|
#elif defined(CONFIG_CPU_SUBTYPE_SH7619)
|
|
|
|
#define SH_ETH_RESET_DEFAULT 1
|
|
|
|
static struct sh_eth_cpu_data sh_eth_my_cpu_data = {
|
|
|
|
.eesipr_value = DMAC_M_RFRMER | DMAC_M_ECI | 0x003fffff,
|
|
|
|
|
|
|
|
.apr = 1,
|
|
|
|
.mpr = 1,
|
|
|
|
.tpauser = 1,
|
|
|
|
.hw_swap = 1,
|
|
|
|
};
|
|
|
|
#elif defined(CONFIG_CPU_SUBTYPE_SH7710) || defined(CONFIG_CPU_SUBTYPE_SH7712)
|
|
|
|
#define SH_ETH_RESET_DEFAULT 1
|
|
|
|
#define SH_ETH_HAS_TSU 1
|
|
|
|
static struct sh_eth_cpu_data sh_eth_my_cpu_data = {
|
|
|
|
.eesipr_value = DMAC_M_RFRMER | DMAC_M_ECI | 0x003fffff,
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static void sh_eth_set_default_cpu_data(struct sh_eth_cpu_data *cd)
|
|
|
|
{
|
|
|
|
if (!cd->ecsr_value)
|
|
|
|
cd->ecsr_value = DEFAULT_ECSR_INIT;
|
|
|
|
|
|
|
|
if (!cd->ecsipr_value)
|
|
|
|
cd->ecsipr_value = DEFAULT_ECSIPR_INIT;
|
|
|
|
|
|
|
|
if (!cd->fcftr_value)
|
|
|
|
cd->fcftr_value = DEFAULT_FIFO_F_D_RFF | \
|
|
|
|
DEFAULT_FIFO_F_D_RFD;
|
|
|
|
|
|
|
|
if (!cd->fdr_value)
|
|
|
|
cd->fdr_value = DEFAULT_FDR_INIT;
|
|
|
|
|
|
|
|
if (!cd->rmcr_value)
|
|
|
|
cd->rmcr_value = DEFAULT_RMCR_VALUE;
|
|
|
|
|
|
|
|
if (!cd->tx_check)
|
|
|
|
cd->tx_check = DEFAULT_TX_CHECK;
|
|
|
|
|
|
|
|
if (!cd->eesr_err_check)
|
|
|
|
cd->eesr_err_check = DEFAULT_EESR_ERR_CHECK;
|
|
|
|
|
|
|
|
if (!cd->tx_error_check)
|
|
|
|
cd->tx_error_check = DEFAULT_TX_ERROR_CHECK;
|
|
|
|
}
|
|
|
|
|
|
|
|
#if defined(SH_ETH_RESET_DEFAULT)
|
|
|
|
/* Chip Reset */
|
|
|
|
static void sh_eth_reset(struct net_device *ndev)
|
|
|
|
{
|
|
|
|
u32 ioaddr = ndev->base_addr;
|
|
|
|
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(readl(ioaddr + EDMR) | EDMR_SRST, ioaddr + EDMR);
|
2009-05-25 06:54:21 +07:00
|
|
|
mdelay(3);
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(readl(ioaddr + EDMR) & ~EDMR_SRST, ioaddr + EDMR);
|
2009-05-25 06:54:21 +07:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if defined(CONFIG_CPU_SH4)
|
|
|
|
static void sh_eth_set_receive_align(struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
int reserve;
|
|
|
|
|
|
|
|
reserve = SH4_SKB_RX_ALIGN - ((u32)skb->data & (SH4_SKB_RX_ALIGN - 1));
|
|
|
|
if (reserve)
|
|
|
|
skb_reserve(skb, reserve);
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static void sh_eth_set_receive_align(struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
skb_reserve(skb, SH2_SH3_SKB_RX_ALIGN);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
2008-08-07 06:49:00 +07:00
|
|
|
/* CPU <-> EDMAC endian convert */
|
|
|
|
static inline __u32 cpu_to_edmac(struct sh_eth_private *mdp, u32 x)
|
|
|
|
{
|
|
|
|
switch (mdp->edmac_endian) {
|
|
|
|
case EDMAC_LITTLE_ENDIAN:
|
|
|
|
return cpu_to_le32(x);
|
|
|
|
case EDMAC_BIG_ENDIAN:
|
|
|
|
return cpu_to_be32(x);
|
|
|
|
}
|
|
|
|
return x;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline __u32 edmac_to_cpu(struct sh_eth_private *mdp, u32 x)
|
|
|
|
{
|
|
|
|
switch (mdp->edmac_endian) {
|
|
|
|
case EDMAC_LITTLE_ENDIAN:
|
|
|
|
return le32_to_cpu(x);
|
|
|
|
case EDMAC_BIG_ENDIAN:
|
|
|
|
return be32_to_cpu(x);
|
|
|
|
}
|
|
|
|
return x;
|
|
|
|
}
|
|
|
|
|
2008-06-10 06:33:56 +07:00
|
|
|
/*
|
|
|
|
* Program the hardware MAC address from dev->dev_addr.
|
|
|
|
*/
|
|
|
|
static void update_mac_address(struct net_device *ndev)
|
|
|
|
{
|
|
|
|
u32 ioaddr = ndev->base_addr;
|
|
|
|
|
2010-11-01 16:29:24 +07:00
|
|
|
writel((ndev->dev_addr[0] << 24) | (ndev->dev_addr[1] << 16) |
|
2008-06-10 06:33:56 +07:00
|
|
|
(ndev->dev_addr[2] << 8) | (ndev->dev_addr[3]),
|
|
|
|
ioaddr + MAHR);
|
2010-11-01 16:29:24 +07:00
|
|
|
writel((ndev->dev_addr[4] << 8) | (ndev->dev_addr[5]),
|
2008-06-10 06:33:56 +07:00
|
|
|
ioaddr + MALR);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Get MAC address from SuperH MAC address register
|
|
|
|
*
|
|
|
|
* SuperH's Ethernet device doesn't have 'ROM' to MAC address.
|
|
|
|
* This driver get MAC address that use by bootloader(U-boot or sh-ipl+g).
|
|
|
|
* When you want use this device, you must set MAC address in bootloader.
|
|
|
|
*
|
|
|
|
*/
|
2009-10-09 07:17:14 +07:00
|
|
|
static void read_mac_address(struct net_device *ndev, unsigned char *mac)
|
2008-06-10 06:33:56 +07:00
|
|
|
{
|
|
|
|
u32 ioaddr = ndev->base_addr;
|
|
|
|
|
2009-10-09 07:17:14 +07:00
|
|
|
if (mac[0] || mac[1] || mac[2] || mac[3] || mac[4] || mac[5]) {
|
|
|
|
memcpy(ndev->dev_addr, mac, 6);
|
|
|
|
} else {
|
2010-11-01 16:29:24 +07:00
|
|
|
ndev->dev_addr[0] = (readl(ioaddr + MAHR) >> 24);
|
|
|
|
ndev->dev_addr[1] = (readl(ioaddr + MAHR) >> 16) & 0xFF;
|
|
|
|
ndev->dev_addr[2] = (readl(ioaddr + MAHR) >> 8) & 0xFF;
|
|
|
|
ndev->dev_addr[3] = (readl(ioaddr + MAHR) & 0xFF);
|
|
|
|
ndev->dev_addr[4] = (readl(ioaddr + MALR) >> 8) & 0xFF;
|
|
|
|
ndev->dev_addr[5] = (readl(ioaddr + MALR) & 0xFF);
|
2009-10-09 07:17:14 +07:00
|
|
|
}
|
2008-06-10 06:33:56 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
struct bb_info {
|
|
|
|
struct mdiobb_ctrl ctrl;
|
|
|
|
u32 addr;
|
|
|
|
u32 mmd_msk;/* MMD */
|
|
|
|
u32 mdo_msk;
|
|
|
|
u32 mdi_msk;
|
|
|
|
u32 mdc_msk;
|
|
|
|
};
|
|
|
|
|
|
|
|
/* PHY bit set */
|
|
|
|
static void bb_set(u32 addr, u32 msk)
|
|
|
|
{
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(readl(addr) | msk, addr);
|
2008-06-10 06:33:56 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* PHY bit clear */
|
|
|
|
static void bb_clr(u32 addr, u32 msk)
|
|
|
|
{
|
2010-11-01 16:29:24 +07:00
|
|
|
writel((readl(addr) & ~msk), addr);
|
2008-06-10 06:33:56 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* PHY bit read */
|
|
|
|
static int bb_read(u32 addr, u32 msk)
|
|
|
|
{
|
2010-11-01 16:29:24 +07:00
|
|
|
return (readl(addr) & msk) != 0;
|
2008-06-10 06:33:56 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Data I/O pin control */
|
|
|
|
static void sh_mmd_ctrl(struct mdiobb_ctrl *ctrl, int bit)
|
|
|
|
{
|
|
|
|
struct bb_info *bitbang = container_of(ctrl, struct bb_info, ctrl);
|
|
|
|
if (bit)
|
|
|
|
bb_set(bitbang->addr, bitbang->mmd_msk);
|
|
|
|
else
|
|
|
|
bb_clr(bitbang->addr, bitbang->mmd_msk);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Set bit data*/
|
|
|
|
static void sh_set_mdio(struct mdiobb_ctrl *ctrl, int bit)
|
|
|
|
{
|
|
|
|
struct bb_info *bitbang = container_of(ctrl, struct bb_info, ctrl);
|
|
|
|
|
|
|
|
if (bit)
|
|
|
|
bb_set(bitbang->addr, bitbang->mdo_msk);
|
|
|
|
else
|
|
|
|
bb_clr(bitbang->addr, bitbang->mdo_msk);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Get bit data*/
|
|
|
|
static int sh_get_mdio(struct mdiobb_ctrl *ctrl)
|
|
|
|
{
|
|
|
|
struct bb_info *bitbang = container_of(ctrl, struct bb_info, ctrl);
|
|
|
|
return bb_read(bitbang->addr, bitbang->mdi_msk);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* MDC pin control */
|
|
|
|
static void sh_mdc_ctrl(struct mdiobb_ctrl *ctrl, int bit)
|
|
|
|
{
|
|
|
|
struct bb_info *bitbang = container_of(ctrl, struct bb_info, ctrl);
|
|
|
|
|
|
|
|
if (bit)
|
|
|
|
bb_set(bitbang->addr, bitbang->mdc_msk);
|
|
|
|
else
|
|
|
|
bb_clr(bitbang->addr, bitbang->mdc_msk);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* mdio bus control struct */
|
|
|
|
static struct mdiobb_ops bb_ops = {
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.set_mdc = sh_mdc_ctrl,
|
|
|
|
.set_mdio_dir = sh_mmd_ctrl,
|
|
|
|
.set_mdio_data = sh_set_mdio,
|
|
|
|
.get_mdio_data = sh_get_mdio,
|
|
|
|
};
|
|
|
|
|
|
|
|
/* free skb and descriptor buffer */
|
|
|
|
static void sh_eth_ring_free(struct net_device *ndev)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* Free Rx skb ringbuffer */
|
|
|
|
if (mdp->rx_skbuff) {
|
|
|
|
for (i = 0; i < RX_RING_SIZE; i++) {
|
|
|
|
if (mdp->rx_skbuff[i])
|
|
|
|
dev_kfree_skb(mdp->rx_skbuff[i]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
kfree(mdp->rx_skbuff);
|
|
|
|
|
|
|
|
/* Free Tx skb ringbuffer */
|
|
|
|
if (mdp->tx_skbuff) {
|
|
|
|
for (i = 0; i < TX_RING_SIZE; i++) {
|
|
|
|
if (mdp->tx_skbuff[i])
|
|
|
|
dev_kfree_skb(mdp->tx_skbuff[i]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
kfree(mdp->tx_skbuff);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* format skb and descriptor buffer */
|
|
|
|
static void sh_eth_ring_format(struct net_device *ndev)
|
|
|
|
{
|
2009-05-25 06:54:21 +07:00
|
|
|
u32 ioaddr = ndev->base_addr;
|
2008-06-10 06:33:56 +07:00
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
int i;
|
|
|
|
struct sk_buff *skb;
|
|
|
|
struct sh_eth_rxdesc *rxdesc = NULL;
|
|
|
|
struct sh_eth_txdesc *txdesc = NULL;
|
|
|
|
int rx_ringsize = sizeof(*rxdesc) * RX_RING_SIZE;
|
|
|
|
int tx_ringsize = sizeof(*txdesc) * TX_RING_SIZE;
|
|
|
|
|
|
|
|
mdp->cur_rx = mdp->cur_tx = 0;
|
|
|
|
mdp->dirty_rx = mdp->dirty_tx = 0;
|
|
|
|
|
|
|
|
memset(mdp->rx_ring, 0, rx_ringsize);
|
|
|
|
|
|
|
|
/* build Rx ring buffer */
|
|
|
|
for (i = 0; i < RX_RING_SIZE; i++) {
|
|
|
|
/* skb */
|
|
|
|
mdp->rx_skbuff[i] = NULL;
|
|
|
|
skb = dev_alloc_skb(mdp->rx_buf_sz);
|
|
|
|
mdp->rx_skbuff[i] = skb;
|
|
|
|
if (skb == NULL)
|
|
|
|
break;
|
2009-05-25 06:52:35 +07:00
|
|
|
dma_map_single(&ndev->dev, skb->tail, mdp->rx_buf_sz,
|
|
|
|
DMA_FROM_DEVICE);
|
2008-06-30 09:08:17 +07:00
|
|
|
skb->dev = ndev; /* Mark as being used by this device. */
|
2009-05-25 06:54:21 +07:00
|
|
|
sh_eth_set_receive_align(skb);
|
|
|
|
|
2008-06-10 06:33:56 +07:00
|
|
|
/* RX descriptor */
|
|
|
|
rxdesc = &mdp->rx_ring[i];
|
2009-05-25 06:53:20 +07:00
|
|
|
rxdesc->addr = virt_to_phys(PTR_ALIGN(skb->data, 4));
|
2008-08-07 06:49:00 +07:00
|
|
|
rxdesc->status = cpu_to_edmac(mdp, RD_RACT | RD_RFP);
|
2008-06-10 06:33:56 +07:00
|
|
|
|
|
|
|
/* The size of the buffer is 16 byte boundary. */
|
2009-05-25 06:53:20 +07:00
|
|
|
rxdesc->buffer_length = ALIGN(mdp->rx_buf_sz, 16);
|
2008-06-30 09:08:17 +07:00
|
|
|
/* Rx descriptor address set */
|
|
|
|
if (i == 0) {
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(mdp->rx_desc_dma, ioaddr + RDLAR);
|
2008-06-30 09:08:17 +07:00
|
|
|
#if defined(CONFIG_CPU_SUBTYPE_SH7763)
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(mdp->rx_desc_dma, ioaddr + RDFAR);
|
2008-06-30 09:08:17 +07:00
|
|
|
#endif
|
|
|
|
}
|
2008-06-10 06:33:56 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
mdp->dirty_rx = (u32) (i - RX_RING_SIZE);
|
|
|
|
|
|
|
|
/* Mark the last entry as wrapping the ring. */
|
2008-08-07 06:49:00 +07:00
|
|
|
rxdesc->status |= cpu_to_edmac(mdp, RD_RDEL);
|
2008-06-10 06:33:56 +07:00
|
|
|
|
|
|
|
memset(mdp->tx_ring, 0, tx_ringsize);
|
|
|
|
|
|
|
|
/* build Tx ring buffer */
|
|
|
|
for (i = 0; i < TX_RING_SIZE; i++) {
|
|
|
|
mdp->tx_skbuff[i] = NULL;
|
|
|
|
txdesc = &mdp->tx_ring[i];
|
2008-08-07 06:49:00 +07:00
|
|
|
txdesc->status = cpu_to_edmac(mdp, TD_TFP);
|
2008-06-10 06:33:56 +07:00
|
|
|
txdesc->buffer_length = 0;
|
2008-06-30 09:08:17 +07:00
|
|
|
if (i == 0) {
|
2008-08-07 06:49:00 +07:00
|
|
|
/* Tx descriptor address set */
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(mdp->tx_desc_dma, ioaddr + TDLAR);
|
2008-06-30 09:08:17 +07:00
|
|
|
#if defined(CONFIG_CPU_SUBTYPE_SH7763)
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(mdp->tx_desc_dma, ioaddr + TDFAR);
|
2008-06-30 09:08:17 +07:00
|
|
|
#endif
|
|
|
|
}
|
2008-06-10 06:33:56 +07:00
|
|
|
}
|
|
|
|
|
2008-08-07 06:49:00 +07:00
|
|
|
txdesc->status |= cpu_to_edmac(mdp, TD_TDLE);
|
2008-06-10 06:33:56 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Get skb and descriptor buffer */
|
|
|
|
static int sh_eth_ring_init(struct net_device *ndev)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
int rx_ringsize, tx_ringsize, ret = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* +26 gets the maximum ethernet encapsulation, +7 & ~7 because the
|
|
|
|
* card needs room to do 8 byte alignment, +2 so we can reserve
|
|
|
|
* the first 2 bytes, and +16 gets room for the status word from the
|
|
|
|
* card.
|
|
|
|
*/
|
|
|
|
mdp->rx_buf_sz = (ndev->mtu <= 1492 ? PKT_BUF_SZ :
|
|
|
|
(((ndev->mtu + 26 + 7) & ~7) + 2 + 16));
|
2009-12-16 12:16:55 +07:00
|
|
|
if (mdp->cd->rpadir)
|
|
|
|
mdp->rx_buf_sz += NET_IP_ALIGN;
|
2008-06-10 06:33:56 +07:00
|
|
|
|
|
|
|
/* Allocate RX and TX skb rings */
|
|
|
|
mdp->rx_skbuff = kmalloc(sizeof(*mdp->rx_skbuff) * RX_RING_SIZE,
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (!mdp->rx_skbuff) {
|
2009-05-25 06:54:21 +07:00
|
|
|
dev_err(&ndev->dev, "Cannot allocate Rx skb\n");
|
2008-06-10 06:33:56 +07:00
|
|
|
ret = -ENOMEM;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
mdp->tx_skbuff = kmalloc(sizeof(*mdp->tx_skbuff) * TX_RING_SIZE,
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (!mdp->tx_skbuff) {
|
2009-05-25 06:54:21 +07:00
|
|
|
dev_err(&ndev->dev, "Cannot allocate Tx skb\n");
|
2008-06-10 06:33:56 +07:00
|
|
|
ret = -ENOMEM;
|
|
|
|
goto skb_ring_free;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Allocate all Rx descriptors. */
|
|
|
|
rx_ringsize = sizeof(struct sh_eth_rxdesc) * RX_RING_SIZE;
|
|
|
|
mdp->rx_ring = dma_alloc_coherent(NULL, rx_ringsize, &mdp->rx_desc_dma,
|
|
|
|
GFP_KERNEL);
|
|
|
|
|
|
|
|
if (!mdp->rx_ring) {
|
2009-05-25 06:54:21 +07:00
|
|
|
dev_err(&ndev->dev, "Cannot allocate Rx Ring (size %d bytes)\n",
|
|
|
|
rx_ringsize);
|
2008-06-10 06:33:56 +07:00
|
|
|
ret = -ENOMEM;
|
|
|
|
goto desc_ring_free;
|
|
|
|
}
|
|
|
|
|
|
|
|
mdp->dirty_rx = 0;
|
|
|
|
|
|
|
|
/* Allocate all Tx descriptors. */
|
|
|
|
tx_ringsize = sizeof(struct sh_eth_txdesc) * TX_RING_SIZE;
|
|
|
|
mdp->tx_ring = dma_alloc_coherent(NULL, tx_ringsize, &mdp->tx_desc_dma,
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (!mdp->tx_ring) {
|
2009-05-25 06:54:21 +07:00
|
|
|
dev_err(&ndev->dev, "Cannot allocate Tx Ring (size %d bytes)\n",
|
|
|
|
tx_ringsize);
|
2008-06-10 06:33:56 +07:00
|
|
|
ret = -ENOMEM;
|
|
|
|
goto desc_ring_free;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
desc_ring_free:
|
|
|
|
/* free DMA buffer */
|
|
|
|
dma_free_coherent(NULL, rx_ringsize, mdp->rx_ring, mdp->rx_desc_dma);
|
|
|
|
|
|
|
|
skb_ring_free:
|
|
|
|
/* Free Rx and Tx skb ring buffer */
|
|
|
|
sh_eth_ring_free(ndev);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sh_eth_dev_init(struct net_device *ndev)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
u32 ioaddr = ndev->base_addr;
|
|
|
|
u_int32_t rx_int_var, tx_int_var;
|
|
|
|
u32 val;
|
|
|
|
|
|
|
|
/* Soft Reset */
|
|
|
|
sh_eth_reset(ndev);
|
|
|
|
|
2008-06-30 09:08:17 +07:00
|
|
|
/* Descriptor format */
|
|
|
|
sh_eth_ring_format(ndev);
|
2009-05-25 06:54:21 +07:00
|
|
|
if (mdp->cd->rpadir)
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(mdp->cd->rpadir_value, ioaddr + RPADIR);
|
2008-06-10 06:33:56 +07:00
|
|
|
|
|
|
|
/* all sh_eth int mask */
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(0, ioaddr + EESIPR);
|
2008-06-10 06:33:56 +07:00
|
|
|
|
2009-05-25 06:54:21 +07:00
|
|
|
#if defined(__LITTLE_ENDIAN__)
|
|
|
|
if (mdp->cd->hw_swap)
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(EDMR_EL, ioaddr + EDMR);
|
2009-05-25 06:54:21 +07:00
|
|
|
else
|
2008-06-30 09:08:17 +07:00
|
|
|
#endif
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(0, ioaddr + EDMR);
|
2008-06-10 06:33:56 +07:00
|
|
|
|
2008-06-30 09:08:17 +07:00
|
|
|
/* FIFO size set */
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(mdp->cd->fdr_value, ioaddr + FDR);
|
|
|
|
writel(0, ioaddr + TFTR);
|
2008-06-10 06:33:56 +07:00
|
|
|
|
2008-06-30 09:08:17 +07:00
|
|
|
/* Frame recv control */
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(mdp->cd->rmcr_value, ioaddr + RMCR);
|
2008-06-10 06:33:56 +07:00
|
|
|
|
|
|
|
rx_int_var = mdp->rx_int_var = DESC_I_RINT8 | DESC_I_RINT5;
|
|
|
|
tx_int_var = mdp->tx_int_var = DESC_I_TINT2;
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(rx_int_var | tx_int_var, ioaddr + TRSCER);
|
2008-06-10 06:33:56 +07:00
|
|
|
|
2009-05-25 06:54:21 +07:00
|
|
|
if (mdp->cd->bculr)
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(0x800, ioaddr + BCULR); /* Burst sycle set */
|
2008-06-30 09:08:17 +07:00
|
|
|
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(mdp->cd->fcftr_value, ioaddr + FCFTR);
|
2008-06-10 06:33:56 +07:00
|
|
|
|
2009-05-25 06:54:21 +07:00
|
|
|
if (!mdp->cd->no_trimd)
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(0, ioaddr + TRIMD);
|
2008-06-10 06:33:56 +07:00
|
|
|
|
2008-06-30 09:08:17 +07:00
|
|
|
/* Recv frame limit set register */
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(RFLR_VALUE, ioaddr + RFLR);
|
2008-06-10 06:33:56 +07:00
|
|
|
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(readl(ioaddr + EESR), ioaddr + EESR);
|
|
|
|
writel(mdp->cd->eesipr_value, ioaddr + EESIPR);
|
2008-06-10 06:33:56 +07:00
|
|
|
|
|
|
|
/* PAUSE Prohibition */
|
2010-11-01 16:29:24 +07:00
|
|
|
val = (readl(ioaddr + ECMR) & ECMR_DM) |
|
2008-06-10 06:33:56 +07:00
|
|
|
ECMR_ZPF | (mdp->duplex ? ECMR_DM : 0) | ECMR_TE | ECMR_RE;
|
|
|
|
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(val, ioaddr + ECMR);
|
2008-06-30 09:08:17 +07:00
|
|
|
|
2009-05-25 06:54:21 +07:00
|
|
|
if (mdp->cd->set_rate)
|
|
|
|
mdp->cd->set_rate(ndev);
|
|
|
|
|
2008-06-30 09:08:17 +07:00
|
|
|
/* E-MAC Status Register clear */
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(mdp->cd->ecsr_value, ioaddr + ECSR);
|
2008-06-30 09:08:17 +07:00
|
|
|
|
|
|
|
/* E-MAC Interrupt Enable register */
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(mdp->cd->ecsipr_value, ioaddr + ECSIPR);
|
2008-06-10 06:33:56 +07:00
|
|
|
|
|
|
|
/* Set MAC address */
|
|
|
|
update_mac_address(ndev);
|
|
|
|
|
|
|
|
/* mask reset */
|
2009-05-25 06:54:21 +07:00
|
|
|
if (mdp->cd->apr)
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(APR_AP, ioaddr + APR);
|
2009-05-25 06:54:21 +07:00
|
|
|
if (mdp->cd->mpr)
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(MPR_MP, ioaddr + MPR);
|
2009-05-25 06:54:21 +07:00
|
|
|
if (mdp->cd->tpauser)
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(TPAUSER_UNLIMITED, ioaddr + TPAUSER);
|
2008-06-30 09:08:17 +07:00
|
|
|
|
2008-06-10 06:33:56 +07:00
|
|
|
/* Setting the Rx mode will start the Rx process. */
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(EDRRR_R, ioaddr + EDRRR);
|
2008-06-10 06:33:56 +07:00
|
|
|
|
|
|
|
netif_start_queue(ndev);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* free Tx skb function */
|
|
|
|
static int sh_eth_txfree(struct net_device *ndev)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
struct sh_eth_txdesc *txdesc;
|
|
|
|
int freeNum = 0;
|
|
|
|
int entry = 0;
|
|
|
|
|
|
|
|
for (; mdp->cur_tx - mdp->dirty_tx > 0; mdp->dirty_tx++) {
|
|
|
|
entry = mdp->dirty_tx % TX_RING_SIZE;
|
|
|
|
txdesc = &mdp->tx_ring[entry];
|
2008-08-07 06:49:00 +07:00
|
|
|
if (txdesc->status & cpu_to_edmac(mdp, TD_TACT))
|
2008-06-10 06:33:56 +07:00
|
|
|
break;
|
|
|
|
/* Free the original skb. */
|
|
|
|
if (mdp->tx_skbuff[entry]) {
|
|
|
|
dev_kfree_skb_irq(mdp->tx_skbuff[entry]);
|
|
|
|
mdp->tx_skbuff[entry] = NULL;
|
|
|
|
freeNum++;
|
|
|
|
}
|
2008-08-07 06:49:00 +07:00
|
|
|
txdesc->status = cpu_to_edmac(mdp, TD_TFP);
|
2008-06-10 06:33:56 +07:00
|
|
|
if (entry >= TX_RING_SIZE - 1)
|
2008-08-07 06:49:00 +07:00
|
|
|
txdesc->status |= cpu_to_edmac(mdp, TD_TDLE);
|
2008-06-10 06:33:56 +07:00
|
|
|
|
|
|
|
mdp->stats.tx_packets++;
|
|
|
|
mdp->stats.tx_bytes += txdesc->buffer_length;
|
|
|
|
}
|
|
|
|
return freeNum;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Packet receive function */
|
|
|
|
static int sh_eth_rx(struct net_device *ndev)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
struct sh_eth_rxdesc *rxdesc;
|
|
|
|
|
|
|
|
int entry = mdp->cur_rx % RX_RING_SIZE;
|
|
|
|
int boguscnt = (mdp->dirty_rx + RX_RING_SIZE) - mdp->cur_rx;
|
|
|
|
struct sk_buff *skb;
|
|
|
|
u16 pkt_len = 0;
|
2009-05-25 06:54:21 +07:00
|
|
|
u32 desc_status;
|
2008-06-10 06:33:56 +07:00
|
|
|
|
|
|
|
rxdesc = &mdp->rx_ring[entry];
|
2008-08-07 06:49:00 +07:00
|
|
|
while (!(rxdesc->status & cpu_to_edmac(mdp, RD_RACT))) {
|
|
|
|
desc_status = edmac_to_cpu(mdp, rxdesc->status);
|
2008-06-10 06:33:56 +07:00
|
|
|
pkt_len = rxdesc->frame_length;
|
|
|
|
|
|
|
|
if (--boguscnt < 0)
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (!(desc_status & RDFEND))
|
|
|
|
mdp->stats.rx_length_errors++;
|
|
|
|
|
|
|
|
if (desc_status & (RD_RFS1 | RD_RFS2 | RD_RFS3 | RD_RFS4 |
|
|
|
|
RD_RFS5 | RD_RFS6 | RD_RFS10)) {
|
|
|
|
mdp->stats.rx_errors++;
|
|
|
|
if (desc_status & RD_RFS1)
|
|
|
|
mdp->stats.rx_crc_errors++;
|
|
|
|
if (desc_status & RD_RFS2)
|
|
|
|
mdp->stats.rx_frame_errors++;
|
|
|
|
if (desc_status & RD_RFS3)
|
|
|
|
mdp->stats.rx_length_errors++;
|
|
|
|
if (desc_status & RD_RFS4)
|
|
|
|
mdp->stats.rx_length_errors++;
|
|
|
|
if (desc_status & RD_RFS6)
|
|
|
|
mdp->stats.rx_missed_errors++;
|
|
|
|
if (desc_status & RD_RFS10)
|
|
|
|
mdp->stats.rx_over_errors++;
|
|
|
|
} else {
|
2009-05-25 06:54:21 +07:00
|
|
|
if (!mdp->cd->hw_swap)
|
|
|
|
sh_eth_soft_swap(
|
|
|
|
phys_to_virt(ALIGN(rxdesc->addr, 4)),
|
|
|
|
pkt_len + 2);
|
2008-06-10 06:33:56 +07:00
|
|
|
skb = mdp->rx_skbuff[entry];
|
|
|
|
mdp->rx_skbuff[entry] = NULL;
|
2009-12-16 12:16:55 +07:00
|
|
|
if (mdp->cd->rpadir)
|
|
|
|
skb_reserve(skb, NET_IP_ALIGN);
|
2008-06-10 06:33:56 +07:00
|
|
|
skb_put(skb, pkt_len);
|
|
|
|
skb->protocol = eth_type_trans(skb, ndev);
|
|
|
|
netif_rx(skb);
|
|
|
|
mdp->stats.rx_packets++;
|
|
|
|
mdp->stats.rx_bytes += pkt_len;
|
|
|
|
}
|
2008-08-07 06:49:00 +07:00
|
|
|
rxdesc->status |= cpu_to_edmac(mdp, RD_RACT);
|
2008-06-10 06:33:56 +07:00
|
|
|
entry = (++mdp->cur_rx) % RX_RING_SIZE;
|
2009-05-25 06:53:40 +07:00
|
|
|
rxdesc = &mdp->rx_ring[entry];
|
2008-06-10 06:33:56 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Refill the Rx ring buffers. */
|
|
|
|
for (; mdp->cur_rx - mdp->dirty_rx > 0; mdp->dirty_rx++) {
|
|
|
|
entry = mdp->dirty_rx % RX_RING_SIZE;
|
|
|
|
rxdesc = &mdp->rx_ring[entry];
|
2008-06-30 09:08:17 +07:00
|
|
|
/* The size of the buffer is 16 byte boundary. */
|
2009-05-25 06:53:20 +07:00
|
|
|
rxdesc->buffer_length = ALIGN(mdp->rx_buf_sz, 16);
|
2008-06-30 09:08:17 +07:00
|
|
|
|
2008-06-10 06:33:56 +07:00
|
|
|
if (mdp->rx_skbuff[entry] == NULL) {
|
|
|
|
skb = dev_alloc_skb(mdp->rx_buf_sz);
|
|
|
|
mdp->rx_skbuff[entry] = skb;
|
|
|
|
if (skb == NULL)
|
|
|
|
break; /* Better luck next round. */
|
2009-05-25 06:52:35 +07:00
|
|
|
dma_map_single(&ndev->dev, skb->tail, mdp->rx_buf_sz,
|
|
|
|
DMA_FROM_DEVICE);
|
2008-06-10 06:33:56 +07:00
|
|
|
skb->dev = ndev;
|
2009-05-25 06:54:21 +07:00
|
|
|
sh_eth_set_receive_align(skb);
|
|
|
|
|
2010-09-03 03:07:41 +07:00
|
|
|
skb_checksum_none_assert(skb);
|
2009-05-25 06:53:20 +07:00
|
|
|
rxdesc->addr = virt_to_phys(PTR_ALIGN(skb->data, 4));
|
2008-06-10 06:33:56 +07:00
|
|
|
}
|
|
|
|
if (entry >= RX_RING_SIZE - 1)
|
|
|
|
rxdesc->status |=
|
2008-08-07 06:49:00 +07:00
|
|
|
cpu_to_edmac(mdp, RD_RACT | RD_RFP | RD_RDEL);
|
2008-06-10 06:33:56 +07:00
|
|
|
else
|
|
|
|
rxdesc->status |=
|
2008-08-07 06:49:00 +07:00
|
|
|
cpu_to_edmac(mdp, RD_RACT | RD_RFP);
|
2008-06-10 06:33:56 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Restart Rx engine if stopped. */
|
|
|
|
/* If we don't need to check status, don't. -KDU */
|
2010-11-01 16:29:24 +07:00
|
|
|
if (!(readl(ndev->base_addr + EDRRR) & EDRRR_R))
|
|
|
|
writel(EDRRR_R, ndev->base_addr + EDRRR);
|
2008-06-10 06:33:56 +07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* error control function */
|
|
|
|
static void sh_eth_error(struct net_device *ndev, int intr_status)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
u32 ioaddr = ndev->base_addr;
|
|
|
|
u32 felic_stat;
|
2009-05-25 06:54:21 +07:00
|
|
|
u32 link_stat;
|
|
|
|
u32 mask;
|
2008-06-10 06:33:56 +07:00
|
|
|
|
|
|
|
if (intr_status & EESR_ECI) {
|
2010-11-01 16:29:24 +07:00
|
|
|
felic_stat = readl(ioaddr + ECSR);
|
|
|
|
writel(felic_stat, ioaddr + ECSR); /* clear int */
|
2008-06-10 06:33:56 +07:00
|
|
|
if (felic_stat & ECSR_ICD)
|
|
|
|
mdp->stats.tx_carrier_errors++;
|
|
|
|
if (felic_stat & ECSR_LCHNG) {
|
|
|
|
/* Link Changed */
|
2009-08-28 06:25:03 +07:00
|
|
|
if (mdp->cd->no_psr || mdp->no_ether_link) {
|
2009-05-25 06:54:21 +07:00
|
|
|
if (mdp->link == PHY_DOWN)
|
|
|
|
link_stat = 0;
|
|
|
|
else
|
|
|
|
link_stat = PHY_ST_LINK;
|
|
|
|
} else {
|
2010-11-01 16:29:24 +07:00
|
|
|
link_stat = (readl(ioaddr + PSR));
|
2009-08-28 06:25:03 +07:00
|
|
|
if (mdp->ether_link_active_low)
|
|
|
|
link_stat = ~link_stat;
|
2009-05-25 06:54:21 +07:00
|
|
|
}
|
2008-06-10 06:33:56 +07:00
|
|
|
if (!(link_stat & PHY_ST_LINK)) {
|
|
|
|
/* Link Down : disable tx and rx */
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(readl(ioaddr + ECMR) &
|
2008-06-10 06:33:56 +07:00
|
|
|
~(ECMR_RE | ECMR_TE), ioaddr + ECMR);
|
|
|
|
} else {
|
|
|
|
/* Link Up */
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(readl(ioaddr + EESIPR) &
|
2008-06-10 06:33:56 +07:00
|
|
|
~DMAC_M_ECI, ioaddr + EESIPR);
|
|
|
|
/*clear int */
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(readl(ioaddr + ECSR),
|
2008-06-10 06:33:56 +07:00
|
|
|
ioaddr + ECSR);
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(readl(ioaddr + EESIPR) |
|
2008-06-10 06:33:56 +07:00
|
|
|
DMAC_M_ECI, ioaddr + EESIPR);
|
|
|
|
/* enable tx and rx */
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(readl(ioaddr + ECMR) |
|
2008-06-10 06:33:56 +07:00
|
|
|
(ECMR_RE | ECMR_TE), ioaddr + ECMR);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (intr_status & EESR_TWB) {
|
|
|
|
/* Write buck end. unused write back interrupt */
|
|
|
|
if (intr_status & EESR_TABT) /* Transmit Abort int */
|
|
|
|
mdp->stats.tx_aborted_errors++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (intr_status & EESR_RABT) {
|
|
|
|
/* Receive Abort int */
|
|
|
|
if (intr_status & EESR_RFRMER) {
|
|
|
|
/* Receive Frame Overflow int */
|
|
|
|
mdp->stats.rx_frame_errors++;
|
2009-05-25 06:54:21 +07:00
|
|
|
dev_err(&ndev->dev, "Receive Frame Overflow\n");
|
2008-06-10 06:33:56 +07:00
|
|
|
}
|
|
|
|
}
|
2009-05-25 06:54:21 +07:00
|
|
|
|
|
|
|
if (!mdp->cd->no_ade) {
|
|
|
|
if (intr_status & EESR_ADE && intr_status & EESR_TDE &&
|
|
|
|
intr_status & EESR_TFE)
|
|
|
|
mdp->stats.tx_fifo_errors++;
|
2008-06-10 06:33:56 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (intr_status & EESR_RDE) {
|
|
|
|
/* Receive Descriptor Empty int */
|
|
|
|
mdp->stats.rx_over_errors++;
|
|
|
|
|
2010-11-01 16:29:24 +07:00
|
|
|
if (readl(ioaddr + EDRRR) ^ EDRRR_R)
|
|
|
|
writel(EDRRR_R, ioaddr + EDRRR);
|
2009-05-25 06:54:21 +07:00
|
|
|
dev_err(&ndev->dev, "Receive Descriptor Empty\n");
|
2008-06-10 06:33:56 +07:00
|
|
|
}
|
|
|
|
if (intr_status & EESR_RFE) {
|
|
|
|
/* Receive FIFO Overflow int */
|
|
|
|
mdp->stats.rx_fifo_errors++;
|
2009-05-25 06:54:21 +07:00
|
|
|
dev_err(&ndev->dev, "Receive FIFO Overflow\n");
|
2008-06-10 06:33:56 +07:00
|
|
|
}
|
2009-05-25 06:54:21 +07:00
|
|
|
|
|
|
|
mask = EESR_TWB | EESR_TABT | EESR_ADE | EESR_TDE | EESR_TFE;
|
|
|
|
if (mdp->cd->no_ade)
|
|
|
|
mask &= ~EESR_ADE;
|
|
|
|
if (intr_status & mask) {
|
2008-06-10 06:33:56 +07:00
|
|
|
/* Tx error */
|
2010-11-01 16:29:24 +07:00
|
|
|
u32 edtrr = readl(ndev->base_addr + EDTRR);
|
2008-06-10 06:33:56 +07:00
|
|
|
/* dmesg */
|
2009-05-25 06:54:21 +07:00
|
|
|
dev_err(&ndev->dev, "TX error. status=%8.8x cur_tx=%8.8x ",
|
|
|
|
intr_status, mdp->cur_tx);
|
|
|
|
dev_err(&ndev->dev, "dirty_tx=%8.8x state=%8.8x EDTRR=%8.8x.\n",
|
2008-06-10 06:33:56 +07:00
|
|
|
mdp->dirty_tx, (u32) ndev->state, edtrr);
|
|
|
|
/* dirty buffer free */
|
|
|
|
sh_eth_txfree(ndev);
|
|
|
|
|
|
|
|
/* SH7712 BUG */
|
|
|
|
if (edtrr ^ EDTRR_TRNS) {
|
|
|
|
/* tx dma start */
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(EDTRR_TRNS, ndev->base_addr + EDTRR);
|
2008-06-10 06:33:56 +07:00
|
|
|
}
|
|
|
|
/* wakeup */
|
|
|
|
netif_wake_queue(ndev);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static irqreturn_t sh_eth_interrupt(int irq, void *netdev)
|
|
|
|
{
|
|
|
|
struct net_device *ndev = netdev;
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
2009-05-25 06:54:21 +07:00
|
|
|
struct sh_eth_cpu_data *cd = mdp->cd;
|
2009-03-17 02:50:57 +07:00
|
|
|
irqreturn_t ret = IRQ_NONE;
|
2009-06-22 14:38:00 +07:00
|
|
|
u32 ioaddr, intr_status = 0;
|
2008-06-10 06:33:56 +07:00
|
|
|
|
|
|
|
ioaddr = ndev->base_addr;
|
|
|
|
spin_lock(&mdp->lock);
|
|
|
|
|
2008-06-30 09:08:17 +07:00
|
|
|
/* Get interrpt stat */
|
2010-11-01 16:29:24 +07:00
|
|
|
intr_status = readl(ioaddr + EESR);
|
2008-06-10 06:33:56 +07:00
|
|
|
/* Clear interrupt */
|
2009-03-17 02:50:57 +07:00
|
|
|
if (intr_status & (EESR_FRC | EESR_RMAF | EESR_RRF |
|
|
|
|
EESR_RTLF | EESR_RTSF | EESR_PRE | EESR_CERF |
|
2009-05-25 06:54:21 +07:00
|
|
|
cd->tx_check | cd->eesr_err_check)) {
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(intr_status, ioaddr + EESR);
|
2009-03-17 02:50:57 +07:00
|
|
|
ret = IRQ_HANDLED;
|
|
|
|
} else
|
|
|
|
goto other_irq;
|
2008-06-10 06:33:56 +07:00
|
|
|
|
2008-06-30 09:08:17 +07:00
|
|
|
if (intr_status & (EESR_FRC | /* Frame recv*/
|
|
|
|
EESR_RMAF | /* Multi cast address recv*/
|
|
|
|
EESR_RRF | /* Bit frame recv */
|
|
|
|
EESR_RTLF | /* Long frame recv*/
|
|
|
|
EESR_RTSF | /* short frame recv */
|
|
|
|
EESR_PRE | /* PHY-LSI recv error */
|
|
|
|
EESR_CERF)){ /* recv frame CRC error */
|
2008-06-10 06:33:56 +07:00
|
|
|
sh_eth_rx(ndev);
|
2008-06-30 09:08:17 +07:00
|
|
|
}
|
2008-06-10 06:33:56 +07:00
|
|
|
|
2008-06-30 09:08:17 +07:00
|
|
|
/* Tx Check */
|
2009-05-25 06:54:21 +07:00
|
|
|
if (intr_status & cd->tx_check) {
|
2008-06-10 06:33:56 +07:00
|
|
|
sh_eth_txfree(ndev);
|
|
|
|
netif_wake_queue(ndev);
|
|
|
|
}
|
|
|
|
|
2009-05-25 06:54:21 +07:00
|
|
|
if (intr_status & cd->eesr_err_check)
|
2008-06-10 06:33:56 +07:00
|
|
|
sh_eth_error(ndev, intr_status);
|
|
|
|
|
2009-03-17 02:50:57 +07:00
|
|
|
other_irq:
|
2008-06-10 06:33:56 +07:00
|
|
|
spin_unlock(&mdp->lock);
|
|
|
|
|
2009-03-17 02:50:57 +07:00
|
|
|
return ret;
|
2008-06-10 06:33:56 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void sh_eth_timer(unsigned long data)
|
|
|
|
{
|
|
|
|
struct net_device *ndev = (struct net_device *)data;
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
|
|
|
|
mod_timer(&mdp->timer, jiffies + (10 * HZ));
|
|
|
|
}
|
|
|
|
|
|
|
|
/* PHY state control function */
|
|
|
|
static void sh_eth_adjust_link(struct net_device *ndev)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
struct phy_device *phydev = mdp->phydev;
|
|
|
|
u32 ioaddr = ndev->base_addr;
|
|
|
|
int new_state = 0;
|
|
|
|
|
|
|
|
if (phydev->link != PHY_DOWN) {
|
|
|
|
if (phydev->duplex != mdp->duplex) {
|
|
|
|
new_state = 1;
|
|
|
|
mdp->duplex = phydev->duplex;
|
2009-05-25 06:54:21 +07:00
|
|
|
if (mdp->cd->set_duplex)
|
|
|
|
mdp->cd->set_duplex(ndev);
|
2008-06-10 06:33:56 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (phydev->speed != mdp->speed) {
|
|
|
|
new_state = 1;
|
|
|
|
mdp->speed = phydev->speed;
|
2009-05-25 06:54:21 +07:00
|
|
|
if (mdp->cd->set_rate)
|
|
|
|
mdp->cd->set_rate(ndev);
|
2008-06-10 06:33:56 +07:00
|
|
|
}
|
|
|
|
if (mdp->link == PHY_DOWN) {
|
2010-11-01 16:29:24 +07:00
|
|
|
writel((readl(ioaddr + ECMR) & ~ECMR_TXF)
|
2008-06-10 06:33:56 +07:00
|
|
|
| ECMR_DM, ioaddr + ECMR);
|
|
|
|
new_state = 1;
|
|
|
|
mdp->link = phydev->link;
|
|
|
|
}
|
|
|
|
} else if (mdp->link) {
|
|
|
|
new_state = 1;
|
|
|
|
mdp->link = PHY_DOWN;
|
|
|
|
mdp->speed = 0;
|
|
|
|
mdp->duplex = -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (new_state)
|
|
|
|
phy_print_status(phydev);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* PHY init function */
|
|
|
|
static int sh_eth_phy_init(struct net_device *ndev)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
2009-05-27 11:11:09 +07:00
|
|
|
char phy_id[MII_BUS_ID_SIZE + 3];
|
2008-06-10 06:33:56 +07:00
|
|
|
struct phy_device *phydev = NULL;
|
|
|
|
|
2008-11-11 04:55:14 +07:00
|
|
|
snprintf(phy_id, sizeof(phy_id), PHY_ID_FMT,
|
2008-06-10 06:33:56 +07:00
|
|
|
mdp->mii_bus->id , mdp->phy_id);
|
|
|
|
|
|
|
|
mdp->link = PHY_DOWN;
|
|
|
|
mdp->speed = 0;
|
|
|
|
mdp->duplex = -1;
|
|
|
|
|
|
|
|
/* Try connect to PHY */
|
2010-08-24 01:20:03 +07:00
|
|
|
phydev = phy_connect(ndev, phy_id, sh_eth_adjust_link,
|
2008-06-10 06:33:56 +07:00
|
|
|
0, PHY_INTERFACE_MODE_MII);
|
|
|
|
if (IS_ERR(phydev)) {
|
|
|
|
dev_err(&ndev->dev, "phy_connect failed\n");
|
|
|
|
return PTR_ERR(phydev);
|
|
|
|
}
|
2009-05-25 06:54:21 +07:00
|
|
|
|
2008-06-10 06:33:56 +07:00
|
|
|
dev_info(&ndev->dev, "attached phy %i to driver %s\n",
|
2009-05-25 06:54:21 +07:00
|
|
|
phydev->addr, phydev->drv->name);
|
2008-06-10 06:33:56 +07:00
|
|
|
|
|
|
|
mdp->phydev = phydev;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* PHY control start function */
|
|
|
|
static int sh_eth_phy_start(struct net_device *ndev)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = sh_eth_phy_init(ndev);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
/* reset phy - this also wakes it from PDOWN */
|
|
|
|
phy_write(mdp->phydev, MII_BMCR, BMCR_RESET);
|
|
|
|
phy_start(mdp->phydev);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* network device open function */
|
|
|
|
static int sh_eth_open(struct net_device *ndev)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
|
2009-10-09 07:20:04 +07:00
|
|
|
pm_runtime_get_sync(&mdp->pdev->dev);
|
|
|
|
|
2009-11-19 14:29:17 +07:00
|
|
|
ret = request_irq(ndev->irq, sh_eth_interrupt,
|
2010-07-06 01:32:50 +07:00
|
|
|
#if defined(CONFIG_CPU_SUBTYPE_SH7763) || \
|
|
|
|
defined(CONFIG_CPU_SUBTYPE_SH7764) || \
|
|
|
|
defined(CONFIG_CPU_SUBTYPE_SH7757)
|
2009-03-17 02:50:57 +07:00
|
|
|
IRQF_SHARED,
|
|
|
|
#else
|
|
|
|
0,
|
|
|
|
#endif
|
|
|
|
ndev->name, ndev);
|
2008-06-10 06:33:56 +07:00
|
|
|
if (ret) {
|
2009-05-25 06:54:21 +07:00
|
|
|
dev_err(&ndev->dev, "Can not assign IRQ number\n");
|
2008-06-10 06:33:56 +07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Descriptor set */
|
|
|
|
ret = sh_eth_ring_init(ndev);
|
|
|
|
if (ret)
|
|
|
|
goto out_free_irq;
|
|
|
|
|
|
|
|
/* device init */
|
|
|
|
ret = sh_eth_dev_init(ndev);
|
|
|
|
if (ret)
|
|
|
|
goto out_free_irq;
|
|
|
|
|
|
|
|
/* PHY control start*/
|
|
|
|
ret = sh_eth_phy_start(ndev);
|
|
|
|
if (ret)
|
|
|
|
goto out_free_irq;
|
|
|
|
|
|
|
|
/* Set the timer to check for link beat. */
|
|
|
|
init_timer(&mdp->timer);
|
|
|
|
mdp->timer.expires = (jiffies + (24 * HZ)) / 10;/* 2.4 sec. */
|
2008-06-30 09:08:17 +07:00
|
|
|
setup_timer(&mdp->timer, sh_eth_timer, (unsigned long)ndev);
|
2008-06-10 06:33:56 +07:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
out_free_irq:
|
|
|
|
free_irq(ndev->irq, ndev);
|
2009-10-09 07:20:04 +07:00
|
|
|
pm_runtime_put_sync(&mdp->pdev->dev);
|
2008-06-10 06:33:56 +07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Timeout function */
|
|
|
|
static void sh_eth_tx_timeout(struct net_device *ndev)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
u32 ioaddr = ndev->base_addr;
|
|
|
|
struct sh_eth_rxdesc *rxdesc;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
netif_stop_queue(ndev);
|
|
|
|
|
|
|
|
/* worning message out. */
|
|
|
|
printk(KERN_WARNING "%s: transmit timed out, status %8.8x,"
|
2010-11-01 16:29:24 +07:00
|
|
|
" resetting...\n", ndev->name, (int)readl(ioaddr + EESR));
|
2008-06-10 06:33:56 +07:00
|
|
|
|
|
|
|
/* tx_errors count up */
|
|
|
|
mdp->stats.tx_errors++;
|
|
|
|
|
|
|
|
/* timer off */
|
|
|
|
del_timer_sync(&mdp->timer);
|
|
|
|
|
|
|
|
/* Free all the skbuffs in the Rx queue. */
|
|
|
|
for (i = 0; i < RX_RING_SIZE; i++) {
|
|
|
|
rxdesc = &mdp->rx_ring[i];
|
|
|
|
rxdesc->status = 0;
|
|
|
|
rxdesc->addr = 0xBADF00D0;
|
|
|
|
if (mdp->rx_skbuff[i])
|
|
|
|
dev_kfree_skb(mdp->rx_skbuff[i]);
|
|
|
|
mdp->rx_skbuff[i] = NULL;
|
|
|
|
}
|
|
|
|
for (i = 0; i < TX_RING_SIZE; i++) {
|
|
|
|
if (mdp->tx_skbuff[i])
|
|
|
|
dev_kfree_skb(mdp->tx_skbuff[i]);
|
|
|
|
mdp->tx_skbuff[i] = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* device init */
|
|
|
|
sh_eth_dev_init(ndev);
|
|
|
|
|
|
|
|
/* timer on */
|
|
|
|
mdp->timer.expires = (jiffies + (24 * HZ)) / 10;/* 2.4 sec. */
|
|
|
|
add_timer(&mdp->timer);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Packet transmit function */
|
|
|
|
static int sh_eth_start_xmit(struct sk_buff *skb, struct net_device *ndev)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
struct sh_eth_txdesc *txdesc;
|
|
|
|
u32 entry;
|
2008-11-18 03:29:58 +07:00
|
|
|
unsigned long flags;
|
2008-06-10 06:33:56 +07:00
|
|
|
|
|
|
|
spin_lock_irqsave(&mdp->lock, flags);
|
|
|
|
if ((mdp->cur_tx - mdp->dirty_tx) >= (TX_RING_SIZE - 4)) {
|
|
|
|
if (!sh_eth_txfree(ndev)) {
|
|
|
|
netif_stop_queue(ndev);
|
|
|
|
spin_unlock_irqrestore(&mdp->lock, flags);
|
2009-06-12 13:22:29 +07:00
|
|
|
return NETDEV_TX_BUSY;
|
2008-06-10 06:33:56 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&mdp->lock, flags);
|
|
|
|
|
|
|
|
entry = mdp->cur_tx % TX_RING_SIZE;
|
|
|
|
mdp->tx_skbuff[entry] = skb;
|
|
|
|
txdesc = &mdp->tx_ring[entry];
|
2009-05-25 06:53:20 +07:00
|
|
|
txdesc->addr = virt_to_phys(skb->data);
|
2008-06-10 06:33:56 +07:00
|
|
|
/* soft swap. */
|
2009-05-25 06:54:21 +07:00
|
|
|
if (!mdp->cd->hw_swap)
|
|
|
|
sh_eth_soft_swap(phys_to_virt(ALIGN(txdesc->addr, 4)),
|
|
|
|
skb->len + 2);
|
2008-06-10 06:33:56 +07:00
|
|
|
/* write back */
|
|
|
|
__flush_purge_region(skb->data, skb->len);
|
|
|
|
if (skb->len < ETHERSMALL)
|
|
|
|
txdesc->buffer_length = ETHERSMALL;
|
|
|
|
else
|
|
|
|
txdesc->buffer_length = skb->len;
|
|
|
|
|
|
|
|
if (entry >= TX_RING_SIZE - 1)
|
2008-08-07 06:49:00 +07:00
|
|
|
txdesc->status |= cpu_to_edmac(mdp, TD_TACT | TD_TDLE);
|
2008-06-10 06:33:56 +07:00
|
|
|
else
|
2008-08-07 06:49:00 +07:00
|
|
|
txdesc->status |= cpu_to_edmac(mdp, TD_TACT);
|
2008-06-10 06:33:56 +07:00
|
|
|
|
|
|
|
mdp->cur_tx++;
|
|
|
|
|
2010-11-01 16:29:24 +07:00
|
|
|
if (!(readl(ndev->base_addr + EDTRR) & EDTRR_TRNS))
|
|
|
|
writel(EDTRR_TRNS, ndev->base_addr + EDTRR);
|
2008-06-30 09:08:17 +07:00
|
|
|
|
2009-06-23 13:03:08 +07:00
|
|
|
return NETDEV_TX_OK;
|
2008-06-10 06:33:56 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* device close function */
|
|
|
|
static int sh_eth_close(struct net_device *ndev)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
u32 ioaddr = ndev->base_addr;
|
|
|
|
int ringsize;
|
|
|
|
|
|
|
|
netif_stop_queue(ndev);
|
|
|
|
|
|
|
|
/* Disable interrupts by clearing the interrupt mask. */
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(0x0000, ioaddr + EESIPR);
|
2008-06-10 06:33:56 +07:00
|
|
|
|
|
|
|
/* Stop the chip's Tx and Rx processes. */
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(0, ioaddr + EDTRR);
|
|
|
|
writel(0, ioaddr + EDRRR);
|
2008-06-10 06:33:56 +07:00
|
|
|
|
|
|
|
/* PHY Disconnect */
|
|
|
|
if (mdp->phydev) {
|
|
|
|
phy_stop(mdp->phydev);
|
|
|
|
phy_disconnect(mdp->phydev);
|
|
|
|
}
|
|
|
|
|
|
|
|
free_irq(ndev->irq, ndev);
|
|
|
|
|
|
|
|
del_timer_sync(&mdp->timer);
|
|
|
|
|
|
|
|
/* Free all the skbuffs in the Rx queue. */
|
|
|
|
sh_eth_ring_free(ndev);
|
|
|
|
|
|
|
|
/* free DMA buffer */
|
|
|
|
ringsize = sizeof(struct sh_eth_rxdesc) * RX_RING_SIZE;
|
|
|
|
dma_free_coherent(NULL, ringsize, mdp->rx_ring, mdp->rx_desc_dma);
|
|
|
|
|
|
|
|
/* free DMA buffer */
|
|
|
|
ringsize = sizeof(struct sh_eth_txdesc) * TX_RING_SIZE;
|
|
|
|
dma_free_coherent(NULL, ringsize, mdp->tx_ring, mdp->tx_desc_dma);
|
|
|
|
|
2009-10-09 07:20:04 +07:00
|
|
|
pm_runtime_put_sync(&mdp->pdev->dev);
|
|
|
|
|
2008-06-10 06:33:56 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct net_device_stats *sh_eth_get_stats(struct net_device *ndev)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
u32 ioaddr = ndev->base_addr;
|
|
|
|
|
2009-10-09 07:20:04 +07:00
|
|
|
pm_runtime_get_sync(&mdp->pdev->dev);
|
|
|
|
|
2010-11-01 16:29:24 +07:00
|
|
|
mdp->stats.tx_dropped += readl(ioaddr + TROCR);
|
|
|
|
writel(0, ioaddr + TROCR); /* (write clear) */
|
|
|
|
mdp->stats.collisions += readl(ioaddr + CDCR);
|
|
|
|
writel(0, ioaddr + CDCR); /* (write clear) */
|
|
|
|
mdp->stats.tx_carrier_errors += readl(ioaddr + LCCR);
|
|
|
|
writel(0, ioaddr + LCCR); /* (write clear) */
|
2008-06-30 09:08:17 +07:00
|
|
|
#if defined(CONFIG_CPU_SUBTYPE_SH7763)
|
2010-11-01 16:29:24 +07:00
|
|
|
mdp->stats.tx_carrier_errors += readl(ioaddr + CERCR);/* CERCR */
|
|
|
|
writel(0, ioaddr + CERCR); /* (write clear) */
|
|
|
|
mdp->stats.tx_carrier_errors += readl(ioaddr + CEECR);/* CEECR */
|
|
|
|
writel(0, ioaddr + CEECR); /* (write clear) */
|
2008-06-30 09:08:17 +07:00
|
|
|
#else
|
2010-11-01 16:29:24 +07:00
|
|
|
mdp->stats.tx_carrier_errors += readl(ioaddr + CNDCR);
|
|
|
|
writel(0, ioaddr + CNDCR); /* (write clear) */
|
2008-06-30 09:08:17 +07:00
|
|
|
#endif
|
2009-10-09 07:20:04 +07:00
|
|
|
pm_runtime_put_sync(&mdp->pdev->dev);
|
|
|
|
|
2008-06-10 06:33:56 +07:00
|
|
|
return &mdp->stats;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ioctl to device funciotn*/
|
|
|
|
static int sh_eth_do_ioctl(struct net_device *ndev, struct ifreq *rq,
|
|
|
|
int cmd)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
struct phy_device *phydev = mdp->phydev;
|
|
|
|
|
|
|
|
if (!netif_running(ndev))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (!phydev)
|
|
|
|
return -ENODEV;
|
|
|
|
|
2010-07-17 15:48:55 +07:00
|
|
|
return phy_mii_ioctl(phydev, rq, cmd);
|
2008-06-10 06:33:56 +07:00
|
|
|
}
|
|
|
|
|
2009-05-25 06:54:21 +07:00
|
|
|
#if defined(SH_ETH_HAS_TSU)
|
2008-06-10 06:33:56 +07:00
|
|
|
/* Multicast reception directions set */
|
|
|
|
static void sh_eth_set_multicast_list(struct net_device *ndev)
|
|
|
|
{
|
|
|
|
u32 ioaddr = ndev->base_addr;
|
|
|
|
|
|
|
|
if (ndev->flags & IFF_PROMISC) {
|
|
|
|
/* Set promiscuous. */
|
2010-11-01 16:29:24 +07:00
|
|
|
writel((readl(ioaddr + ECMR) & ~ECMR_MCT) | ECMR_PRM,
|
2008-06-10 06:33:56 +07:00
|
|
|
ioaddr + ECMR);
|
|
|
|
} else {
|
|
|
|
/* Normal, unicast/broadcast-only mode. */
|
2010-11-01 16:29:24 +07:00
|
|
|
writel((readl(ioaddr + ECMR) & ~ECMR_PRM) | ECMR_MCT,
|
2008-06-10 06:33:56 +07:00
|
|
|
ioaddr + ECMR);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* SuperH's TSU register init function */
|
|
|
|
static void sh_eth_tsu_init(u32 ioaddr)
|
|
|
|
{
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(0, ioaddr + TSU_FWEN0); /* Disable forward(0->1) */
|
|
|
|
writel(0, ioaddr + TSU_FWEN1); /* Disable forward(1->0) */
|
|
|
|
writel(0, ioaddr + TSU_FCM); /* forward fifo 3k-3k */
|
|
|
|
writel(0xc, ioaddr + TSU_BSYSL0);
|
|
|
|
writel(0xc, ioaddr + TSU_BSYSL1);
|
|
|
|
writel(0, ioaddr + TSU_PRISL0);
|
|
|
|
writel(0, ioaddr + TSU_PRISL1);
|
|
|
|
writel(0, ioaddr + TSU_FWSL0);
|
|
|
|
writel(0, ioaddr + TSU_FWSL1);
|
|
|
|
writel(TSU_FWSLC_POSTENU | TSU_FWSLC_POSTENL, ioaddr + TSU_FWSLC);
|
2008-06-30 09:08:17 +07:00
|
|
|
#if defined(CONFIG_CPU_SUBTYPE_SH7763)
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(0, ioaddr + TSU_QTAG0); /* Disable QTAG(0->1) */
|
|
|
|
writel(0, ioaddr + TSU_QTAG1); /* Disable QTAG(1->0) */
|
2008-06-30 09:08:17 +07:00
|
|
|
#else
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(0, ioaddr + TSU_QTAGM0); /* Disable QTAG(0->1) */
|
|
|
|
writel(0, ioaddr + TSU_QTAGM1); /* Disable QTAG(1->0) */
|
2008-06-30 09:08:17 +07:00
|
|
|
#endif
|
2010-11-01 16:29:24 +07:00
|
|
|
writel(0, ioaddr + TSU_FWSR); /* all interrupt status clear */
|
|
|
|
writel(0, ioaddr + TSU_FWINMK); /* Disable all interrupt */
|
|
|
|
writel(0, ioaddr + TSU_TEN); /* Disable all CAM entry */
|
|
|
|
writel(0, ioaddr + TSU_POST1); /* Disable CAM entry [ 0- 7] */
|
|
|
|
writel(0, ioaddr + TSU_POST2); /* Disable CAM entry [ 8-15] */
|
|
|
|
writel(0, ioaddr + TSU_POST3); /* Disable CAM entry [16-23] */
|
|
|
|
writel(0, ioaddr + TSU_POST4); /* Disable CAM entry [24-31] */
|
2008-06-10 06:33:56 +07:00
|
|
|
}
|
2009-05-25 06:54:21 +07:00
|
|
|
#endif /* SH_ETH_HAS_TSU */
|
2008-06-10 06:33:56 +07:00
|
|
|
|
|
|
|
/* MDIO bus release function */
|
|
|
|
static int sh_mdio_release(struct net_device *ndev)
|
|
|
|
{
|
|
|
|
struct mii_bus *bus = dev_get_drvdata(&ndev->dev);
|
|
|
|
|
|
|
|
/* unregister mdio bus */
|
|
|
|
mdiobus_unregister(bus);
|
|
|
|
|
|
|
|
/* remove mdio bus info from net_device */
|
|
|
|
dev_set_drvdata(&ndev->dev, NULL);
|
|
|
|
|
2010-05-20 11:00:59 +07:00
|
|
|
/* free interrupts memory */
|
|
|
|
kfree(bus->irq);
|
|
|
|
|
2008-06-10 06:33:56 +07:00
|
|
|
/* free bitbang info */
|
|
|
|
free_mdio_bitbang(bus);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* MDIO bus init function */
|
|
|
|
static int sh_mdio_init(struct net_device *ndev, int id)
|
|
|
|
{
|
|
|
|
int ret, i;
|
|
|
|
struct bb_info *bitbang;
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
|
|
|
|
/* create bit control struct for PHY */
|
|
|
|
bitbang = kzalloc(sizeof(struct bb_info), GFP_KERNEL);
|
|
|
|
if (!bitbang) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* bitbang init */
|
|
|
|
bitbang->addr = ndev->base_addr + PIR;
|
|
|
|
bitbang->mdi_msk = 0x08;
|
|
|
|
bitbang->mdo_msk = 0x04;
|
|
|
|
bitbang->mmd_msk = 0x02;/* MMD */
|
|
|
|
bitbang->mdc_msk = 0x01;
|
|
|
|
bitbang->ctrl.ops = &bb_ops;
|
|
|
|
|
2010-08-04 00:44:52 +07:00
|
|
|
/* MII controller setting */
|
2008-06-10 06:33:56 +07:00
|
|
|
mdp->mii_bus = alloc_mdio_bitbang(&bitbang->ctrl);
|
|
|
|
if (!mdp->mii_bus) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out_free_bitbang;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Hook up MII support for ethtool */
|
|
|
|
mdp->mii_bus->name = "sh_mii";
|
2008-10-01 22:41:33 +07:00
|
|
|
mdp->mii_bus->parent = &ndev->dev;
|
2008-11-18 03:29:58 +07:00
|
|
|
snprintf(mdp->mii_bus->id, MII_BUS_ID_SIZE, "%x", id);
|
2008-06-10 06:33:56 +07:00
|
|
|
|
|
|
|
/* PHY IRQ */
|
|
|
|
mdp->mii_bus->irq = kmalloc(sizeof(int)*PHY_MAX_ADDR, GFP_KERNEL);
|
|
|
|
if (!mdp->mii_bus->irq) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out_free_bus;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < PHY_MAX_ADDR; i++)
|
|
|
|
mdp->mii_bus->irq[i] = PHY_POLL;
|
|
|
|
|
|
|
|
/* regist mdio bus */
|
|
|
|
ret = mdiobus_register(mdp->mii_bus);
|
|
|
|
if (ret)
|
|
|
|
goto out_free_irq;
|
|
|
|
|
|
|
|
dev_set_drvdata(&ndev->dev, mdp->mii_bus);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
out_free_irq:
|
|
|
|
kfree(mdp->mii_bus->irq);
|
|
|
|
|
|
|
|
out_free_bus:
|
2008-10-09 06:29:57 +07:00
|
|
|
free_mdio_bitbang(mdp->mii_bus);
|
2008-06-10 06:33:56 +07:00
|
|
|
|
|
|
|
out_free_bitbang:
|
|
|
|
kfree(bitbang);
|
|
|
|
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-04-11 14:40:49 +07:00
|
|
|
static const struct net_device_ops sh_eth_netdev_ops = {
|
|
|
|
.ndo_open = sh_eth_open,
|
|
|
|
.ndo_stop = sh_eth_close,
|
|
|
|
.ndo_start_xmit = sh_eth_start_xmit,
|
|
|
|
.ndo_get_stats = sh_eth_get_stats,
|
2009-05-25 06:54:21 +07:00
|
|
|
#if defined(SH_ETH_HAS_TSU)
|
2009-04-11 14:40:49 +07:00
|
|
|
.ndo_set_multicast_list = sh_eth_set_multicast_list,
|
2009-05-25 06:54:21 +07:00
|
|
|
#endif
|
2009-04-11 14:40:49 +07:00
|
|
|
.ndo_tx_timeout = sh_eth_tx_timeout,
|
|
|
|
.ndo_do_ioctl = sh_eth_do_ioctl,
|
|
|
|
.ndo_validate_addr = eth_validate_addr,
|
|
|
|
.ndo_set_mac_address = eth_mac_addr,
|
|
|
|
.ndo_change_mtu = eth_change_mtu,
|
|
|
|
};
|
|
|
|
|
2008-06-10 06:33:56 +07:00
|
|
|
static int sh_eth_drv_probe(struct platform_device *pdev)
|
|
|
|
{
|
2010-08-19 14:39:45 +07:00
|
|
|
int ret, devno = 0;
|
2008-06-10 06:33:56 +07:00
|
|
|
struct resource *res;
|
|
|
|
struct net_device *ndev = NULL;
|
|
|
|
struct sh_eth_private *mdp;
|
2008-08-07 06:49:00 +07:00
|
|
|
struct sh_eth_plat_data *pd;
|
2008-06-10 06:33:56 +07:00
|
|
|
|
|
|
|
/* get base addr */
|
|
|
|
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
|
|
|
if (unlikely(res == NULL)) {
|
|
|
|
dev_err(&pdev->dev, "invalid resource\n");
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
ndev = alloc_etherdev(sizeof(struct sh_eth_private));
|
|
|
|
if (!ndev) {
|
2009-05-25 06:54:21 +07:00
|
|
|
dev_err(&pdev->dev, "Could not allocate device.\n");
|
2008-06-10 06:33:56 +07:00
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* The sh Ether-specific entries in the device structure. */
|
|
|
|
ndev->base_addr = res->start;
|
|
|
|
devno = pdev->id;
|
|
|
|
if (devno < 0)
|
|
|
|
devno = 0;
|
|
|
|
|
|
|
|
ndev->dma = -1;
|
2008-09-11 00:22:44 +07:00
|
|
|
ret = platform_get_irq(pdev, 0);
|
|
|
|
if (ret < 0) {
|
2008-06-10 06:33:56 +07:00
|
|
|
ret = -ENODEV;
|
|
|
|
goto out_release;
|
|
|
|
}
|
2008-09-11 00:22:44 +07:00
|
|
|
ndev->irq = ret;
|
2008-06-10 06:33:56 +07:00
|
|
|
|
|
|
|
SET_NETDEV_DEV(ndev, &pdev->dev);
|
|
|
|
|
|
|
|
/* Fill in the fields of the device structure with ethernet values. */
|
|
|
|
ether_setup(ndev);
|
|
|
|
|
|
|
|
mdp = netdev_priv(ndev);
|
|
|
|
spin_lock_init(&mdp->lock);
|
2009-10-09 07:20:04 +07:00
|
|
|
mdp->pdev = pdev;
|
|
|
|
pm_runtime_enable(&pdev->dev);
|
|
|
|
pm_runtime_resume(&pdev->dev);
|
2008-06-10 06:33:56 +07:00
|
|
|
|
2008-08-07 06:49:00 +07:00
|
|
|
pd = (struct sh_eth_plat_data *)(pdev->dev.platform_data);
|
2008-06-10 06:33:56 +07:00
|
|
|
/* get PHY ID */
|
2008-08-07 06:49:00 +07:00
|
|
|
mdp->phy_id = pd->phy;
|
|
|
|
/* EDMAC endian */
|
|
|
|
mdp->edmac_endian = pd->edmac_endian;
|
2009-08-28 06:25:03 +07:00
|
|
|
mdp->no_ether_link = pd->no_ether_link;
|
|
|
|
mdp->ether_link_active_low = pd->ether_link_active_low;
|
2008-06-10 06:33:56 +07:00
|
|
|
|
2009-05-25 06:54:21 +07:00
|
|
|
/* set cpu data */
|
|
|
|
mdp->cd = &sh_eth_my_cpu_data;
|
|
|
|
sh_eth_set_default_cpu_data(mdp->cd);
|
|
|
|
|
2008-06-10 06:33:56 +07:00
|
|
|
/* set function */
|
2009-04-11 14:40:49 +07:00
|
|
|
ndev->netdev_ops = &sh_eth_netdev_ops;
|
2008-06-10 06:33:56 +07:00
|
|
|
ndev->watchdog_timeo = TX_TIMEOUT;
|
|
|
|
|
|
|
|
mdp->post_rx = POST_RX >> (devno << 1);
|
|
|
|
mdp->post_fw = POST_FW >> (devno << 1);
|
|
|
|
|
|
|
|
/* read and set MAC address */
|
2009-10-09 07:17:14 +07:00
|
|
|
read_mac_address(ndev, pd->mac_addr);
|
2008-06-10 06:33:56 +07:00
|
|
|
|
|
|
|
/* First device only init */
|
|
|
|
if (!devno) {
|
2009-05-25 06:54:21 +07:00
|
|
|
if (mdp->cd->chip_reset)
|
|
|
|
mdp->cd->chip_reset(ndev);
|
2008-06-10 06:33:56 +07:00
|
|
|
|
2009-05-25 06:54:21 +07:00
|
|
|
#if defined(SH_ETH_HAS_TSU)
|
2008-06-10 06:33:56 +07:00
|
|
|
/* TSU init (Init only)*/
|
|
|
|
sh_eth_tsu_init(SH_TSU_ADDR);
|
2008-08-07 06:49:00 +07:00
|
|
|
#endif
|
2008-06-10 06:33:56 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* network device register */
|
|
|
|
ret = register_netdev(ndev);
|
|
|
|
if (ret)
|
|
|
|
goto out_release;
|
|
|
|
|
|
|
|
/* mdio bus init */
|
|
|
|
ret = sh_mdio_init(ndev, pdev->id);
|
|
|
|
if (ret)
|
|
|
|
goto out_unregister;
|
|
|
|
|
2009-12-30 11:10:35 +07:00
|
|
|
/* print device infomation */
|
|
|
|
pr_info("Base address at 0x%x, %pM, IRQ %d.\n",
|
|
|
|
(u32)ndev->base_addr, ndev->dev_addr, ndev->irq);
|
2008-06-10 06:33:56 +07:00
|
|
|
|
|
|
|
platform_set_drvdata(pdev, ndev);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
out_unregister:
|
|
|
|
unregister_netdev(ndev);
|
|
|
|
|
|
|
|
out_release:
|
|
|
|
/* net_dev free */
|
|
|
|
if (ndev)
|
|
|
|
free_netdev(ndev);
|
|
|
|
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sh_eth_drv_remove(struct platform_device *pdev)
|
|
|
|
{
|
|
|
|
struct net_device *ndev = platform_get_drvdata(pdev);
|
|
|
|
|
|
|
|
sh_mdio_release(ndev);
|
|
|
|
unregister_netdev(ndev);
|
|
|
|
flush_scheduled_work();
|
2009-10-09 07:20:04 +07:00
|
|
|
pm_runtime_disable(&pdev->dev);
|
2008-06-10 06:33:56 +07:00
|
|
|
free_netdev(ndev);
|
|
|
|
platform_set_drvdata(pdev, NULL);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-10-09 07:20:04 +07:00
|
|
|
static int sh_eth_runtime_nop(struct device *dev)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Runtime PM callback shared between ->runtime_suspend()
|
|
|
|
* and ->runtime_resume(). Simply returns success.
|
|
|
|
*
|
|
|
|
* This driver re-initializes all registers after
|
|
|
|
* pm_runtime_get_sync() anyway so there is no need
|
|
|
|
* to save and restore registers here.
|
|
|
|
*/
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct dev_pm_ops sh_eth_dev_pm_ops = {
|
|
|
|
.runtime_suspend = sh_eth_runtime_nop,
|
|
|
|
.runtime_resume = sh_eth_runtime_nop,
|
|
|
|
};
|
|
|
|
|
2008-06-10 06:33:56 +07:00
|
|
|
static struct platform_driver sh_eth_driver = {
|
|
|
|
.probe = sh_eth_drv_probe,
|
|
|
|
.remove = sh_eth_drv_remove,
|
|
|
|
.driver = {
|
|
|
|
.name = CARDNAME,
|
2009-10-09 07:20:04 +07:00
|
|
|
.pm = &sh_eth_dev_pm_ops,
|
2008-06-10 06:33:56 +07:00
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static int __init sh_eth_init(void)
|
|
|
|
{
|
|
|
|
return platform_driver_register(&sh_eth_driver);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit sh_eth_cleanup(void)
|
|
|
|
{
|
|
|
|
platform_driver_unregister(&sh_eth_driver);
|
|
|
|
}
|
|
|
|
|
|
|
|
module_init(sh_eth_init);
|
|
|
|
module_exit(sh_eth_cleanup);
|
|
|
|
|
|
|
|
MODULE_AUTHOR("Nobuhiro Iwamatsu, Yoshihiro Shimoda");
|
|
|
|
MODULE_DESCRIPTION("Renesas SuperH Ethernet driver");
|
|
|
|
MODULE_LICENSE("GPL v2");
|