2008-06-09 23:33:56 +00:00
|
|
|
/*
|
|
|
|
* SuperH Ethernet device driver
|
|
|
|
*
|
2012-03-25 18:59:51 +00:00
|
|
|
* Copyright (C) 2006-2012 Nobuhiro Iwamatsu
|
|
|
|
* Copyright (C) 2008-2012 Renesas Solutions Corp.
|
2008-06-09 23:33:56 +00: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>
|
2011-09-29 17:16:57 +00:00
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/spinlock.h>
|
2011-08-09 20:15:50 +00:00
|
|
|
#include <linux/interrupt.h>
|
2008-06-09 23:33:56 +00:00
|
|
|
#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 00:20:04 +00: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 08:04:11 +00:00
|
|
|
#include <linux/slab.h>
|
2011-02-15 21:17:32 +00:00
|
|
|
#include <linux/ethtool.h>
|
2012-02-06 23:55:15 +00:00
|
|
|
#include <linux/if_vlan.h>
|
2012-03-25 18:59:51 +00:00
|
|
|
#include <linux/clk.h>
|
2011-09-27 21:49:12 +00:00
|
|
|
#include <linux/sh_eth.h>
|
2008-06-09 23:33:56 +00:00
|
|
|
|
|
|
|
#include "sh_eth.h"
|
|
|
|
|
2011-02-15 21:17:32 +00:00
|
|
|
#define SH_ETH_DEF_MSG_ENABLE \
|
|
|
|
(NETIF_MSG_LINK | \
|
|
|
|
NETIF_MSG_TIMER | \
|
|
|
|
NETIF_MSG_RX_ERR| \
|
|
|
|
NETIF_MSG_TX_ERR)
|
|
|
|
|
2009-05-24 23:54:21 +00:00
|
|
|
/* There is CPU dependent code */
|
2009-05-24 23:54:30 +00: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);
|
|
|
|
|
|
|
|
if (mdp->duplex) /* Full */
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_write(ndev, sh_eth_read(ndev, ECMR) | ECMR_DM, ECMR);
|
2009-05-24 23:54:30 +00:00
|
|
|
else /* Half */
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_write(ndev, sh_eth_read(ndev, ECMR) & ~ECMR_DM, ECMR);
|
2009-05-24 23:54:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void sh_eth_set_rate(struct net_device *ndev)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
|
|
|
|
switch (mdp->speed) {
|
|
|
|
case 10: /* 10BASE */
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_write(ndev, sh_eth_read(ndev, ECMR) & ~ECMR_RTM, ECMR);
|
2009-05-24 23:54:30 +00:00
|
|
|
break;
|
|
|
|
case 100:/* 100BASE */
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_write(ndev, sh_eth_read(ndev, ECMR) | ECMR_RTM, ECMR);
|
2009-05-24 23:54:30 +00: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 05:16:55 +00:00
|
|
|
.rpadir = 1,
|
|
|
|
.rpadir_value = 0x00020000, /* NET_IP_ALIGN assumed to be 2 */
|
2009-05-24 23:54:30 +00:00
|
|
|
};
|
2010-07-05 18:32:50 +00:00
|
|
|
#elif defined(CONFIG_CPU_SUBTYPE_SH7757)
|
2011-03-07 21:59:49 +00:00
|
|
|
#define SH_ETH_HAS_BOTH_MODULES 1
|
|
|
|
#define SH_ETH_HAS_TSU 1
|
2010-07-05 18:32:50 +00:00
|
|
|
static void sh_eth_set_duplex(struct net_device *ndev)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
|
|
|
|
if (mdp->duplex) /* Full */
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_write(ndev, sh_eth_read(ndev, ECMR) | ECMR_DM, ECMR);
|
2010-07-05 18:32:50 +00:00
|
|
|
else /* Half */
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_write(ndev, sh_eth_read(ndev, ECMR) & ~ECMR_DM, ECMR);
|
2010-07-05 18:32:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void sh_eth_set_rate(struct net_device *ndev)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
|
|
|
|
switch (mdp->speed) {
|
|
|
|
case 10: /* 10BASE */
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_write(ndev, 0, RTRATE);
|
2010-07-05 18:32:50 +00:00
|
|
|
break;
|
|
|
|
case 100:/* 100BASE */
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_write(ndev, 1, RTRATE);
|
2010-07-05 18:32:50 +00: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,
|
2011-07-05 20:33:57 +00:00
|
|
|
.rpadir = 1,
|
|
|
|
.rpadir_value = 2 << 16,
|
2010-07-05 18:32:50 +00:00
|
|
|
};
|
2009-05-24 23:54:30 +00:00
|
|
|
|
2011-03-07 21:59:49 +00:00
|
|
|
#define SH_GIGA_ETH_BASE 0xfee00000
|
|
|
|
#define GIGA_MALR(port) (SH_GIGA_ETH_BASE + 0x800 * (port) + 0x05c8)
|
|
|
|
#define GIGA_MAHR(port) (SH_GIGA_ETH_BASE + 0x800 * (port) + 0x05c0)
|
|
|
|
static void sh_eth_chip_reset_giga(struct net_device *ndev)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
unsigned long mahr[2], malr[2];
|
|
|
|
|
|
|
|
/* save MAHR and MALR */
|
|
|
|
for (i = 0; i < 2; i++) {
|
2011-09-27 21:48:58 +00:00
|
|
|
malr[i] = ioread32((void *)GIGA_MALR(i));
|
|
|
|
mahr[i] = ioread32((void *)GIGA_MAHR(i));
|
2011-03-07 21:59:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* reset device */
|
2011-09-27 21:48:58 +00:00
|
|
|
iowrite32(ARSTR_ARSTR, (void *)(SH_GIGA_ETH_BASE + 0x1800));
|
2011-03-07 21:59:49 +00:00
|
|
|
mdelay(1);
|
|
|
|
|
|
|
|
/* restore MAHR and MALR */
|
|
|
|
for (i = 0; i < 2; i++) {
|
2011-09-27 21:48:58 +00:00
|
|
|
iowrite32(malr[i], (void *)GIGA_MALR(i));
|
|
|
|
iowrite32(mahr[i], (void *)GIGA_MAHR(i));
|
2011-03-07 21:59:49 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sh_eth_is_gether(struct sh_eth_private *mdp);
|
|
|
|
static void sh_eth_reset(struct net_device *ndev)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
int cnt = 100;
|
|
|
|
|
|
|
|
if (sh_eth_is_gether(mdp)) {
|
|
|
|
sh_eth_write(ndev, 0x03, EDSR);
|
|
|
|
sh_eth_write(ndev, sh_eth_read(ndev, EDMR) | EDMR_SRST_GETHER,
|
|
|
|
EDMR);
|
|
|
|
while (cnt > 0) {
|
|
|
|
if (!(sh_eth_read(ndev, EDMR) & 0x3))
|
|
|
|
break;
|
|
|
|
mdelay(1);
|
|
|
|
cnt--;
|
|
|
|
}
|
|
|
|
if (cnt < 0)
|
|
|
|
printk(KERN_ERR "Device reset fail\n");
|
|
|
|
|
|
|
|
/* Table Init */
|
|
|
|
sh_eth_write(ndev, 0x0, TDLAR);
|
|
|
|
sh_eth_write(ndev, 0x0, TDFAR);
|
|
|
|
sh_eth_write(ndev, 0x0, TDFXR);
|
|
|
|
sh_eth_write(ndev, 0x0, TDFFR);
|
|
|
|
sh_eth_write(ndev, 0x0, RDLAR);
|
|
|
|
sh_eth_write(ndev, 0x0, RDFAR);
|
|
|
|
sh_eth_write(ndev, 0x0, RDFXR);
|
|
|
|
sh_eth_write(ndev, 0x0, RDFFR);
|
|
|
|
} else {
|
|
|
|
sh_eth_write(ndev, sh_eth_read(ndev, EDMR) | EDMR_SRST_ETHER,
|
|
|
|
EDMR);
|
|
|
|
mdelay(3);
|
|
|
|
sh_eth_write(ndev, sh_eth_read(ndev, EDMR) & ~EDMR_SRST_ETHER,
|
|
|
|
EDMR);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void sh_eth_set_duplex_giga(struct net_device *ndev)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
|
|
|
|
if (mdp->duplex) /* Full */
|
|
|
|
sh_eth_write(ndev, sh_eth_read(ndev, ECMR) | ECMR_DM, ECMR);
|
|
|
|
else /* Half */
|
|
|
|
sh_eth_write(ndev, sh_eth_read(ndev, ECMR) & ~ECMR_DM, ECMR);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void sh_eth_set_rate_giga(struct net_device *ndev)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
|
|
|
|
switch (mdp->speed) {
|
|
|
|
case 10: /* 10BASE */
|
|
|
|
sh_eth_write(ndev, 0x00000000, GECMR);
|
|
|
|
break;
|
|
|
|
case 100:/* 100BASE */
|
|
|
|
sh_eth_write(ndev, 0x00000010, GECMR);
|
|
|
|
break;
|
|
|
|
case 1000: /* 1000BASE */
|
|
|
|
sh_eth_write(ndev, 0x00000020, GECMR);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* SH7757(GETHERC) */
|
|
|
|
static struct sh_eth_cpu_data sh_eth_my_cpu_data_giga = {
|
|
|
|
.chip_reset = sh_eth_chip_reset_giga,
|
|
|
|
.set_duplex = sh_eth_set_duplex_giga,
|
|
|
|
.set_rate = sh_eth_set_rate_giga,
|
|
|
|
|
|
|
|
.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,
|
|
|
|
.fdr_value = 0x0000072f,
|
|
|
|
.rmcr_value = 0x00000001,
|
|
|
|
|
|
|
|
.apr = 1,
|
|
|
|
.mpr = 1,
|
|
|
|
.tpauser = 1,
|
|
|
|
.bculr = 1,
|
|
|
|
.hw_swap = 1,
|
|
|
|
.rpadir = 1,
|
|
|
|
.rpadir_value = 2 << 16,
|
|
|
|
.no_trimd = 1,
|
|
|
|
.no_ade = 1,
|
2012-02-15 17:54:51 +00:00
|
|
|
.tsu = 1,
|
2011-03-07 21:59:49 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static struct sh_eth_cpu_data *sh_eth_get_cpu_data(struct sh_eth_private *mdp)
|
|
|
|
{
|
|
|
|
if (sh_eth_is_gether(mdp))
|
|
|
|
return &sh_eth_my_cpu_data_giga;
|
|
|
|
else
|
|
|
|
return &sh_eth_my_cpu_data;
|
|
|
|
}
|
|
|
|
|
2012-03-25 18:59:51 +00:00
|
|
|
#elif defined(CONFIG_CPU_SUBTYPE_SH7734) || defined(CONFIG_CPU_SUBTYPE_SH7763)
|
2009-05-24 23:54:21 +00:00
|
|
|
#define SH_ETH_HAS_TSU 1
|
2012-03-25 18:59:51 +00:00
|
|
|
static void sh_eth_reset_hw_crc(struct net_device *ndev);
|
2009-05-24 23:54:21 +00:00
|
|
|
static void sh_eth_chip_reset(struct net_device *ndev)
|
|
|
|
{
|
2011-03-07 21:59:34 +00:00
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
|
2009-05-24 23:54:21 +00:00
|
|
|
/* reset device */
|
2011-03-07 21:59:34 +00:00
|
|
|
sh_eth_tsu_write(mdp, ARSTR_ARSTR, ARSTR);
|
2009-05-24 23:54:21 +00:00
|
|
|
mdelay(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void sh_eth_reset(struct net_device *ndev)
|
|
|
|
{
|
|
|
|
int cnt = 100;
|
|
|
|
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_write(ndev, EDSR_ENALL, EDSR);
|
2011-03-07 21:59:38 +00:00
|
|
|
sh_eth_write(ndev, sh_eth_read(ndev, EDMR) | EDMR_SRST_GETHER, EDMR);
|
2009-05-24 23:54:21 +00:00
|
|
|
while (cnt > 0) {
|
2011-03-07 21:59:26 +00:00
|
|
|
if (!(sh_eth_read(ndev, EDMR) & 0x3))
|
2009-05-24 23:54:21 +00:00
|
|
|
break;
|
|
|
|
mdelay(1);
|
|
|
|
cnt--;
|
|
|
|
}
|
2009-12-30 01:43:45 +00:00
|
|
|
if (cnt == 0)
|
2009-05-24 23:54:21 +00:00
|
|
|
printk(KERN_ERR "Device reset fail\n");
|
|
|
|
|
|
|
|
/* Table Init */
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_write(ndev, 0x0, TDLAR);
|
|
|
|
sh_eth_write(ndev, 0x0, TDFAR);
|
|
|
|
sh_eth_write(ndev, 0x0, TDFXR);
|
|
|
|
sh_eth_write(ndev, 0x0, TDFFR);
|
|
|
|
sh_eth_write(ndev, 0x0, RDLAR);
|
|
|
|
sh_eth_write(ndev, 0x0, RDFAR);
|
|
|
|
sh_eth_write(ndev, 0x0, RDFXR);
|
|
|
|
sh_eth_write(ndev, 0x0, RDFFR);
|
2012-03-25 18:59:51 +00:00
|
|
|
|
|
|
|
/* Reset HW CRC register */
|
|
|
|
sh_eth_reset_hw_crc(ndev);
|
2009-05-24 23:54:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void sh_eth_set_duplex(struct net_device *ndev)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
|
|
|
|
if (mdp->duplex) /* Full */
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_write(ndev, sh_eth_read(ndev, ECMR) | ECMR_DM, ECMR);
|
2009-05-24 23:54:21 +00:00
|
|
|
else /* Half */
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_write(ndev, sh_eth_read(ndev, ECMR) & ~ECMR_DM, ECMR);
|
2009-05-24 23:54:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void sh_eth_set_rate(struct net_device *ndev)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
|
|
|
|
switch (mdp->speed) {
|
|
|
|
case 10: /* 10BASE */
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_write(ndev, GECMR_10, GECMR);
|
2009-05-24 23:54:21 +00:00
|
|
|
break;
|
|
|
|
case 100:/* 100BASE */
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_write(ndev, GECMR_100, GECMR);
|
2009-05-24 23:54:21 +00:00
|
|
|
break;
|
|
|
|
case 1000: /* 1000BASE */
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_write(ndev, GECMR_1000, GECMR);
|
2009-05-24 23:54:21 +00: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,
|
2011-03-07 21:59:34 +00:00
|
|
|
.tsu = 1,
|
2012-03-25 18:59:51 +00:00
|
|
|
#if defined(CONFIG_CPU_SUBTYPE_SH7734)
|
|
|
|
.hw_crc = 1,
|
|
|
|
#endif
|
2009-05-24 23:54:21 +00:00
|
|
|
};
|
|
|
|
|
2012-03-25 18:59:51 +00:00
|
|
|
static void sh_eth_reset_hw_crc(struct net_device *ndev)
|
|
|
|
{
|
|
|
|
if (sh_eth_my_cpu_data.hw_crc)
|
|
|
|
sh_eth_write(ndev, 0x0, CSMR);
|
|
|
|
}
|
|
|
|
|
2009-05-24 23:54:21 +00:00
|
|
|
#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,
|
2011-03-07 21:59:34 +00:00
|
|
|
.tsu = 1,
|
2009-05-24 23:54:21 +00:00
|
|
|
};
|
|
|
|
#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)
|
|
|
|
{
|
2011-03-07 21:59:38 +00:00
|
|
|
sh_eth_write(ndev, sh_eth_read(ndev, EDMR) | EDMR_SRST_ETHER, EDMR);
|
2009-05-24 23:54:21 +00:00
|
|
|
mdelay(3);
|
2011-03-07 21:59:38 +00:00
|
|
|
sh_eth_write(ndev, sh_eth_read(ndev, EDMR) & ~EDMR_SRST_ETHER, EDMR);
|
2009-05-24 23:54:21 +00: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-06 23:49:00 +00: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-09 23:33:56 +00:00
|
|
|
/*
|
|
|
|
* Program the hardware MAC address from dev->dev_addr.
|
|
|
|
*/
|
|
|
|
static void update_mac_address(struct net_device *ndev)
|
|
|
|
{
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_write(ndev,
|
|
|
|
(ndev->dev_addr[0] << 24) | (ndev->dev_addr[1] << 16) |
|
|
|
|
(ndev->dev_addr[2] << 8) | (ndev->dev_addr[3]), MAHR);
|
|
|
|
sh_eth_write(ndev,
|
|
|
|
(ndev->dev_addr[4] << 8) | (ndev->dev_addr[5]), MALR);
|
2008-06-09 23:33:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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 00:17:14 +00:00
|
|
|
static void read_mac_address(struct net_device *ndev, unsigned char *mac)
|
2008-06-09 23:33:56 +00:00
|
|
|
{
|
2009-10-09 00:17:14 +00:00
|
|
|
if (mac[0] || mac[1] || mac[2] || mac[3] || mac[4] || mac[5]) {
|
|
|
|
memcpy(ndev->dev_addr, mac, 6);
|
|
|
|
} else {
|
2011-03-07 21:59:26 +00:00
|
|
|
ndev->dev_addr[0] = (sh_eth_read(ndev, MAHR) >> 24);
|
|
|
|
ndev->dev_addr[1] = (sh_eth_read(ndev, MAHR) >> 16) & 0xFF;
|
|
|
|
ndev->dev_addr[2] = (sh_eth_read(ndev, MAHR) >> 8) & 0xFF;
|
|
|
|
ndev->dev_addr[3] = (sh_eth_read(ndev, MAHR) & 0xFF);
|
|
|
|
ndev->dev_addr[4] = (sh_eth_read(ndev, MALR) >> 8) & 0xFF;
|
|
|
|
ndev->dev_addr[5] = (sh_eth_read(ndev, MALR) & 0xFF);
|
2009-10-09 00:17:14 +00:00
|
|
|
}
|
2008-06-09 23:33:56 +00:00
|
|
|
}
|
|
|
|
|
2011-03-07 21:59:38 +00:00
|
|
|
static int sh_eth_is_gether(struct sh_eth_private *mdp)
|
|
|
|
{
|
|
|
|
if (mdp->reg_offset == sh_eth_offset_gigabit)
|
|
|
|
return 1;
|
|
|
|
else
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned long sh_eth_get_edtrr_trns(struct sh_eth_private *mdp)
|
|
|
|
{
|
|
|
|
if (sh_eth_is_gether(mdp))
|
|
|
|
return EDTRR_TRNS_GETHER;
|
|
|
|
else
|
|
|
|
return EDTRR_TRNS_ETHER;
|
|
|
|
}
|
|
|
|
|
2008-06-09 23:33:56 +00:00
|
|
|
struct bb_info {
|
2011-09-27 21:48:58 +00:00
|
|
|
void (*set_gate)(void *addr);
|
2008-06-09 23:33:56 +00:00
|
|
|
struct mdiobb_ctrl ctrl;
|
2011-09-27 21:48:58 +00:00
|
|
|
void *addr;
|
2008-06-09 23:33:56 +00:00
|
|
|
u32 mmd_msk;/* MMD */
|
|
|
|
u32 mdo_msk;
|
|
|
|
u32 mdi_msk;
|
|
|
|
u32 mdc_msk;
|
|
|
|
};
|
|
|
|
|
|
|
|
/* PHY bit set */
|
2011-09-27 21:48:58 +00:00
|
|
|
static void bb_set(void *addr, u32 msk)
|
2008-06-09 23:33:56 +00:00
|
|
|
{
|
2011-09-27 21:48:58 +00:00
|
|
|
iowrite32(ioread32(addr) | msk, addr);
|
2008-06-09 23:33:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* PHY bit clear */
|
2011-09-27 21:48:58 +00:00
|
|
|
static void bb_clr(void *addr, u32 msk)
|
2008-06-09 23:33:56 +00:00
|
|
|
{
|
2011-09-27 21:48:58 +00:00
|
|
|
iowrite32((ioread32(addr) & ~msk), addr);
|
2008-06-09 23:33:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* PHY bit read */
|
2011-09-27 21:48:58 +00:00
|
|
|
static int bb_read(void *addr, u32 msk)
|
2008-06-09 23:33:56 +00:00
|
|
|
{
|
2011-09-27 21:48:58 +00:00
|
|
|
return (ioread32(addr) & msk) != 0;
|
2008-06-09 23:33:56 +00: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);
|
2011-03-07 21:59:55 +00:00
|
|
|
|
|
|
|
if (bitbang->set_gate)
|
|
|
|
bitbang->set_gate(bitbang->addr);
|
|
|
|
|
2008-06-09 23:33:56 +00:00
|
|
|
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);
|
|
|
|
|
2011-03-07 21:59:55 +00:00
|
|
|
if (bitbang->set_gate)
|
|
|
|
bitbang->set_gate(bitbang->addr);
|
|
|
|
|
2008-06-09 23:33:56 +00:00
|
|
|
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);
|
2011-03-07 21:59:55 +00:00
|
|
|
|
|
|
|
if (bitbang->set_gate)
|
|
|
|
bitbang->set_gate(bitbang->addr);
|
|
|
|
|
2008-06-09 23:33:56 +00:00
|
|
|
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);
|
|
|
|
|
2011-03-07 21:59:55 +00:00
|
|
|
if (bitbang->set_gate)
|
|
|
|
bitbang->set_gate(bitbang->addr);
|
|
|
|
|
2008-06-09 23:33:56 +00:00
|
|
|
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)
|
|
|
|
{
|
|
|
|
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;
|
2012-02-06 11:16:13 +00:00
|
|
|
skb = netdev_alloc_skb(ndev, mdp->rx_buf_sz);
|
2008-06-09 23:33:56 +00:00
|
|
|
mdp->rx_skbuff[i] = skb;
|
|
|
|
if (skb == NULL)
|
|
|
|
break;
|
2012-02-06 22:17:21 +00:00
|
|
|
dma_map_single(&ndev->dev, skb->data, mdp->rx_buf_sz,
|
2009-05-24 23:52:35 +00:00
|
|
|
DMA_FROM_DEVICE);
|
2009-05-24 23:54:21 +00:00
|
|
|
sh_eth_set_receive_align(skb);
|
|
|
|
|
2008-06-09 23:33:56 +00:00
|
|
|
/* RX descriptor */
|
|
|
|
rxdesc = &mdp->rx_ring[i];
|
2009-05-24 23:53:20 +00:00
|
|
|
rxdesc->addr = virt_to_phys(PTR_ALIGN(skb->data, 4));
|
2008-08-06 23:49:00 +00:00
|
|
|
rxdesc->status = cpu_to_edmac(mdp, RD_RACT | RD_RFP);
|
2008-06-09 23:33:56 +00:00
|
|
|
|
|
|
|
/* The size of the buffer is 16 byte boundary. */
|
2009-05-24 23:53:20 +00:00
|
|
|
rxdesc->buffer_length = ALIGN(mdp->rx_buf_sz, 16);
|
2008-06-30 02:08:17 +00:00
|
|
|
/* Rx descriptor address set */
|
|
|
|
if (i == 0) {
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_write(ndev, mdp->rx_desc_dma, RDLAR);
|
2011-03-07 21:59:38 +00:00
|
|
|
if (sh_eth_is_gether(mdp))
|
|
|
|
sh_eth_write(ndev, mdp->rx_desc_dma, RDFAR);
|
2008-06-30 02:08:17 +00:00
|
|
|
}
|
2008-06-09 23:33:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
mdp->dirty_rx = (u32) (i - RX_RING_SIZE);
|
|
|
|
|
|
|
|
/* Mark the last entry as wrapping the ring. */
|
2008-08-06 23:49:00 +00:00
|
|
|
rxdesc->status |= cpu_to_edmac(mdp, RD_RDEL);
|
2008-06-09 23:33:56 +00: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-06 23:49:00 +00:00
|
|
|
txdesc->status = cpu_to_edmac(mdp, TD_TFP);
|
2008-06-09 23:33:56 +00:00
|
|
|
txdesc->buffer_length = 0;
|
2008-06-30 02:08:17 +00:00
|
|
|
if (i == 0) {
|
2008-08-06 23:49:00 +00:00
|
|
|
/* Tx descriptor address set */
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_write(ndev, mdp->tx_desc_dma, TDLAR);
|
2011-03-07 21:59:38 +00:00
|
|
|
if (sh_eth_is_gether(mdp))
|
|
|
|
sh_eth_write(ndev, mdp->tx_desc_dma, TDFAR);
|
2008-06-30 02:08:17 +00:00
|
|
|
}
|
2008-06-09 23:33:56 +00:00
|
|
|
}
|
|
|
|
|
2008-08-06 23:49:00 +00:00
|
|
|
txdesc->status |= cpu_to_edmac(mdp, TD_TDLE);
|
2008-06-09 23:33:56 +00: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 05:16:55 +00:00
|
|
|
if (mdp->cd->rpadir)
|
|
|
|
mdp->rx_buf_sz += NET_IP_ALIGN;
|
2008-06-09 23:33:56 +00: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-24 23:54:21 +00:00
|
|
|
dev_err(&ndev->dev, "Cannot allocate Rx skb\n");
|
2008-06-09 23:33:56 +00:00
|
|
|
ret = -ENOMEM;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
mdp->tx_skbuff = kmalloc(sizeof(*mdp->tx_skbuff) * TX_RING_SIZE,
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (!mdp->tx_skbuff) {
|
2009-05-24 23:54:21 +00:00
|
|
|
dev_err(&ndev->dev, "Cannot allocate Tx skb\n");
|
2008-06-09 23:33:56 +00: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-24 23:54:21 +00:00
|
|
|
dev_err(&ndev->dev, "Cannot allocate Rx Ring (size %d bytes)\n",
|
|
|
|
rx_ringsize);
|
2008-06-09 23:33:56 +00: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-24 23:54:21 +00:00
|
|
|
dev_err(&ndev->dev, "Cannot allocate Tx Ring (size %d bytes)\n",
|
|
|
|
tx_ringsize);
|
2008-06-09 23:33:56 +00: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);
|
|
|
|
u_int32_t rx_int_var, tx_int_var;
|
|
|
|
u32 val;
|
|
|
|
|
|
|
|
/* Soft Reset */
|
|
|
|
sh_eth_reset(ndev);
|
|
|
|
|
2008-06-30 02:08:17 +00:00
|
|
|
/* Descriptor format */
|
|
|
|
sh_eth_ring_format(ndev);
|
2009-05-24 23:54:21 +00:00
|
|
|
if (mdp->cd->rpadir)
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_write(ndev, mdp->cd->rpadir_value, RPADIR);
|
2008-06-09 23:33:56 +00:00
|
|
|
|
|
|
|
/* all sh_eth int mask */
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_write(ndev, 0, EESIPR);
|
2008-06-09 23:33:56 +00:00
|
|
|
|
2012-03-29 19:32:08 +00:00
|
|
|
#if defined(__LITTLE_ENDIAN)
|
2009-05-24 23:54:21 +00:00
|
|
|
if (mdp->cd->hw_swap)
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_write(ndev, EDMR_EL, EDMR);
|
2009-05-24 23:54:21 +00:00
|
|
|
else
|
2008-06-30 02:08:17 +00:00
|
|
|
#endif
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_write(ndev, 0, EDMR);
|
2008-06-09 23:33:56 +00:00
|
|
|
|
2008-06-30 02:08:17 +00:00
|
|
|
/* FIFO size set */
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_write(ndev, mdp->cd->fdr_value, FDR);
|
|
|
|
sh_eth_write(ndev, 0, TFTR);
|
2008-06-09 23:33:56 +00:00
|
|
|
|
2008-06-30 02:08:17 +00:00
|
|
|
/* Frame recv control */
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_write(ndev, mdp->cd->rmcr_value, RMCR);
|
2008-06-09 23:33:56 +00:00
|
|
|
|
|
|
|
rx_int_var = mdp->rx_int_var = DESC_I_RINT8 | DESC_I_RINT5;
|
|
|
|
tx_int_var = mdp->tx_int_var = DESC_I_TINT2;
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_write(ndev, rx_int_var | tx_int_var, TRSCER);
|
2008-06-09 23:33:56 +00:00
|
|
|
|
2009-05-24 23:54:21 +00:00
|
|
|
if (mdp->cd->bculr)
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_write(ndev, 0x800, BCULR); /* Burst sycle set */
|
2008-06-30 02:08:17 +00:00
|
|
|
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_write(ndev, mdp->cd->fcftr_value, FCFTR);
|
2008-06-09 23:33:56 +00:00
|
|
|
|
2009-05-24 23:54:21 +00:00
|
|
|
if (!mdp->cd->no_trimd)
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_write(ndev, 0, TRIMD);
|
2008-06-09 23:33:56 +00:00
|
|
|
|
2008-06-30 02:08:17 +00:00
|
|
|
/* Recv frame limit set register */
|
2012-02-06 23:55:15 +00:00
|
|
|
sh_eth_write(ndev, ndev->mtu + ETH_HLEN + VLAN_HLEN + ETH_FCS_LEN,
|
|
|
|
RFLR);
|
2008-06-09 23:33:56 +00:00
|
|
|
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_write(ndev, sh_eth_read(ndev, EESR), EESR);
|
|
|
|
sh_eth_write(ndev, mdp->cd->eesipr_value, EESIPR);
|
2008-06-09 23:33:56 +00:00
|
|
|
|
|
|
|
/* PAUSE Prohibition */
|
2011-03-07 21:59:26 +00:00
|
|
|
val = (sh_eth_read(ndev, ECMR) & ECMR_DM) |
|
2008-06-09 23:33:56 +00:00
|
|
|
ECMR_ZPF | (mdp->duplex ? ECMR_DM : 0) | ECMR_TE | ECMR_RE;
|
|
|
|
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_write(ndev, val, ECMR);
|
2008-06-30 02:08:17 +00:00
|
|
|
|
2009-05-24 23:54:21 +00:00
|
|
|
if (mdp->cd->set_rate)
|
|
|
|
mdp->cd->set_rate(ndev);
|
|
|
|
|
2008-06-30 02:08:17 +00:00
|
|
|
/* E-MAC Status Register clear */
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_write(ndev, mdp->cd->ecsr_value, ECSR);
|
2008-06-30 02:08:17 +00:00
|
|
|
|
|
|
|
/* E-MAC Interrupt Enable register */
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_write(ndev, mdp->cd->ecsipr_value, ECSIPR);
|
2008-06-09 23:33:56 +00:00
|
|
|
|
|
|
|
/* Set MAC address */
|
|
|
|
update_mac_address(ndev);
|
|
|
|
|
|
|
|
/* mask reset */
|
2009-05-24 23:54:21 +00:00
|
|
|
if (mdp->cd->apr)
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_write(ndev, APR_AP, APR);
|
2009-05-24 23:54:21 +00:00
|
|
|
if (mdp->cd->mpr)
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_write(ndev, MPR_MP, MPR);
|
2009-05-24 23:54:21 +00:00
|
|
|
if (mdp->cd->tpauser)
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_write(ndev, TPAUSER_UNLIMITED, TPAUSER);
|
2008-06-30 02:08:17 +00:00
|
|
|
|
2008-06-09 23:33:56 +00:00
|
|
|
/* Setting the Rx mode will start the Rx process. */
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_write(ndev, EDRRR_R, EDRRR);
|
2008-06-09 23:33:56 +00: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-06 23:49:00 +00:00
|
|
|
if (txdesc->status & cpu_to_edmac(mdp, TD_TACT))
|
2008-06-09 23:33:56 +00:00
|
|
|
break;
|
|
|
|
/* Free the original skb. */
|
|
|
|
if (mdp->tx_skbuff[entry]) {
|
2011-06-30 22:52:13 +00:00
|
|
|
dma_unmap_single(&ndev->dev, txdesc->addr,
|
|
|
|
txdesc->buffer_length, DMA_TO_DEVICE);
|
2008-06-09 23:33:56 +00:00
|
|
|
dev_kfree_skb_irq(mdp->tx_skbuff[entry]);
|
|
|
|
mdp->tx_skbuff[entry] = NULL;
|
|
|
|
freeNum++;
|
|
|
|
}
|
2008-08-06 23:49:00 +00:00
|
|
|
txdesc->status = cpu_to_edmac(mdp, TD_TFP);
|
2008-06-09 23:33:56 +00:00
|
|
|
if (entry >= TX_RING_SIZE - 1)
|
2008-08-06 23:49:00 +00:00
|
|
|
txdesc->status |= cpu_to_edmac(mdp, TD_TDLE);
|
2008-06-09 23:33:56 +00:00
|
|
|
|
2012-02-06 22:17:21 +00:00
|
|
|
ndev->stats.tx_packets++;
|
|
|
|
ndev->stats.tx_bytes += txdesc->buffer_length;
|
2008-06-09 23:33:56 +00:00
|
|
|
}
|
|
|
|
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-24 23:54:21 +00:00
|
|
|
u32 desc_status;
|
2008-06-09 23:33:56 +00:00
|
|
|
|
|
|
|
rxdesc = &mdp->rx_ring[entry];
|
2008-08-06 23:49:00 +00:00
|
|
|
while (!(rxdesc->status & cpu_to_edmac(mdp, RD_RACT))) {
|
|
|
|
desc_status = edmac_to_cpu(mdp, rxdesc->status);
|
2008-06-09 23:33:56 +00:00
|
|
|
pkt_len = rxdesc->frame_length;
|
|
|
|
|
|
|
|
if (--boguscnt < 0)
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (!(desc_status & RDFEND))
|
2012-02-06 22:17:21 +00:00
|
|
|
ndev->stats.rx_length_errors++;
|
2008-06-09 23:33:56 +00:00
|
|
|
|
|
|
|
if (desc_status & (RD_RFS1 | RD_RFS2 | RD_RFS3 | RD_RFS4 |
|
|
|
|
RD_RFS5 | RD_RFS6 | RD_RFS10)) {
|
2012-02-06 22:17:21 +00:00
|
|
|
ndev->stats.rx_errors++;
|
2008-06-09 23:33:56 +00:00
|
|
|
if (desc_status & RD_RFS1)
|
2012-02-06 22:17:21 +00:00
|
|
|
ndev->stats.rx_crc_errors++;
|
2008-06-09 23:33:56 +00:00
|
|
|
if (desc_status & RD_RFS2)
|
2012-02-06 22:17:21 +00:00
|
|
|
ndev->stats.rx_frame_errors++;
|
2008-06-09 23:33:56 +00:00
|
|
|
if (desc_status & RD_RFS3)
|
2012-02-06 22:17:21 +00:00
|
|
|
ndev->stats.rx_length_errors++;
|
2008-06-09 23:33:56 +00:00
|
|
|
if (desc_status & RD_RFS4)
|
2012-02-06 22:17:21 +00:00
|
|
|
ndev->stats.rx_length_errors++;
|
2008-06-09 23:33:56 +00:00
|
|
|
if (desc_status & RD_RFS6)
|
2012-02-06 22:17:21 +00:00
|
|
|
ndev->stats.rx_missed_errors++;
|
2008-06-09 23:33:56 +00:00
|
|
|
if (desc_status & RD_RFS10)
|
2012-02-06 22:17:21 +00:00
|
|
|
ndev->stats.rx_over_errors++;
|
2008-06-09 23:33:56 +00:00
|
|
|
} else {
|
2009-05-24 23:54:21 +00:00
|
|
|
if (!mdp->cd->hw_swap)
|
|
|
|
sh_eth_soft_swap(
|
|
|
|
phys_to_virt(ALIGN(rxdesc->addr, 4)),
|
|
|
|
pkt_len + 2);
|
2008-06-09 23:33:56 +00:00
|
|
|
skb = mdp->rx_skbuff[entry];
|
|
|
|
mdp->rx_skbuff[entry] = NULL;
|
2009-12-16 05:16:55 +00:00
|
|
|
if (mdp->cd->rpadir)
|
|
|
|
skb_reserve(skb, NET_IP_ALIGN);
|
2008-06-09 23:33:56 +00:00
|
|
|
skb_put(skb, pkt_len);
|
|
|
|
skb->protocol = eth_type_trans(skb, ndev);
|
|
|
|
netif_rx(skb);
|
2012-02-06 22:17:21 +00:00
|
|
|
ndev->stats.rx_packets++;
|
|
|
|
ndev->stats.rx_bytes += pkt_len;
|
2008-06-09 23:33:56 +00:00
|
|
|
}
|
2008-08-06 23:49:00 +00:00
|
|
|
rxdesc->status |= cpu_to_edmac(mdp, RD_RACT);
|
2008-06-09 23:33:56 +00:00
|
|
|
entry = (++mdp->cur_rx) % RX_RING_SIZE;
|
2009-05-24 23:53:40 +00:00
|
|
|
rxdesc = &mdp->rx_ring[entry];
|
2008-06-09 23:33:56 +00: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 02:08:17 +00:00
|
|
|
/* The size of the buffer is 16 byte boundary. */
|
2009-05-24 23:53:20 +00:00
|
|
|
rxdesc->buffer_length = ALIGN(mdp->rx_buf_sz, 16);
|
2008-06-30 02:08:17 +00:00
|
|
|
|
2008-06-09 23:33:56 +00:00
|
|
|
if (mdp->rx_skbuff[entry] == NULL) {
|
2012-02-06 11:16:13 +00:00
|
|
|
skb = netdev_alloc_skb(ndev, mdp->rx_buf_sz);
|
2008-06-09 23:33:56 +00:00
|
|
|
mdp->rx_skbuff[entry] = skb;
|
|
|
|
if (skb == NULL)
|
|
|
|
break; /* Better luck next round. */
|
2012-02-06 22:17:21 +00:00
|
|
|
dma_map_single(&ndev->dev, skb->data, mdp->rx_buf_sz,
|
2009-05-24 23:52:35 +00:00
|
|
|
DMA_FROM_DEVICE);
|
2009-05-24 23:54:21 +00:00
|
|
|
sh_eth_set_receive_align(skb);
|
|
|
|
|
2010-09-02 20:07:41 +00:00
|
|
|
skb_checksum_none_assert(skb);
|
2009-05-24 23:53:20 +00:00
|
|
|
rxdesc->addr = virt_to_phys(PTR_ALIGN(skb->data, 4));
|
2008-06-09 23:33:56 +00:00
|
|
|
}
|
|
|
|
if (entry >= RX_RING_SIZE - 1)
|
|
|
|
rxdesc->status |=
|
2008-08-06 23:49:00 +00:00
|
|
|
cpu_to_edmac(mdp, RD_RACT | RD_RFP | RD_RDEL);
|
2008-06-09 23:33:56 +00:00
|
|
|
else
|
|
|
|
rxdesc->status |=
|
2008-08-06 23:49:00 +00:00
|
|
|
cpu_to_edmac(mdp, RD_RACT | RD_RFP);
|
2008-06-09 23:33:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Restart Rx engine if stopped. */
|
|
|
|
/* If we don't need to check status, don't. -KDU */
|
2011-03-07 21:59:26 +00:00
|
|
|
if (!(sh_eth_read(ndev, EDRRR) & EDRRR_R))
|
|
|
|
sh_eth_write(ndev, EDRRR_R, EDRRR);
|
2008-06-09 23:33:56 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-03-07 21:59:26 +00:00
|
|
|
static void sh_eth_rcv_snd_disable(struct net_device *ndev)
|
2011-02-15 21:17:32 +00:00
|
|
|
{
|
|
|
|
/* disable tx and rx */
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_write(ndev, sh_eth_read(ndev, ECMR) &
|
|
|
|
~(ECMR_RE | ECMR_TE), ECMR);
|
2011-02-15 21:17:32 +00:00
|
|
|
}
|
|
|
|
|
2011-03-07 21:59:26 +00:00
|
|
|
static void sh_eth_rcv_snd_enable(struct net_device *ndev)
|
2011-02-15 21:17:32 +00:00
|
|
|
{
|
|
|
|
/* enable tx and rx */
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_write(ndev, sh_eth_read(ndev, ECMR) |
|
|
|
|
(ECMR_RE | ECMR_TE), ECMR);
|
2011-02-15 21:17:32 +00:00
|
|
|
}
|
|
|
|
|
2008-06-09 23:33:56 +00:00
|
|
|
/* error control function */
|
|
|
|
static void sh_eth_error(struct net_device *ndev, int intr_status)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
u32 felic_stat;
|
2009-05-24 23:54:21 +00:00
|
|
|
u32 link_stat;
|
|
|
|
u32 mask;
|
2008-06-09 23:33:56 +00:00
|
|
|
|
|
|
|
if (intr_status & EESR_ECI) {
|
2011-03-07 21:59:26 +00:00
|
|
|
felic_stat = sh_eth_read(ndev, ECSR);
|
|
|
|
sh_eth_write(ndev, felic_stat, ECSR); /* clear int */
|
2008-06-09 23:33:56 +00:00
|
|
|
if (felic_stat & ECSR_ICD)
|
2012-02-06 22:17:21 +00:00
|
|
|
ndev->stats.tx_carrier_errors++;
|
2008-06-09 23:33:56 +00:00
|
|
|
if (felic_stat & ECSR_LCHNG) {
|
|
|
|
/* Link Changed */
|
2009-08-27 23:25:03 +00:00
|
|
|
if (mdp->cd->no_psr || mdp->no_ether_link) {
|
2009-05-24 23:54:21 +00:00
|
|
|
if (mdp->link == PHY_DOWN)
|
|
|
|
link_stat = 0;
|
|
|
|
else
|
|
|
|
link_stat = PHY_ST_LINK;
|
|
|
|
} else {
|
2011-03-07 21:59:26 +00:00
|
|
|
link_stat = (sh_eth_read(ndev, PSR));
|
2009-08-27 23:25:03 +00:00
|
|
|
if (mdp->ether_link_active_low)
|
|
|
|
link_stat = ~link_stat;
|
2009-05-24 23:54:21 +00:00
|
|
|
}
|
2011-02-15 21:17:32 +00:00
|
|
|
if (!(link_stat & PHY_ST_LINK))
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_rcv_snd_disable(ndev);
|
2011-02-15 21:17:32 +00:00
|
|
|
else {
|
2008-06-09 23:33:56 +00:00
|
|
|
/* Link Up */
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_write(ndev, sh_eth_read(ndev, EESIPR) &
|
|
|
|
~DMAC_M_ECI, EESIPR);
|
2008-06-09 23:33:56 +00:00
|
|
|
/*clear int */
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_write(ndev, sh_eth_read(ndev, ECSR),
|
|
|
|
ECSR);
|
|
|
|
sh_eth_write(ndev, sh_eth_read(ndev, EESIPR) |
|
|
|
|
DMAC_M_ECI, EESIPR);
|
2008-06-09 23:33:56 +00:00
|
|
|
/* enable tx and rx */
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_rcv_snd_enable(ndev);
|
2008-06-09 23:33:56 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (intr_status & EESR_TWB) {
|
|
|
|
/* Write buck end. unused write back interrupt */
|
|
|
|
if (intr_status & EESR_TABT) /* Transmit Abort int */
|
2012-02-06 22:17:21 +00:00
|
|
|
ndev->stats.tx_aborted_errors++;
|
2011-02-15 21:17:32 +00:00
|
|
|
if (netif_msg_tx_err(mdp))
|
|
|
|
dev_err(&ndev->dev, "Transmit Abort\n");
|
2008-06-09 23:33:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (intr_status & EESR_RABT) {
|
|
|
|
/* Receive Abort int */
|
|
|
|
if (intr_status & EESR_RFRMER) {
|
|
|
|
/* Receive Frame Overflow int */
|
2012-02-06 22:17:21 +00:00
|
|
|
ndev->stats.rx_frame_errors++;
|
2011-02-15 21:17:32 +00:00
|
|
|
if (netif_msg_rx_err(mdp))
|
|
|
|
dev_err(&ndev->dev, "Receive Abort\n");
|
2008-06-09 23:33:56 +00:00
|
|
|
}
|
|
|
|
}
|
2009-05-24 23:54:21 +00:00
|
|
|
|
2011-02-15 21:17:32 +00:00
|
|
|
if (intr_status & EESR_TDE) {
|
|
|
|
/* Transmit Descriptor Empty int */
|
2012-02-06 22:17:21 +00:00
|
|
|
ndev->stats.tx_fifo_errors++;
|
2011-02-15 21:17:32 +00:00
|
|
|
if (netif_msg_tx_err(mdp))
|
|
|
|
dev_err(&ndev->dev, "Transmit Descriptor Empty\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (intr_status & EESR_TFE) {
|
|
|
|
/* FIFO under flow */
|
2012-02-06 22:17:21 +00:00
|
|
|
ndev->stats.tx_fifo_errors++;
|
2011-02-15 21:17:32 +00:00
|
|
|
if (netif_msg_tx_err(mdp))
|
|
|
|
dev_err(&ndev->dev, "Transmit FIFO Under flow\n");
|
2008-06-09 23:33:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (intr_status & EESR_RDE) {
|
|
|
|
/* Receive Descriptor Empty int */
|
2012-02-06 22:17:21 +00:00
|
|
|
ndev->stats.rx_over_errors++;
|
2008-06-09 23:33:56 +00:00
|
|
|
|
2011-03-07 21:59:26 +00:00
|
|
|
if (sh_eth_read(ndev, EDRRR) ^ EDRRR_R)
|
|
|
|
sh_eth_write(ndev, EDRRR_R, EDRRR);
|
2011-02-15 21:17:32 +00:00
|
|
|
if (netif_msg_rx_err(mdp))
|
|
|
|
dev_err(&ndev->dev, "Receive Descriptor Empty\n");
|
2008-06-09 23:33:56 +00:00
|
|
|
}
|
2011-02-15 21:17:32 +00:00
|
|
|
|
2008-06-09 23:33:56 +00:00
|
|
|
if (intr_status & EESR_RFE) {
|
|
|
|
/* Receive FIFO Overflow int */
|
2012-02-06 22:17:21 +00:00
|
|
|
ndev->stats.rx_fifo_errors++;
|
2011-02-15 21:17:32 +00:00
|
|
|
if (netif_msg_rx_err(mdp))
|
|
|
|
dev_err(&ndev->dev, "Receive FIFO Overflow\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!mdp->cd->no_ade && (intr_status & EESR_ADE)) {
|
|
|
|
/* Address Error */
|
2012-02-06 22:17:21 +00:00
|
|
|
ndev->stats.tx_fifo_errors++;
|
2011-02-15 21:17:32 +00:00
|
|
|
if (netif_msg_tx_err(mdp))
|
|
|
|
dev_err(&ndev->dev, "Address Error\n");
|
2008-06-09 23:33:56 +00:00
|
|
|
}
|
2009-05-24 23:54:21 +00: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-09 23:33:56 +00:00
|
|
|
/* Tx error */
|
2011-03-07 21:59:26 +00:00
|
|
|
u32 edtrr = sh_eth_read(ndev, EDTRR);
|
2008-06-09 23:33:56 +00:00
|
|
|
/* dmesg */
|
2009-05-24 23:54:21 +00: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-09 23:33:56 +00:00
|
|
|
mdp->dirty_tx, (u32) ndev->state, edtrr);
|
|
|
|
/* dirty buffer free */
|
|
|
|
sh_eth_txfree(ndev);
|
|
|
|
|
|
|
|
/* SH7712 BUG */
|
2011-03-07 21:59:38 +00:00
|
|
|
if (edtrr ^ sh_eth_get_edtrr_trns(mdp)) {
|
2008-06-09 23:33:56 +00:00
|
|
|
/* tx dma start */
|
2011-03-07 21:59:38 +00:00
|
|
|
sh_eth_write(ndev, sh_eth_get_edtrr_trns(mdp), EDTRR);
|
2008-06-09 23:33:56 +00: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-24 23:54:21 +00:00
|
|
|
struct sh_eth_cpu_data *cd = mdp->cd;
|
2009-03-16 19:50:57 +00:00
|
|
|
irqreturn_t ret = IRQ_NONE;
|
2011-03-07 21:59:26 +00:00
|
|
|
u32 intr_status = 0;
|
2008-06-09 23:33:56 +00:00
|
|
|
|
|
|
|
spin_lock(&mdp->lock);
|
|
|
|
|
2008-06-30 02:08:17 +00:00
|
|
|
/* Get interrpt stat */
|
2011-03-07 21:59:26 +00:00
|
|
|
intr_status = sh_eth_read(ndev, EESR);
|
2008-06-09 23:33:56 +00:00
|
|
|
/* Clear interrupt */
|
2009-03-16 19:50:57 +00:00
|
|
|
if (intr_status & (EESR_FRC | EESR_RMAF | EESR_RRF |
|
|
|
|
EESR_RTLF | EESR_RTSF | EESR_PRE | EESR_CERF |
|
2009-05-24 23:54:21 +00:00
|
|
|
cd->tx_check | cd->eesr_err_check)) {
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_write(ndev, intr_status, EESR);
|
2009-03-16 19:50:57 +00:00
|
|
|
ret = IRQ_HANDLED;
|
|
|
|
} else
|
|
|
|
goto other_irq;
|
2008-06-09 23:33:56 +00:00
|
|
|
|
2008-06-30 02:08:17 +00: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-09 23:33:56 +00:00
|
|
|
sh_eth_rx(ndev);
|
2008-06-30 02:08:17 +00:00
|
|
|
}
|
2008-06-09 23:33:56 +00:00
|
|
|
|
2008-06-30 02:08:17 +00:00
|
|
|
/* Tx Check */
|
2009-05-24 23:54:21 +00:00
|
|
|
if (intr_status & cd->tx_check) {
|
2008-06-09 23:33:56 +00:00
|
|
|
sh_eth_txfree(ndev);
|
|
|
|
netif_wake_queue(ndev);
|
|
|
|
}
|
|
|
|
|
2009-05-24 23:54:21 +00:00
|
|
|
if (intr_status & cd->eesr_err_check)
|
2008-06-09 23:33:56 +00:00
|
|
|
sh_eth_error(ndev, intr_status);
|
|
|
|
|
2009-03-16 19:50:57 +00:00
|
|
|
other_irq:
|
2008-06-09 23:33:56 +00:00
|
|
|
spin_unlock(&mdp->lock);
|
|
|
|
|
2009-03-16 19:50:57 +00:00
|
|
|
return ret;
|
2008-06-09 23:33:56 +00: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;
|
|
|
|
int new_state = 0;
|
|
|
|
|
|
|
|
if (phydev->link != PHY_DOWN) {
|
|
|
|
if (phydev->duplex != mdp->duplex) {
|
|
|
|
new_state = 1;
|
|
|
|
mdp->duplex = phydev->duplex;
|
2009-05-24 23:54:21 +00:00
|
|
|
if (mdp->cd->set_duplex)
|
|
|
|
mdp->cd->set_duplex(ndev);
|
2008-06-09 23:33:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (phydev->speed != mdp->speed) {
|
|
|
|
new_state = 1;
|
|
|
|
mdp->speed = phydev->speed;
|
2009-05-24 23:54:21 +00:00
|
|
|
if (mdp->cd->set_rate)
|
|
|
|
mdp->cd->set_rate(ndev);
|
2008-06-09 23:33:56 +00:00
|
|
|
}
|
|
|
|
if (mdp->link == PHY_DOWN) {
|
2011-07-05 20:33:51 +00:00
|
|
|
sh_eth_write(ndev,
|
|
|
|
(sh_eth_read(ndev, ECMR) & ~ECMR_TXF), ECMR);
|
2008-06-09 23:33:56 +00:00
|
|
|
new_state = 1;
|
|
|
|
mdp->link = phydev->link;
|
|
|
|
}
|
|
|
|
} else if (mdp->link) {
|
|
|
|
new_state = 1;
|
|
|
|
mdp->link = PHY_DOWN;
|
|
|
|
mdp->speed = 0;
|
|
|
|
mdp->duplex = -1;
|
|
|
|
}
|
|
|
|
|
2011-02-15 21:17:32 +00:00
|
|
|
if (new_state && netif_msg_link(mdp))
|
2008-06-09 23:33:56 +00:00
|
|
|
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 04:11:09 +00:00
|
|
|
char phy_id[MII_BUS_ID_SIZE + 3];
|
2008-06-09 23:33:56 +00:00
|
|
|
struct phy_device *phydev = NULL;
|
|
|
|
|
2008-11-10 21:55:14 +00:00
|
|
|
snprintf(phy_id, sizeof(phy_id), PHY_ID_FMT,
|
2008-06-09 23:33:56 +00:00
|
|
|
mdp->mii_bus->id , mdp->phy_id);
|
|
|
|
|
|
|
|
mdp->link = PHY_DOWN;
|
|
|
|
mdp->speed = 0;
|
|
|
|
mdp->duplex = -1;
|
|
|
|
|
|
|
|
/* Try connect to PHY */
|
2010-08-23 18:20:03 +00:00
|
|
|
phydev = phy_connect(ndev, phy_id, sh_eth_adjust_link,
|
2011-03-07 21:59:45 +00:00
|
|
|
0, mdp->phy_interface);
|
2008-06-09 23:33:56 +00:00
|
|
|
if (IS_ERR(phydev)) {
|
|
|
|
dev_err(&ndev->dev, "phy_connect failed\n");
|
|
|
|
return PTR_ERR(phydev);
|
|
|
|
}
|
2009-05-24 23:54:21 +00:00
|
|
|
|
2008-06-09 23:33:56 +00:00
|
|
|
dev_info(&ndev->dev, "attached phy %i to driver %s\n",
|
2009-05-24 23:54:21 +00:00
|
|
|
phydev->addr, phydev->drv->name);
|
2008-06-09 23:33:56 +00: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;
|
|
|
|
}
|
|
|
|
|
2011-02-15 21:17:32 +00:00
|
|
|
static int sh_eth_get_settings(struct net_device *ndev,
|
|
|
|
struct ethtool_cmd *ecmd)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
unsigned long flags;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&mdp->lock, flags);
|
|
|
|
ret = phy_ethtool_gset(mdp->phydev, ecmd);
|
|
|
|
spin_unlock_irqrestore(&mdp->lock, flags);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sh_eth_set_settings(struct net_device *ndev,
|
|
|
|
struct ethtool_cmd *ecmd)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
unsigned long flags;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&mdp->lock, flags);
|
|
|
|
|
|
|
|
/* disable tx and rx */
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_rcv_snd_disable(ndev);
|
2011-02-15 21:17:32 +00:00
|
|
|
|
|
|
|
ret = phy_ethtool_sset(mdp->phydev, ecmd);
|
|
|
|
if (ret)
|
|
|
|
goto error_exit;
|
|
|
|
|
|
|
|
if (ecmd->duplex == DUPLEX_FULL)
|
|
|
|
mdp->duplex = 1;
|
|
|
|
else
|
|
|
|
mdp->duplex = 0;
|
|
|
|
|
|
|
|
if (mdp->cd->set_duplex)
|
|
|
|
mdp->cd->set_duplex(ndev);
|
|
|
|
|
|
|
|
error_exit:
|
|
|
|
mdelay(1);
|
|
|
|
|
|
|
|
/* enable tx and rx */
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_rcv_snd_enable(ndev);
|
2011-02-15 21:17:32 +00:00
|
|
|
|
|
|
|
spin_unlock_irqrestore(&mdp->lock, flags);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sh_eth_nway_reset(struct net_device *ndev)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
unsigned long flags;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&mdp->lock, flags);
|
|
|
|
ret = phy_start_aneg(mdp->phydev);
|
|
|
|
spin_unlock_irqrestore(&mdp->lock, flags);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static u32 sh_eth_get_msglevel(struct net_device *ndev)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
return mdp->msg_enable;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void sh_eth_set_msglevel(struct net_device *ndev, u32 value)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
mdp->msg_enable = value;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const char sh_eth_gstrings_stats[][ETH_GSTRING_LEN] = {
|
|
|
|
"rx_current", "tx_current",
|
|
|
|
"rx_dirty", "tx_dirty",
|
|
|
|
};
|
|
|
|
#define SH_ETH_STATS_LEN ARRAY_SIZE(sh_eth_gstrings_stats)
|
|
|
|
|
|
|
|
static int sh_eth_get_sset_count(struct net_device *netdev, int sset)
|
|
|
|
{
|
|
|
|
switch (sset) {
|
|
|
|
case ETH_SS_STATS:
|
|
|
|
return SH_ETH_STATS_LEN;
|
|
|
|
default:
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void sh_eth_get_ethtool_stats(struct net_device *ndev,
|
|
|
|
struct ethtool_stats *stats, u64 *data)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
int i = 0;
|
|
|
|
|
|
|
|
/* device-specific stats */
|
|
|
|
data[i++] = mdp->cur_rx;
|
|
|
|
data[i++] = mdp->cur_tx;
|
|
|
|
data[i++] = mdp->dirty_rx;
|
|
|
|
data[i++] = mdp->dirty_tx;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void sh_eth_get_strings(struct net_device *ndev, u32 stringset, u8 *data)
|
|
|
|
{
|
|
|
|
switch (stringset) {
|
|
|
|
case ETH_SS_STATS:
|
|
|
|
memcpy(data, *sh_eth_gstrings_stats,
|
|
|
|
sizeof(sh_eth_gstrings_stats));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-01-04 12:59:49 +00:00
|
|
|
static const struct ethtool_ops sh_eth_ethtool_ops = {
|
2011-02-15 21:17:32 +00:00
|
|
|
.get_settings = sh_eth_get_settings,
|
|
|
|
.set_settings = sh_eth_set_settings,
|
2012-01-04 12:59:49 +00:00
|
|
|
.nway_reset = sh_eth_nway_reset,
|
2011-02-15 21:17:32 +00:00
|
|
|
.get_msglevel = sh_eth_get_msglevel,
|
|
|
|
.set_msglevel = sh_eth_set_msglevel,
|
2012-01-04 12:59:49 +00:00
|
|
|
.get_link = ethtool_op_get_link,
|
2011-02-15 21:17:32 +00:00
|
|
|
.get_strings = sh_eth_get_strings,
|
|
|
|
.get_ethtool_stats = sh_eth_get_ethtool_stats,
|
|
|
|
.get_sset_count = sh_eth_get_sset_count,
|
|
|
|
};
|
|
|
|
|
2008-06-09 23:33:56 +00:00
|
|
|
/* 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 00:20:04 +00:00
|
|
|
pm_runtime_get_sync(&mdp->pdev->dev);
|
|
|
|
|
2009-11-19 07:29:17 +00:00
|
|
|
ret = request_irq(ndev->irq, sh_eth_interrupt,
|
2010-07-05 18:32:50 +00:00
|
|
|
#if defined(CONFIG_CPU_SUBTYPE_SH7763) || \
|
2011-02-15 21:17:32 +00:00
|
|
|
defined(CONFIG_CPU_SUBTYPE_SH7764) || \
|
|
|
|
defined(CONFIG_CPU_SUBTYPE_SH7757)
|
2009-03-16 19:50:57 +00:00
|
|
|
IRQF_SHARED,
|
|
|
|
#else
|
|
|
|
0,
|
|
|
|
#endif
|
|
|
|
ndev->name, ndev);
|
2008-06-09 23:33:56 +00:00
|
|
|
if (ret) {
|
2009-05-24 23:54:21 +00:00
|
|
|
dev_err(&ndev->dev, "Can not assign IRQ number\n");
|
2008-06-09 23:33:56 +00: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 02:08:17 +00:00
|
|
|
setup_timer(&mdp->timer, sh_eth_timer, (unsigned long)ndev);
|
2008-06-09 23:33:56 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
out_free_irq:
|
|
|
|
free_irq(ndev->irq, ndev);
|
2009-10-09 00:20:04 +00:00
|
|
|
pm_runtime_put_sync(&mdp->pdev->dev);
|
2008-06-09 23:33:56 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Timeout function */
|
|
|
|
static void sh_eth_tx_timeout(struct net_device *ndev)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
struct sh_eth_rxdesc *rxdesc;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
netif_stop_queue(ndev);
|
|
|
|
|
2011-02-15 21:17:32 +00:00
|
|
|
if (netif_msg_timer(mdp))
|
|
|
|
dev_err(&ndev->dev, "%s: transmit timed out, status %8.8x,"
|
2011-03-07 21:59:26 +00:00
|
|
|
" resetting...\n", ndev->name, (int)sh_eth_read(ndev, EESR));
|
2008-06-09 23:33:56 +00:00
|
|
|
|
|
|
|
/* tx_errors count up */
|
2012-02-06 22:17:21 +00:00
|
|
|
ndev->stats.tx_errors++;
|
2008-06-09 23:33:56 +00:00
|
|
|
|
|
|
|
/* 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-17 20:29:58 +00:00
|
|
|
unsigned long flags;
|
2008-06-09 23:33:56 +00:00
|
|
|
|
|
|
|
spin_lock_irqsave(&mdp->lock, flags);
|
|
|
|
if ((mdp->cur_tx - mdp->dirty_tx) >= (TX_RING_SIZE - 4)) {
|
|
|
|
if (!sh_eth_txfree(ndev)) {
|
2011-02-15 21:17:32 +00:00
|
|
|
if (netif_msg_tx_queued(mdp))
|
|
|
|
dev_warn(&ndev->dev, "TxFD exhausted.\n");
|
2008-06-09 23:33:56 +00:00
|
|
|
netif_stop_queue(ndev);
|
|
|
|
spin_unlock_irqrestore(&mdp->lock, flags);
|
2009-06-12 06:22:29 +00:00
|
|
|
return NETDEV_TX_BUSY;
|
2008-06-09 23:33:56 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&mdp->lock, flags);
|
|
|
|
|
|
|
|
entry = mdp->cur_tx % TX_RING_SIZE;
|
|
|
|
mdp->tx_skbuff[entry] = skb;
|
|
|
|
txdesc = &mdp->tx_ring[entry];
|
|
|
|
/* soft swap. */
|
2009-05-24 23:54:21 +00:00
|
|
|
if (!mdp->cd->hw_swap)
|
|
|
|
sh_eth_soft_swap(phys_to_virt(ALIGN(txdesc->addr, 4)),
|
|
|
|
skb->len + 2);
|
2011-06-30 22:52:13 +00:00
|
|
|
txdesc->addr = dma_map_single(&ndev->dev, skb->data, skb->len,
|
|
|
|
DMA_TO_DEVICE);
|
2008-06-09 23:33:56 +00:00
|
|
|
if (skb->len < ETHERSMALL)
|
|
|
|
txdesc->buffer_length = ETHERSMALL;
|
|
|
|
else
|
|
|
|
txdesc->buffer_length = skb->len;
|
|
|
|
|
|
|
|
if (entry >= TX_RING_SIZE - 1)
|
2008-08-06 23:49:00 +00:00
|
|
|
txdesc->status |= cpu_to_edmac(mdp, TD_TACT | TD_TDLE);
|
2008-06-09 23:33:56 +00:00
|
|
|
else
|
2008-08-06 23:49:00 +00:00
|
|
|
txdesc->status |= cpu_to_edmac(mdp, TD_TACT);
|
2008-06-09 23:33:56 +00:00
|
|
|
|
|
|
|
mdp->cur_tx++;
|
|
|
|
|
2011-03-07 21:59:38 +00:00
|
|
|
if (!(sh_eth_read(ndev, EDTRR) & sh_eth_get_edtrr_trns(mdp)))
|
|
|
|
sh_eth_write(ndev, sh_eth_get_edtrr_trns(mdp), EDTRR);
|
2008-06-30 02:08:17 +00:00
|
|
|
|
2009-06-23 06:03:08 +00:00
|
|
|
return NETDEV_TX_OK;
|
2008-06-09 23:33:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* device close function */
|
|
|
|
static int sh_eth_close(struct net_device *ndev)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
int ringsize;
|
|
|
|
|
|
|
|
netif_stop_queue(ndev);
|
|
|
|
|
|
|
|
/* Disable interrupts by clearing the interrupt mask. */
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_write(ndev, 0x0000, EESIPR);
|
2008-06-09 23:33:56 +00:00
|
|
|
|
|
|
|
/* Stop the chip's Tx and Rx processes. */
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_write(ndev, 0, EDTRR);
|
|
|
|
sh_eth_write(ndev, 0, EDRRR);
|
2008-06-09 23:33:56 +00: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 00:20:04 +00:00
|
|
|
pm_runtime_put_sync(&mdp->pdev->dev);
|
|
|
|
|
2008-06-09 23:33:56 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct net_device_stats *sh_eth_get_stats(struct net_device *ndev)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
|
2009-10-09 00:20:04 +00:00
|
|
|
pm_runtime_get_sync(&mdp->pdev->dev);
|
|
|
|
|
2012-02-06 22:17:21 +00:00
|
|
|
ndev->stats.tx_dropped += sh_eth_read(ndev, TROCR);
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_write(ndev, 0, TROCR); /* (write clear) */
|
2012-02-06 22:17:21 +00:00
|
|
|
ndev->stats.collisions += sh_eth_read(ndev, CDCR);
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_write(ndev, 0, CDCR); /* (write clear) */
|
2012-02-06 22:17:21 +00:00
|
|
|
ndev->stats.tx_carrier_errors += sh_eth_read(ndev, LCCR);
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_write(ndev, 0, LCCR); /* (write clear) */
|
2011-03-07 21:59:38 +00:00
|
|
|
if (sh_eth_is_gether(mdp)) {
|
2012-02-06 22:17:21 +00:00
|
|
|
ndev->stats.tx_carrier_errors += sh_eth_read(ndev, CERCR);
|
2011-03-07 21:59:38 +00:00
|
|
|
sh_eth_write(ndev, 0, CERCR); /* (write clear) */
|
2012-02-06 22:17:21 +00:00
|
|
|
ndev->stats.tx_carrier_errors += sh_eth_read(ndev, CEECR);
|
2011-03-07 21:59:38 +00:00
|
|
|
sh_eth_write(ndev, 0, CEECR); /* (write clear) */
|
|
|
|
} else {
|
2012-02-06 22:17:21 +00:00
|
|
|
ndev->stats.tx_carrier_errors += sh_eth_read(ndev, CNDCR);
|
2011-03-07 21:59:38 +00:00
|
|
|
sh_eth_write(ndev, 0, CNDCR); /* (write clear) */
|
|
|
|
}
|
2009-10-09 00:20:04 +00:00
|
|
|
pm_runtime_put_sync(&mdp->pdev->dev);
|
|
|
|
|
2012-02-06 22:17:21 +00:00
|
|
|
return &ndev->stats;
|
2008-06-09 23:33:56 +00:00
|
|
|
}
|
|
|
|
|
2012-02-06 22:17:21 +00:00
|
|
|
/* ioctl to device function */
|
2008-06-09 23:33:56 +00:00
|
|
|
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 08:48:55 +00:00
|
|
|
return phy_mii_ioctl(phydev, rq, cmd);
|
2008-06-09 23:33:56 +00:00
|
|
|
}
|
|
|
|
|
2009-05-24 23:54:21 +00:00
|
|
|
#if defined(SH_ETH_HAS_TSU)
|
2012-02-15 17:55:03 +00:00
|
|
|
/* For TSU_POSTn. Please refer to the manual about this (strange) bitfields */
|
|
|
|
static void *sh_eth_tsu_get_post_reg_offset(struct sh_eth_private *mdp,
|
|
|
|
int entry)
|
|
|
|
{
|
|
|
|
return sh_eth_tsu_get_offset(mdp, TSU_POST1) + (entry / 8 * 4);
|
|
|
|
}
|
|
|
|
|
|
|
|
static u32 sh_eth_tsu_get_post_mask(int entry)
|
|
|
|
{
|
|
|
|
return 0x0f << (28 - ((entry % 8) * 4));
|
|
|
|
}
|
|
|
|
|
|
|
|
static u32 sh_eth_tsu_get_post_bit(struct sh_eth_private *mdp, int entry)
|
|
|
|
{
|
|
|
|
return (0x08 >> (mdp->port << 1)) << (28 - ((entry % 8) * 4));
|
|
|
|
}
|
|
|
|
|
|
|
|
static void sh_eth_tsu_enable_cam_entry_post(struct net_device *ndev,
|
|
|
|
int entry)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
u32 tmp;
|
|
|
|
void *reg_offset;
|
|
|
|
|
|
|
|
reg_offset = sh_eth_tsu_get_post_reg_offset(mdp, entry);
|
|
|
|
tmp = ioread32(reg_offset);
|
|
|
|
iowrite32(tmp | sh_eth_tsu_get_post_bit(mdp, entry), reg_offset);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool sh_eth_tsu_disable_cam_entry_post(struct net_device *ndev,
|
|
|
|
int entry)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
u32 post_mask, ref_mask, tmp;
|
|
|
|
void *reg_offset;
|
|
|
|
|
|
|
|
reg_offset = sh_eth_tsu_get_post_reg_offset(mdp, entry);
|
|
|
|
post_mask = sh_eth_tsu_get_post_mask(entry);
|
|
|
|
ref_mask = sh_eth_tsu_get_post_bit(mdp, entry) & ~post_mask;
|
|
|
|
|
|
|
|
tmp = ioread32(reg_offset);
|
|
|
|
iowrite32(tmp & ~post_mask, reg_offset);
|
|
|
|
|
|
|
|
/* If other port enables, the function returns "true" */
|
|
|
|
return tmp & ref_mask;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sh_eth_tsu_busy(struct net_device *ndev)
|
|
|
|
{
|
|
|
|
int timeout = SH_ETH_TSU_TIMEOUT_MS * 100;
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
|
|
|
|
while ((sh_eth_tsu_read(mdp, TSU_ADSBSY) & TSU_ADSBSY_0)) {
|
|
|
|
udelay(10);
|
|
|
|
timeout--;
|
|
|
|
if (timeout <= 0) {
|
|
|
|
dev_err(&ndev->dev, "%s: timeout\n", __func__);
|
|
|
|
return -ETIMEDOUT;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sh_eth_tsu_write_entry(struct net_device *ndev, void *reg,
|
|
|
|
const u8 *addr)
|
|
|
|
{
|
|
|
|
u32 val;
|
|
|
|
|
|
|
|
val = addr[0] << 24 | addr[1] << 16 | addr[2] << 8 | addr[3];
|
|
|
|
iowrite32(val, reg);
|
|
|
|
if (sh_eth_tsu_busy(ndev) < 0)
|
|
|
|
return -EBUSY;
|
|
|
|
|
|
|
|
val = addr[4] << 8 | addr[5];
|
|
|
|
iowrite32(val, reg + 4);
|
|
|
|
if (sh_eth_tsu_busy(ndev) < 0)
|
|
|
|
return -EBUSY;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void sh_eth_tsu_read_entry(void *reg, u8 *addr)
|
|
|
|
{
|
|
|
|
u32 val;
|
|
|
|
|
|
|
|
val = ioread32(reg);
|
|
|
|
addr[0] = (val >> 24) & 0xff;
|
|
|
|
addr[1] = (val >> 16) & 0xff;
|
|
|
|
addr[2] = (val >> 8) & 0xff;
|
|
|
|
addr[3] = val & 0xff;
|
|
|
|
val = ioread32(reg + 4);
|
|
|
|
addr[4] = (val >> 8) & 0xff;
|
|
|
|
addr[5] = val & 0xff;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int sh_eth_tsu_find_entry(struct net_device *ndev, const u8 *addr)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
void *reg_offset = sh_eth_tsu_get_offset(mdp, TSU_ADRH0);
|
|
|
|
int i;
|
|
|
|
u8 c_addr[ETH_ALEN];
|
|
|
|
|
|
|
|
for (i = 0; i < SH_ETH_TSU_CAM_ENTRIES; i++, reg_offset += 8) {
|
|
|
|
sh_eth_tsu_read_entry(reg_offset, c_addr);
|
|
|
|
if (memcmp(addr, c_addr, ETH_ALEN) == 0)
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sh_eth_tsu_find_empty(struct net_device *ndev)
|
|
|
|
{
|
|
|
|
u8 blank[ETH_ALEN];
|
|
|
|
int entry;
|
|
|
|
|
|
|
|
memset(blank, 0, sizeof(blank));
|
|
|
|
entry = sh_eth_tsu_find_entry(ndev, blank);
|
|
|
|
return (entry < 0) ? -ENOMEM : entry;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sh_eth_tsu_disable_cam_entry_table(struct net_device *ndev,
|
|
|
|
int entry)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
void *reg_offset = sh_eth_tsu_get_offset(mdp, TSU_ADRH0);
|
|
|
|
int ret;
|
|
|
|
u8 blank[ETH_ALEN];
|
|
|
|
|
|
|
|
sh_eth_tsu_write(mdp, sh_eth_tsu_read(mdp, TSU_TEN) &
|
|
|
|
~(1 << (31 - entry)), TSU_TEN);
|
|
|
|
|
|
|
|
memset(blank, 0, sizeof(blank));
|
|
|
|
ret = sh_eth_tsu_write_entry(ndev, reg_offset + entry * 8, blank);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sh_eth_tsu_add_entry(struct net_device *ndev, const u8 *addr)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
void *reg_offset = sh_eth_tsu_get_offset(mdp, TSU_ADRH0);
|
|
|
|
int i, ret;
|
|
|
|
|
|
|
|
if (!mdp->cd->tsu)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
i = sh_eth_tsu_find_entry(ndev, addr);
|
|
|
|
if (i < 0) {
|
|
|
|
/* No entry found, create one */
|
|
|
|
i = sh_eth_tsu_find_empty(ndev);
|
|
|
|
if (i < 0)
|
|
|
|
return -ENOMEM;
|
|
|
|
ret = sh_eth_tsu_write_entry(ndev, reg_offset + i * 8, addr);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
/* Enable the entry */
|
|
|
|
sh_eth_tsu_write(mdp, sh_eth_tsu_read(mdp, TSU_TEN) |
|
|
|
|
(1 << (31 - i)), TSU_TEN);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Entry found or created, enable POST */
|
|
|
|
sh_eth_tsu_enable_cam_entry_post(ndev, i);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sh_eth_tsu_del_entry(struct net_device *ndev, const u8 *addr)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
int i, ret;
|
|
|
|
|
|
|
|
if (!mdp->cd->tsu)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
i = sh_eth_tsu_find_entry(ndev, addr);
|
|
|
|
if (i) {
|
|
|
|
/* Entry found */
|
|
|
|
if (sh_eth_tsu_disable_cam_entry_post(ndev, i))
|
|
|
|
goto done;
|
|
|
|
|
|
|
|
/* Disable the entry if both ports was disabled */
|
|
|
|
ret = sh_eth_tsu_disable_cam_entry_table(ndev, i);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
done:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sh_eth_tsu_purge_all(struct net_device *ndev)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
int i, ret;
|
|
|
|
|
|
|
|
if (unlikely(!mdp->cd->tsu))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
for (i = 0; i < SH_ETH_TSU_CAM_ENTRIES; i++) {
|
|
|
|
if (sh_eth_tsu_disable_cam_entry_post(ndev, i))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* Disable the entry if both ports was disabled */
|
|
|
|
ret = sh_eth_tsu_disable_cam_entry_table(ndev, i);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void sh_eth_tsu_purge_mcast(struct net_device *ndev)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
u8 addr[ETH_ALEN];
|
|
|
|
void *reg_offset = sh_eth_tsu_get_offset(mdp, TSU_ADRH0);
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (unlikely(!mdp->cd->tsu))
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (i = 0; i < SH_ETH_TSU_CAM_ENTRIES; i++, reg_offset += 8) {
|
|
|
|
sh_eth_tsu_read_entry(reg_offset, addr);
|
|
|
|
if (is_multicast_ether_addr(addr))
|
|
|
|
sh_eth_tsu_del_entry(ndev, addr);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-06-09 23:33:56 +00:00
|
|
|
/* Multicast reception directions set */
|
|
|
|
static void sh_eth_set_multicast_list(struct net_device *ndev)
|
|
|
|
{
|
2012-02-15 17:55:03 +00:00
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
u32 ecmr_bits;
|
|
|
|
int mcast_all = 0;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&mdp->lock, flags);
|
|
|
|
/*
|
|
|
|
* Initial condition is MCT = 1, PRM = 0.
|
|
|
|
* Depending on ndev->flags, set PRM or clear MCT
|
|
|
|
*/
|
|
|
|
ecmr_bits = (sh_eth_read(ndev, ECMR) & ~ECMR_PRM) | ECMR_MCT;
|
|
|
|
|
|
|
|
if (!(ndev->flags & IFF_MULTICAST)) {
|
|
|
|
sh_eth_tsu_purge_mcast(ndev);
|
|
|
|
mcast_all = 1;
|
|
|
|
}
|
|
|
|
if (ndev->flags & IFF_ALLMULTI) {
|
|
|
|
sh_eth_tsu_purge_mcast(ndev);
|
|
|
|
ecmr_bits &= ~ECMR_MCT;
|
|
|
|
mcast_all = 1;
|
|
|
|
}
|
|
|
|
|
2008-06-09 23:33:56 +00:00
|
|
|
if (ndev->flags & IFF_PROMISC) {
|
2012-02-15 17:55:03 +00:00
|
|
|
sh_eth_tsu_purge_all(ndev);
|
|
|
|
ecmr_bits = (ecmr_bits & ~ECMR_MCT) | ECMR_PRM;
|
|
|
|
} else if (mdp->cd->tsu) {
|
|
|
|
struct netdev_hw_addr *ha;
|
|
|
|
netdev_for_each_mc_addr(ha, ndev) {
|
|
|
|
if (mcast_all && is_multicast_ether_addr(ha->addr))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (sh_eth_tsu_add_entry(ndev, ha->addr) < 0) {
|
|
|
|
if (!mcast_all) {
|
|
|
|
sh_eth_tsu_purge_mcast(ndev);
|
|
|
|
ecmr_bits &= ~ECMR_MCT;
|
|
|
|
mcast_all = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2008-06-09 23:33:56 +00:00
|
|
|
} else {
|
|
|
|
/* Normal, unicast/broadcast-only mode. */
|
2012-02-15 17:55:03 +00:00
|
|
|
ecmr_bits = (ecmr_bits & ~ECMR_PRM) | ECMR_MCT;
|
2008-06-09 23:33:56 +00:00
|
|
|
}
|
2012-02-15 17:55:03 +00:00
|
|
|
|
|
|
|
/* update the ethernet mode */
|
|
|
|
sh_eth_write(ndev, ecmr_bits, ECMR);
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&mdp->lock, flags);
|
2008-06-09 23:33:56 +00:00
|
|
|
}
|
2012-02-15 17:55:06 +00:00
|
|
|
|
|
|
|
static int sh_eth_get_vtag_index(struct sh_eth_private *mdp)
|
|
|
|
{
|
|
|
|
if (!mdp->port)
|
|
|
|
return TSU_VTAG0;
|
|
|
|
else
|
|
|
|
return TSU_VTAG1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sh_eth_vlan_rx_add_vid(struct net_device *ndev, u16 vid)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
int vtag_reg_index = sh_eth_get_vtag_index(mdp);
|
|
|
|
|
|
|
|
if (unlikely(!mdp->cd->tsu))
|
|
|
|
return -EPERM;
|
|
|
|
|
|
|
|
/* No filtering if vid = 0 */
|
|
|
|
if (!vid)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
mdp->vlan_num_ids++;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The controller has one VLAN tag HW filter. So, if the filter is
|
|
|
|
* already enabled, the driver disables it and the filte
|
|
|
|
*/
|
|
|
|
if (mdp->vlan_num_ids > 1) {
|
|
|
|
/* disable VLAN filter */
|
|
|
|
sh_eth_tsu_write(mdp, 0, vtag_reg_index);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
sh_eth_tsu_write(mdp, TSU_VTAG_ENABLE | (vid & TSU_VTAG_VID_MASK),
|
|
|
|
vtag_reg_index);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sh_eth_vlan_rx_kill_vid(struct net_device *ndev, u16 vid)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
int vtag_reg_index = sh_eth_get_vtag_index(mdp);
|
|
|
|
|
|
|
|
if (unlikely(!mdp->cd->tsu))
|
|
|
|
return -EPERM;
|
|
|
|
|
|
|
|
/* No filtering if vid = 0 */
|
|
|
|
if (!vid)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
mdp->vlan_num_ids--;
|
|
|
|
sh_eth_tsu_write(mdp, 0, vtag_reg_index);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2011-03-07 21:59:34 +00:00
|
|
|
#endif /* SH_ETH_HAS_TSU */
|
2008-06-09 23:33:56 +00:00
|
|
|
|
|
|
|
/* SuperH's TSU register init function */
|
2011-03-07 21:59:26 +00:00
|
|
|
static void sh_eth_tsu_init(struct sh_eth_private *mdp)
|
2008-06-09 23:33:56 +00:00
|
|
|
{
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_tsu_write(mdp, 0, TSU_FWEN0); /* Disable forward(0->1) */
|
|
|
|
sh_eth_tsu_write(mdp, 0, TSU_FWEN1); /* Disable forward(1->0) */
|
|
|
|
sh_eth_tsu_write(mdp, 0, TSU_FCM); /* forward fifo 3k-3k */
|
|
|
|
sh_eth_tsu_write(mdp, 0xc, TSU_BSYSL0);
|
|
|
|
sh_eth_tsu_write(mdp, 0xc, TSU_BSYSL1);
|
|
|
|
sh_eth_tsu_write(mdp, 0, TSU_PRISL0);
|
|
|
|
sh_eth_tsu_write(mdp, 0, TSU_PRISL1);
|
|
|
|
sh_eth_tsu_write(mdp, 0, TSU_FWSL0);
|
|
|
|
sh_eth_tsu_write(mdp, 0, TSU_FWSL1);
|
|
|
|
sh_eth_tsu_write(mdp, TSU_FWSLC_POSTENU | TSU_FWSLC_POSTENL, TSU_FWSLC);
|
2011-03-07 21:59:38 +00:00
|
|
|
if (sh_eth_is_gether(mdp)) {
|
|
|
|
sh_eth_tsu_write(mdp, 0, TSU_QTAG0); /* Disable QTAG(0->1) */
|
|
|
|
sh_eth_tsu_write(mdp, 0, TSU_QTAG1); /* Disable QTAG(1->0) */
|
|
|
|
} else {
|
|
|
|
sh_eth_tsu_write(mdp, 0, TSU_QTAGM0); /* Disable QTAG(0->1) */
|
|
|
|
sh_eth_tsu_write(mdp, 0, TSU_QTAGM1); /* Disable QTAG(1->0) */
|
|
|
|
}
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_tsu_write(mdp, 0, TSU_FWSR); /* all interrupt status clear */
|
|
|
|
sh_eth_tsu_write(mdp, 0, TSU_FWINMK); /* Disable all interrupt */
|
|
|
|
sh_eth_tsu_write(mdp, 0, TSU_TEN); /* Disable all CAM entry */
|
|
|
|
sh_eth_tsu_write(mdp, 0, TSU_POST1); /* Disable CAM entry [ 0- 7] */
|
|
|
|
sh_eth_tsu_write(mdp, 0, TSU_POST2); /* Disable CAM entry [ 8-15] */
|
|
|
|
sh_eth_tsu_write(mdp, 0, TSU_POST3); /* Disable CAM entry [16-23] */
|
|
|
|
sh_eth_tsu_write(mdp, 0, TSU_POST4); /* Disable CAM entry [24-31] */
|
2008-06-09 23:33:56 +00: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 04:00:59 +00:00
|
|
|
/* free interrupts memory */
|
|
|
|
kfree(bus->irq);
|
|
|
|
|
2008-06-09 23:33:56 +00:00
|
|
|
/* free bitbang info */
|
|
|
|
free_mdio_bitbang(bus);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* MDIO bus init function */
|
2011-03-07 21:59:55 +00:00
|
|
|
static int sh_mdio_init(struct net_device *ndev, int id,
|
|
|
|
struct sh_eth_plat_data *pd)
|
2008-06-09 23:33:56 +00:00
|
|
|
{
|
|
|
|
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 */
|
2011-09-27 21:48:58 +00:00
|
|
|
bitbang->addr = mdp->addr + mdp->reg_offset[PIR];
|
2011-03-07 21:59:55 +00:00
|
|
|
bitbang->set_gate = pd->set_mdio_gate;
|
2008-06-09 23:33:56 +00:00
|
|
|
bitbang->mdi_msk = 0x08;
|
|
|
|
bitbang->mdo_msk = 0x04;
|
|
|
|
bitbang->mmd_msk = 0x02;/* MMD */
|
|
|
|
bitbang->mdc_msk = 0x01;
|
|
|
|
bitbang->ctrl.ops = &bb_ops;
|
|
|
|
|
2010-08-03 17:44:52 +00:00
|
|
|
/* MII controller setting */
|
2008-06-09 23:33:56 +00: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 15:41:33 +00:00
|
|
|
mdp->mii_bus->parent = &ndev->dev;
|
2012-01-09 23:59:17 +00:00
|
|
|
snprintf(mdp->mii_bus->id, MII_BUS_ID_SIZE, "%s-%x",
|
2012-01-16 16:50:16 +00:00
|
|
|
mdp->pdev->name, id);
|
2008-06-09 23:33:56 +00: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-08 23:29:57 +00:00
|
|
|
free_mdio_bitbang(mdp->mii_bus);
|
2008-06-09 23:33:56 +00:00
|
|
|
|
|
|
|
out_free_bitbang:
|
|
|
|
kfree(bitbang);
|
|
|
|
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-03-07 21:59:26 +00:00
|
|
|
static const u16 *sh_eth_get_register_offset(int register_type)
|
|
|
|
{
|
|
|
|
const u16 *reg_offset = NULL;
|
|
|
|
|
|
|
|
switch (register_type) {
|
|
|
|
case SH_ETH_REG_GIGABIT:
|
|
|
|
reg_offset = sh_eth_offset_gigabit;
|
|
|
|
break;
|
|
|
|
case SH_ETH_REG_FAST_SH4:
|
|
|
|
reg_offset = sh_eth_offset_fast_sh4;
|
|
|
|
break;
|
|
|
|
case SH_ETH_REG_FAST_SH3_SH2:
|
|
|
|
reg_offset = sh_eth_offset_fast_sh3_sh2;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
printk(KERN_ERR "Unknown register type (%d)\n", register_type);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return reg_offset;
|
|
|
|
}
|
|
|
|
|
2009-04-11 07:40:49 +00: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-24 23:54:21 +00:00
|
|
|
#if defined(SH_ETH_HAS_TSU)
|
2011-08-16 06:29:01 +00:00
|
|
|
.ndo_set_rx_mode = sh_eth_set_multicast_list,
|
2012-02-15 17:55:06 +00:00
|
|
|
.ndo_vlan_rx_add_vid = sh_eth_vlan_rx_add_vid,
|
|
|
|
.ndo_vlan_rx_kill_vid = sh_eth_vlan_rx_kill_vid,
|
2009-05-24 23:54:21 +00:00
|
|
|
#endif
|
2009-04-11 07:40:49 +00: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-09 23:33:56 +00:00
|
|
|
static int sh_eth_drv_probe(struct platform_device *pdev)
|
|
|
|
{
|
2010-08-19 07:39:45 +00:00
|
|
|
int ret, devno = 0;
|
2008-06-09 23:33:56 +00:00
|
|
|
struct resource *res;
|
|
|
|
struct net_device *ndev = NULL;
|
2011-06-23 16:02:38 +00:00
|
|
|
struct sh_eth_private *mdp = NULL;
|
2008-08-06 23:49:00 +00:00
|
|
|
struct sh_eth_plat_data *pd;
|
2008-06-09 23:33:56 +00: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) {
|
|
|
|
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-10 17:22:44 +00:00
|
|
|
ret = platform_get_irq(pdev, 0);
|
|
|
|
if (ret < 0) {
|
2008-06-09 23:33:56 +00:00
|
|
|
ret = -ENODEV;
|
|
|
|
goto out_release;
|
|
|
|
}
|
2008-09-10 17:22:44 +00:00
|
|
|
ndev->irq = ret;
|
2008-06-09 23:33:56 +00: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);
|
2011-09-27 21:48:58 +00:00
|
|
|
mdp->addr = ioremap(res->start, resource_size(res));
|
|
|
|
if (mdp->addr == NULL) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
dev_err(&pdev->dev, "ioremap failed.\n");
|
|
|
|
goto out_release;
|
|
|
|
}
|
|
|
|
|
2008-06-09 23:33:56 +00:00
|
|
|
spin_lock_init(&mdp->lock);
|
2009-10-09 00:20:04 +00:00
|
|
|
mdp->pdev = pdev;
|
|
|
|
pm_runtime_enable(&pdev->dev);
|
|
|
|
pm_runtime_resume(&pdev->dev);
|
2008-06-09 23:33:56 +00:00
|
|
|
|
2008-08-06 23:49:00 +00:00
|
|
|
pd = (struct sh_eth_plat_data *)(pdev->dev.platform_data);
|
2008-06-09 23:33:56 +00:00
|
|
|
/* get PHY ID */
|
2008-08-06 23:49:00 +00:00
|
|
|
mdp->phy_id = pd->phy;
|
2011-03-07 21:59:45 +00:00
|
|
|
mdp->phy_interface = pd->phy_interface;
|
2008-08-06 23:49:00 +00:00
|
|
|
/* EDMAC endian */
|
|
|
|
mdp->edmac_endian = pd->edmac_endian;
|
2009-08-27 23:25:03 +00:00
|
|
|
mdp->no_ether_link = pd->no_ether_link;
|
|
|
|
mdp->ether_link_active_low = pd->ether_link_active_low;
|
2011-03-07 21:59:26 +00:00
|
|
|
mdp->reg_offset = sh_eth_get_register_offset(pd->register_type);
|
2008-06-09 23:33:56 +00:00
|
|
|
|
2009-05-24 23:54:21 +00:00
|
|
|
/* set cpu data */
|
2011-03-07 21:59:49 +00:00
|
|
|
#if defined(SH_ETH_HAS_BOTH_MODULES)
|
|
|
|
mdp->cd = sh_eth_get_cpu_data(mdp);
|
|
|
|
#else
|
2009-05-24 23:54:21 +00:00
|
|
|
mdp->cd = &sh_eth_my_cpu_data;
|
2011-03-07 21:59:49 +00:00
|
|
|
#endif
|
2009-05-24 23:54:21 +00:00
|
|
|
sh_eth_set_default_cpu_data(mdp->cd);
|
|
|
|
|
2008-06-09 23:33:56 +00:00
|
|
|
/* set function */
|
2009-04-11 07:40:49 +00:00
|
|
|
ndev->netdev_ops = &sh_eth_netdev_ops;
|
2011-02-15 21:17:32 +00:00
|
|
|
SET_ETHTOOL_OPS(ndev, &sh_eth_ethtool_ops);
|
2008-06-09 23:33:56 +00:00
|
|
|
ndev->watchdog_timeo = TX_TIMEOUT;
|
|
|
|
|
2011-02-15 21:17:32 +00:00
|
|
|
/* debug message level */
|
|
|
|
mdp->msg_enable = SH_ETH_DEF_MSG_ENABLE;
|
2008-06-09 23:33:56 +00:00
|
|
|
mdp->post_rx = POST_RX >> (devno << 1);
|
|
|
|
mdp->post_fw = POST_FW >> (devno << 1);
|
|
|
|
|
|
|
|
/* read and set MAC address */
|
2009-10-09 00:17:14 +00:00
|
|
|
read_mac_address(ndev, pd->mac_addr);
|
2008-06-09 23:33:56 +00:00
|
|
|
|
2012-02-15 17:55:01 +00:00
|
|
|
/* ioremap the TSU registers */
|
|
|
|
if (mdp->cd->tsu) {
|
|
|
|
struct resource *rtsu;
|
|
|
|
rtsu = platform_get_resource(pdev, IORESOURCE_MEM, 1);
|
|
|
|
if (!rtsu) {
|
|
|
|
dev_err(&pdev->dev, "Not found TSU resource\n");
|
|
|
|
goto out_release;
|
|
|
|
}
|
|
|
|
mdp->tsu_addr = ioremap(rtsu->start,
|
|
|
|
resource_size(rtsu));
|
2012-02-15 17:55:03 +00:00
|
|
|
mdp->port = devno % 2;
|
2012-02-15 17:55:06 +00:00
|
|
|
ndev->features = NETIF_F_HW_VLAN_FILTER;
|
2012-02-15 17:55:01 +00:00
|
|
|
}
|
|
|
|
|
2012-02-15 17:54:56 +00:00
|
|
|
/* initialize first or needed device */
|
|
|
|
if (!devno || pd->needs_init) {
|
2009-05-24 23:54:21 +00:00
|
|
|
if (mdp->cd->chip_reset)
|
|
|
|
mdp->cd->chip_reset(ndev);
|
2008-06-09 23:33:56 +00:00
|
|
|
|
2011-03-07 21:59:34 +00:00
|
|
|
if (mdp->cd->tsu) {
|
|
|
|
/* TSU init (Init only)*/
|
|
|
|
sh_eth_tsu_init(mdp);
|
|
|
|
}
|
2008-06-09 23:33:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* network device register */
|
|
|
|
ret = register_netdev(ndev);
|
|
|
|
if (ret)
|
|
|
|
goto out_release;
|
|
|
|
|
|
|
|
/* mdio bus init */
|
2011-03-07 21:59:55 +00:00
|
|
|
ret = sh_mdio_init(ndev, pdev->id, pd);
|
2008-06-09 23:33:56 +00:00
|
|
|
if (ret)
|
|
|
|
goto out_unregister;
|
|
|
|
|
2011-03-31 01:57:33 +00:00
|
|
|
/* print device information */
|
2009-12-30 04:10:35 +00:00
|
|
|
pr_info("Base address at 0x%x, %pM, IRQ %d.\n",
|
|
|
|
(u32)ndev->base_addr, ndev->dev_addr, ndev->irq);
|
2008-06-09 23:33:56 +00:00
|
|
|
|
|
|
|
platform_set_drvdata(pdev, ndev);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
out_unregister:
|
|
|
|
unregister_netdev(ndev);
|
|
|
|
|
|
|
|
out_release:
|
|
|
|
/* net_dev free */
|
2011-09-27 21:48:58 +00:00
|
|
|
if (mdp && mdp->addr)
|
|
|
|
iounmap(mdp->addr);
|
2011-06-23 16:02:38 +00:00
|
|
|
if (mdp && mdp->tsu_addr)
|
2011-03-07 21:59:34 +00:00
|
|
|
iounmap(mdp->tsu_addr);
|
2008-06-09 23:33:56 +00:00
|
|
|
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);
|
2011-03-07 21:59:34 +00:00
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
2008-06-09 23:33:56 +00:00
|
|
|
|
2012-02-15 17:55:01 +00:00
|
|
|
if (mdp->cd->tsu)
|
|
|
|
iounmap(mdp->tsu_addr);
|
2008-06-09 23:33:56 +00:00
|
|
|
sh_mdio_release(ndev);
|
|
|
|
unregister_netdev(ndev);
|
2009-10-09 00:20:04 +00:00
|
|
|
pm_runtime_disable(&pdev->dev);
|
2011-09-27 21:48:58 +00:00
|
|
|
iounmap(mdp->addr);
|
2008-06-09 23:33:56 +00:00
|
|
|
free_netdev(ndev);
|
|
|
|
platform_set_drvdata(pdev, NULL);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-10-09 00:20:04 +00: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-09 23:33:56 +00:00
|
|
|
static struct platform_driver sh_eth_driver = {
|
|
|
|
.probe = sh_eth_drv_probe,
|
|
|
|
.remove = sh_eth_drv_remove,
|
|
|
|
.driver = {
|
|
|
|
.name = CARDNAME,
|
2009-10-09 00:20:04 +00:00
|
|
|
.pm = &sh_eth_dev_pm_ops,
|
2008-06-09 23:33:56 +00:00
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2011-11-27 16:44:17 +00:00
|
|
|
module_platform_driver(sh_eth_driver);
|
2008-06-09 23:33:56 +00:00
|
|
|
|
|
|
|
MODULE_AUTHOR("Nobuhiro Iwamatsu, Yoshihiro Shimoda");
|
|
|
|
MODULE_DESCRIPTION("Renesas SuperH Ethernet driver");
|
|
|
|
MODULE_LICENSE("GPL v2");
|