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
|
2013-03-28 11:51:31 +00:00
|
|
|
* Copyright (C) 2008-2013 Renesas Solutions Corp.
|
|
|
|
* Copyright (C) 2013 Cogent Embedded, Inc.
|
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)
|
|
|
|
|
2013-03-28 11:48:26 +00:00
|
|
|
static const u16 sh_eth_offset_gigabit[SH_ETH_MAX_REGISTER_OFFSET] = {
|
|
|
|
[EDSR] = 0x0000,
|
|
|
|
[EDMR] = 0x0400,
|
|
|
|
[EDTRR] = 0x0408,
|
|
|
|
[EDRRR] = 0x0410,
|
|
|
|
[EESR] = 0x0428,
|
|
|
|
[EESIPR] = 0x0430,
|
|
|
|
[TDLAR] = 0x0010,
|
|
|
|
[TDFAR] = 0x0014,
|
|
|
|
[TDFXR] = 0x0018,
|
|
|
|
[TDFFR] = 0x001c,
|
|
|
|
[RDLAR] = 0x0030,
|
|
|
|
[RDFAR] = 0x0034,
|
|
|
|
[RDFXR] = 0x0038,
|
|
|
|
[RDFFR] = 0x003c,
|
|
|
|
[TRSCER] = 0x0438,
|
|
|
|
[RMFCR] = 0x0440,
|
|
|
|
[TFTR] = 0x0448,
|
|
|
|
[FDR] = 0x0450,
|
|
|
|
[RMCR] = 0x0458,
|
|
|
|
[RPADIR] = 0x0460,
|
|
|
|
[FCFTR] = 0x0468,
|
|
|
|
[CSMR] = 0x04E4,
|
|
|
|
|
|
|
|
[ECMR] = 0x0500,
|
|
|
|
[ECSR] = 0x0510,
|
|
|
|
[ECSIPR] = 0x0518,
|
|
|
|
[PIR] = 0x0520,
|
|
|
|
[PSR] = 0x0528,
|
|
|
|
[PIPR] = 0x052c,
|
|
|
|
[RFLR] = 0x0508,
|
|
|
|
[APR] = 0x0554,
|
|
|
|
[MPR] = 0x0558,
|
|
|
|
[PFTCR] = 0x055c,
|
|
|
|
[PFRCR] = 0x0560,
|
|
|
|
[TPAUSER] = 0x0564,
|
|
|
|
[GECMR] = 0x05b0,
|
|
|
|
[BCULR] = 0x05b4,
|
|
|
|
[MAHR] = 0x05c0,
|
|
|
|
[MALR] = 0x05c8,
|
|
|
|
[TROCR] = 0x0700,
|
|
|
|
[CDCR] = 0x0708,
|
|
|
|
[LCCR] = 0x0710,
|
|
|
|
[CEFCR] = 0x0740,
|
|
|
|
[FRECR] = 0x0748,
|
|
|
|
[TSFRCR] = 0x0750,
|
|
|
|
[TLFRCR] = 0x0758,
|
|
|
|
[RFCR] = 0x0760,
|
|
|
|
[CERCR] = 0x0768,
|
|
|
|
[CEECR] = 0x0770,
|
|
|
|
[MAFCR] = 0x0778,
|
|
|
|
[RMII_MII] = 0x0790,
|
|
|
|
|
|
|
|
[ARSTR] = 0x0000,
|
|
|
|
[TSU_CTRST] = 0x0004,
|
|
|
|
[TSU_FWEN0] = 0x0010,
|
|
|
|
[TSU_FWEN1] = 0x0014,
|
|
|
|
[TSU_FCM] = 0x0018,
|
|
|
|
[TSU_BSYSL0] = 0x0020,
|
|
|
|
[TSU_BSYSL1] = 0x0024,
|
|
|
|
[TSU_PRISL0] = 0x0028,
|
|
|
|
[TSU_PRISL1] = 0x002c,
|
|
|
|
[TSU_FWSL0] = 0x0030,
|
|
|
|
[TSU_FWSL1] = 0x0034,
|
|
|
|
[TSU_FWSLC] = 0x0038,
|
|
|
|
[TSU_QTAG0] = 0x0040,
|
|
|
|
[TSU_QTAG1] = 0x0044,
|
|
|
|
[TSU_FWSR] = 0x0050,
|
|
|
|
[TSU_FWINMK] = 0x0054,
|
|
|
|
[TSU_ADQT0] = 0x0048,
|
|
|
|
[TSU_ADQT1] = 0x004c,
|
|
|
|
[TSU_VTAG0] = 0x0058,
|
|
|
|
[TSU_VTAG1] = 0x005c,
|
|
|
|
[TSU_ADSBSY] = 0x0060,
|
|
|
|
[TSU_TEN] = 0x0064,
|
|
|
|
[TSU_POST1] = 0x0070,
|
|
|
|
[TSU_POST2] = 0x0074,
|
|
|
|
[TSU_POST3] = 0x0078,
|
|
|
|
[TSU_POST4] = 0x007c,
|
|
|
|
[TSU_ADRH0] = 0x0100,
|
|
|
|
[TSU_ADRL0] = 0x0104,
|
|
|
|
[TSU_ADRH31] = 0x01f8,
|
|
|
|
[TSU_ADRL31] = 0x01fc,
|
|
|
|
|
|
|
|
[TXNLCR0] = 0x0080,
|
|
|
|
[TXALCR0] = 0x0084,
|
|
|
|
[RXNLCR0] = 0x0088,
|
|
|
|
[RXALCR0] = 0x008c,
|
|
|
|
[FWNLCR0] = 0x0090,
|
|
|
|
[FWALCR0] = 0x0094,
|
|
|
|
[TXNLCR1] = 0x00a0,
|
|
|
|
[TXALCR1] = 0x00a0,
|
|
|
|
[RXNLCR1] = 0x00a8,
|
|
|
|
[RXALCR1] = 0x00ac,
|
|
|
|
[FWNLCR1] = 0x00b0,
|
|
|
|
[FWALCR1] = 0x00b4,
|
|
|
|
};
|
|
|
|
|
2013-03-28 11:51:31 +00:00
|
|
|
static const u16 sh_eth_offset_fast_rcar[SH_ETH_MAX_REGISTER_OFFSET] = {
|
|
|
|
[ECMR] = 0x0300,
|
|
|
|
[RFLR] = 0x0308,
|
|
|
|
[ECSR] = 0x0310,
|
|
|
|
[ECSIPR] = 0x0318,
|
|
|
|
[PIR] = 0x0320,
|
|
|
|
[PSR] = 0x0328,
|
|
|
|
[RDMLR] = 0x0340,
|
|
|
|
[IPGR] = 0x0350,
|
|
|
|
[APR] = 0x0354,
|
|
|
|
[MPR] = 0x0358,
|
|
|
|
[RFCF] = 0x0360,
|
|
|
|
[TPAUSER] = 0x0364,
|
|
|
|
[TPAUSECR] = 0x0368,
|
|
|
|
[MAHR] = 0x03c0,
|
|
|
|
[MALR] = 0x03c8,
|
|
|
|
[TROCR] = 0x03d0,
|
|
|
|
[CDCR] = 0x03d4,
|
|
|
|
[LCCR] = 0x03d8,
|
|
|
|
[CNDCR] = 0x03dc,
|
|
|
|
[CEFCR] = 0x03e4,
|
|
|
|
[FRECR] = 0x03e8,
|
|
|
|
[TSFRCR] = 0x03ec,
|
|
|
|
[TLFRCR] = 0x03f0,
|
|
|
|
[RFCR] = 0x03f4,
|
|
|
|
[MAFCR] = 0x03f8,
|
|
|
|
|
|
|
|
[EDMR] = 0x0200,
|
|
|
|
[EDTRR] = 0x0208,
|
|
|
|
[EDRRR] = 0x0210,
|
|
|
|
[TDLAR] = 0x0218,
|
|
|
|
[RDLAR] = 0x0220,
|
|
|
|
[EESR] = 0x0228,
|
|
|
|
[EESIPR] = 0x0230,
|
|
|
|
[TRSCER] = 0x0238,
|
|
|
|
[RMFCR] = 0x0240,
|
|
|
|
[TFTR] = 0x0248,
|
|
|
|
[FDR] = 0x0250,
|
|
|
|
[RMCR] = 0x0258,
|
|
|
|
[TFUCR] = 0x0264,
|
|
|
|
[RFOCR] = 0x0268,
|
2013-07-23 01:18:04 +00:00
|
|
|
[RMIIMODE] = 0x026c,
|
2013-03-28 11:51:31 +00:00
|
|
|
[FCFTR] = 0x0270,
|
|
|
|
[TRIMD] = 0x027c,
|
|
|
|
};
|
|
|
|
|
2013-03-28 11:48:26 +00:00
|
|
|
static const u16 sh_eth_offset_fast_sh4[SH_ETH_MAX_REGISTER_OFFSET] = {
|
|
|
|
[ECMR] = 0x0100,
|
|
|
|
[RFLR] = 0x0108,
|
|
|
|
[ECSR] = 0x0110,
|
|
|
|
[ECSIPR] = 0x0118,
|
|
|
|
[PIR] = 0x0120,
|
|
|
|
[PSR] = 0x0128,
|
|
|
|
[RDMLR] = 0x0140,
|
|
|
|
[IPGR] = 0x0150,
|
|
|
|
[APR] = 0x0154,
|
|
|
|
[MPR] = 0x0158,
|
|
|
|
[TPAUSER] = 0x0164,
|
|
|
|
[RFCF] = 0x0160,
|
|
|
|
[TPAUSECR] = 0x0168,
|
|
|
|
[BCFRR] = 0x016c,
|
|
|
|
[MAHR] = 0x01c0,
|
|
|
|
[MALR] = 0x01c8,
|
|
|
|
[TROCR] = 0x01d0,
|
|
|
|
[CDCR] = 0x01d4,
|
|
|
|
[LCCR] = 0x01d8,
|
|
|
|
[CNDCR] = 0x01dc,
|
|
|
|
[CEFCR] = 0x01e4,
|
|
|
|
[FRECR] = 0x01e8,
|
|
|
|
[TSFRCR] = 0x01ec,
|
|
|
|
[TLFRCR] = 0x01f0,
|
|
|
|
[RFCR] = 0x01f4,
|
|
|
|
[MAFCR] = 0x01f8,
|
|
|
|
[RTRATE] = 0x01fc,
|
|
|
|
|
|
|
|
[EDMR] = 0x0000,
|
|
|
|
[EDTRR] = 0x0008,
|
|
|
|
[EDRRR] = 0x0010,
|
|
|
|
[TDLAR] = 0x0018,
|
|
|
|
[RDLAR] = 0x0020,
|
|
|
|
[EESR] = 0x0028,
|
|
|
|
[EESIPR] = 0x0030,
|
|
|
|
[TRSCER] = 0x0038,
|
|
|
|
[RMFCR] = 0x0040,
|
|
|
|
[TFTR] = 0x0048,
|
|
|
|
[FDR] = 0x0050,
|
|
|
|
[RMCR] = 0x0058,
|
|
|
|
[TFUCR] = 0x0064,
|
|
|
|
[RFOCR] = 0x0068,
|
|
|
|
[FCFTR] = 0x0070,
|
|
|
|
[RPADIR] = 0x0078,
|
|
|
|
[TRIMD] = 0x007c,
|
|
|
|
[RBWAR] = 0x00c8,
|
|
|
|
[RDFAR] = 0x00cc,
|
|
|
|
[TBRAR] = 0x00d4,
|
|
|
|
[TDFAR] = 0x00d8,
|
|
|
|
};
|
|
|
|
|
|
|
|
static const u16 sh_eth_offset_fast_sh3_sh2[SH_ETH_MAX_REGISTER_OFFSET] = {
|
|
|
|
[ECMR] = 0x0160,
|
|
|
|
[ECSR] = 0x0164,
|
|
|
|
[ECSIPR] = 0x0168,
|
|
|
|
[PIR] = 0x016c,
|
|
|
|
[MAHR] = 0x0170,
|
|
|
|
[MALR] = 0x0174,
|
|
|
|
[RFLR] = 0x0178,
|
|
|
|
[PSR] = 0x017c,
|
|
|
|
[TROCR] = 0x0180,
|
|
|
|
[CDCR] = 0x0184,
|
|
|
|
[LCCR] = 0x0188,
|
|
|
|
[CNDCR] = 0x018c,
|
|
|
|
[CEFCR] = 0x0194,
|
|
|
|
[FRECR] = 0x0198,
|
|
|
|
[TSFRCR] = 0x019c,
|
|
|
|
[TLFRCR] = 0x01a0,
|
|
|
|
[RFCR] = 0x01a4,
|
|
|
|
[MAFCR] = 0x01a8,
|
|
|
|
[IPGR] = 0x01b4,
|
|
|
|
[APR] = 0x01b8,
|
|
|
|
[MPR] = 0x01bc,
|
|
|
|
[TPAUSER] = 0x01c4,
|
|
|
|
[BCFR] = 0x01cc,
|
|
|
|
|
|
|
|
[ARSTR] = 0x0000,
|
|
|
|
[TSU_CTRST] = 0x0004,
|
|
|
|
[TSU_FWEN0] = 0x0010,
|
|
|
|
[TSU_FWEN1] = 0x0014,
|
|
|
|
[TSU_FCM] = 0x0018,
|
|
|
|
[TSU_BSYSL0] = 0x0020,
|
|
|
|
[TSU_BSYSL1] = 0x0024,
|
|
|
|
[TSU_PRISL0] = 0x0028,
|
|
|
|
[TSU_PRISL1] = 0x002c,
|
|
|
|
[TSU_FWSL0] = 0x0030,
|
|
|
|
[TSU_FWSL1] = 0x0034,
|
|
|
|
[TSU_FWSLC] = 0x0038,
|
|
|
|
[TSU_QTAGM0] = 0x0040,
|
|
|
|
[TSU_QTAGM1] = 0x0044,
|
|
|
|
[TSU_ADQT0] = 0x0048,
|
|
|
|
[TSU_ADQT1] = 0x004c,
|
|
|
|
[TSU_FWSR] = 0x0050,
|
|
|
|
[TSU_FWINMK] = 0x0054,
|
|
|
|
[TSU_ADSBSY] = 0x0060,
|
|
|
|
[TSU_TEN] = 0x0064,
|
|
|
|
[TSU_POST1] = 0x0070,
|
|
|
|
[TSU_POST2] = 0x0074,
|
|
|
|
[TSU_POST3] = 0x0078,
|
|
|
|
[TSU_POST4] = 0x007c,
|
|
|
|
|
|
|
|
[TXNLCR0] = 0x0080,
|
|
|
|
[TXALCR0] = 0x0084,
|
|
|
|
[RXNLCR0] = 0x0088,
|
|
|
|
[RXALCR0] = 0x008c,
|
|
|
|
[FWNLCR0] = 0x0090,
|
|
|
|
[FWALCR0] = 0x0094,
|
|
|
|
[TXNLCR1] = 0x00a0,
|
|
|
|
[TXALCR1] = 0x00a0,
|
|
|
|
[RXNLCR1] = 0x00a8,
|
|
|
|
[RXALCR1] = 0x00ac,
|
|
|
|
[FWNLCR1] = 0x00b0,
|
|
|
|
[FWALCR1] = 0x00b4,
|
|
|
|
|
|
|
|
[TSU_ADRH0] = 0x0100,
|
|
|
|
[TSU_ADRL0] = 0x0104,
|
|
|
|
[TSU_ADRL31] = 0x01fc,
|
|
|
|
};
|
|
|
|
|
2013-06-06 09:51:39 +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;
|
|
|
|
}
|
|
|
|
|
2013-06-11 23:07:29 +00:00
|
|
|
static void sh_eth_select_mii(struct net_device *ndev)
|
2012-06-25 17:34:14 +00:00
|
|
|
{
|
|
|
|
u32 value = 0x0;
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
|
|
|
|
switch (mdp->phy_interface) {
|
|
|
|
case PHY_INTERFACE_MODE_GMII:
|
|
|
|
value = 0x2;
|
|
|
|
break;
|
|
|
|
case PHY_INTERFACE_MODE_MII:
|
|
|
|
value = 0x1;
|
|
|
|
break;
|
|
|
|
case PHY_INTERFACE_MODE_RMII:
|
|
|
|
value = 0x0;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
pr_warn("PHY interface mode was not setup. Set to MII.\n");
|
|
|
|
value = 0x1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
sh_eth_write(ndev, value, RMII_MII);
|
|
|
|
}
|
|
|
|
|
2013-06-11 23:07:29 +00:00
|
|
|
static void sh_eth_set_duplex(struct net_device *ndev)
|
2009-05-24 23:54:30 +00:00
|
|
|
{
|
|
|
|
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
|
|
|
}
|
|
|
|
|
2013-06-06 09:45:25 +00:00
|
|
|
/* There is CPU dependent code */
|
2013-06-07 14:05:59 +00:00
|
|
|
static void sh_eth_set_rate_r8a777x(struct net_device *ndev)
|
2009-05-24 23:54:30 +00:00
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
2012-08-14 20:33:29 +00:00
|
|
|
|
2013-03-28 11:51:31 +00:00
|
|
|
switch (mdp->speed) {
|
|
|
|
case 10: /* 10BASE */
|
|
|
|
sh_eth_write(ndev, sh_eth_read(ndev, ECMR) & ~ECMR_ELB, ECMR);
|
|
|
|
break;
|
|
|
|
case 100:/* 100BASE */
|
|
|
|
sh_eth_write(ndev, sh_eth_read(ndev, ECMR) | ECMR_ELB, ECMR);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-04-27 10:44:24 +00:00
|
|
|
/* R8A7778/9 */
|
2013-06-07 14:05:59 +00:00
|
|
|
static struct sh_eth_cpu_data r8a777x_data = {
|
2013-03-28 11:51:31 +00:00
|
|
|
.set_duplex = sh_eth_set_duplex,
|
2013-06-07 14:05:59 +00:00
|
|
|
.set_rate = sh_eth_set_rate_r8a777x,
|
2013-03-28 11:51:31 +00:00
|
|
|
|
2013-08-17 23:11:28 +00:00
|
|
|
.register_type = SH_ETH_REG_FAST_RCAR,
|
|
|
|
|
2013-03-28 11:51:31 +00:00
|
|
|
.ecsr_value = ECSR_PSRTO | ECSR_LCHNG | ECSR_ICD,
|
|
|
|
.ecsipr_value = ECSIPR_PSRTOIP | ECSIPR_LCHNGIP | ECSIPR_ICDIP,
|
|
|
|
.eesipr_value = 0x01ff009f,
|
|
|
|
|
|
|
|
.tx_check = EESR_FTC | EESR_CND | EESR_DLC | EESR_CD | EESR_RTO,
|
2013-06-20 21:12:21 +00:00
|
|
|
.eesr_err_check = EESR_TWB | EESR_TABT | EESR_RABT | EESR_RFE |
|
|
|
|
EESR_RDE | EESR_RFRMER | EESR_TFE | EESR_TDE |
|
|
|
|
EESR_ECI,
|
2013-03-28 11:51:31 +00:00
|
|
|
|
|
|
|
.apr = 1,
|
|
|
|
.mpr = 1,
|
|
|
|
.tpauser = 1,
|
|
|
|
.hw_swap = 1,
|
|
|
|
};
|
|
|
|
|
2013-07-23 01:18:05 +00:00
|
|
|
/* R8A7790 */
|
|
|
|
static struct sh_eth_cpu_data r8a7790_data = {
|
|
|
|
.set_duplex = sh_eth_set_duplex,
|
|
|
|
.set_rate = sh_eth_set_rate_r8a777x,
|
|
|
|
|
2013-08-17 23:11:28 +00:00
|
|
|
.register_type = SH_ETH_REG_FAST_RCAR,
|
|
|
|
|
2013-07-23 01:18:05 +00:00
|
|
|
.ecsr_value = ECSR_PSRTO | ECSR_LCHNG | ECSR_ICD,
|
|
|
|
.ecsipr_value = ECSIPR_PSRTOIP | ECSIPR_LCHNGIP | ECSIPR_ICDIP,
|
|
|
|
.eesipr_value = 0x01ff009f,
|
|
|
|
|
|
|
|
.tx_check = EESR_FTC | EESR_CND | EESR_DLC | EESR_CD | EESR_RTO,
|
2013-07-31 07:42:11 +00:00
|
|
|
.eesr_err_check = EESR_TWB | EESR_TABT | EESR_RABT | EESR_RFE |
|
|
|
|
EESR_RDE | EESR_RFRMER | EESR_TFE | EESR_TDE |
|
|
|
|
EESR_ECI,
|
2013-07-23 01:18:05 +00:00
|
|
|
|
|
|
|
.apr = 1,
|
|
|
|
.mpr = 1,
|
|
|
|
.tpauser = 1,
|
|
|
|
.hw_swap = 1,
|
|
|
|
.rmiimode = 1,
|
2013-08-30 03:41:08 +00:00
|
|
|
.shift_rd0 = 1,
|
2013-07-23 01:18:05 +00:00
|
|
|
};
|
|
|
|
|
2013-06-07 14:03:37 +00:00
|
|
|
static void sh_eth_set_rate_sh7724(struct net_device *ndev)
|
2013-03-28 11:51:31 +00:00
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
2009-05-24 23:54:30 +00:00
|
|
|
|
|
|
|
switch (mdp->speed) {
|
|
|
|
case 10: /* 10BASE */
|
2013-03-28 11:51:31 +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 */
|
2013-03-28 11:51:31 +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 */
|
2013-06-07 14:03:37 +00:00
|
|
|
static struct sh_eth_cpu_data sh7724_data = {
|
2009-05-24 23:54:30 +00:00
|
|
|
.set_duplex = sh_eth_set_duplex,
|
2013-06-07 14:03:37 +00:00
|
|
|
.set_rate = sh_eth_set_rate_sh7724,
|
2009-05-24 23:54:30 +00:00
|
|
|
|
2013-08-17 23:11:28 +00:00
|
|
|
.register_type = SH_ETH_REG_FAST_SH4,
|
|
|
|
|
2009-05-24 23:54:30 +00:00
|
|
|
.ecsr_value = ECSR_PSRTO | ECSR_LCHNG | ECSR_ICD,
|
|
|
|
.ecsipr_value = ECSIPR_PSRTOIP | ECSIPR_LCHNGIP | ECSIPR_ICDIP,
|
2013-06-19 22:24:54 +00:00
|
|
|
.eesipr_value = 0x01ff009f,
|
2009-05-24 23:54:30 +00:00
|
|
|
|
|
|
|
.tx_check = EESR_FTC | EESR_CND | EESR_DLC | EESR_CD | EESR_RTO,
|
2013-06-20 21:12:21 +00:00
|
|
|
.eesr_err_check = EESR_TWB | EESR_TABT | EESR_RABT | EESR_RFE |
|
|
|
|
EESR_RDE | EESR_RFRMER | EESR_TFE | EESR_TDE |
|
|
|
|
EESR_ECI,
|
2009-05-24 23:54:30 +00:00
|
|
|
|
|
|
|
.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
|
|
|
};
|
2012-06-25 17:35:12 +00:00
|
|
|
|
2013-06-07 13:59:21 +00:00
|
|
|
static void sh_eth_set_rate_sh7757(struct net_device *ndev)
|
2010-07-05 18:32:50 +00:00
|
|
|
{
|
|
|
|
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 */
|
2013-06-07 13:59:21 +00:00
|
|
|
static struct sh_eth_cpu_data sh7757_data = {
|
|
|
|
.set_duplex = sh_eth_set_duplex,
|
|
|
|
.set_rate = sh_eth_set_rate_sh7757,
|
2010-07-05 18:32:50 +00:00
|
|
|
|
2013-08-17 23:11:28 +00:00
|
|
|
.register_type = SH_ETH_REG_FAST_SH4,
|
|
|
|
|
2010-07-05 18:32:50 +00:00
|
|
|
.eesipr_value = DMAC_M_RFRMER | DMAC_M_ECI | 0x003fffff,
|
2013-10-15 22:29:58 +00:00
|
|
|
.rmcr_value = RMCR_RNC,
|
2010-07-05 18:32:50 +00:00
|
|
|
|
|
|
|
.tx_check = EESR_FTC | EESR_CND | EESR_DLC | EESR_CD | EESR_RTO,
|
2013-06-20 21:12:21 +00:00
|
|
|
.eesr_err_check = EESR_TWB | EESR_TABT | EESR_RABT | EESR_RFE |
|
|
|
|
EESR_RDE | EESR_RFRMER | EESR_TFE | EESR_TDE |
|
|
|
|
EESR_ECI,
|
2010-07-05 18:32:50 +00:00
|
|
|
|
2013-06-06 09:49:30 +00:00
|
|
|
.irq_flags = IRQF_SHARED,
|
2010-07-05 18:32:50 +00:00
|
|
|
.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
|
|
|
|
2013-06-08 06:40:41 +00:00
|
|
|
#define SH_GIGA_ETH_BASE 0xfee00000UL
|
2011-03-07 21:59:49 +00:00
|
|
|
#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 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) */
|
2013-06-07 13:59:21 +00:00
|
|
|
static struct sh_eth_cpu_data sh7757_data_giga = {
|
2011-03-07 21:59:49 +00:00
|
|
|
.chip_reset = sh_eth_chip_reset_giga,
|
2013-06-06 09:45:25 +00:00
|
|
|
.set_duplex = sh_eth_set_duplex,
|
2011-03-07 21:59:49 +00:00
|
|
|
.set_rate = sh_eth_set_rate_giga,
|
|
|
|
|
2013-08-17 23:11:28 +00:00
|
|
|
.register_type = SH_ETH_REG_GIGABIT,
|
|
|
|
|
2011-03-07 21:59:49 +00:00
|
|
|
.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,
|
2013-06-20 21:12:21 +00:00
|
|
|
.eesr_err_check = EESR_TWB1 | EESR_TWB | EESR_TABT | EESR_RABT |
|
|
|
|
EESR_RFE | EESR_RDE | EESR_RFRMER | EESR_TFE |
|
|
|
|
EESR_TDE | EESR_ECI,
|
2011-03-07 21:59:49 +00:00
|
|
|
.fdr_value = 0x0000072f,
|
2013-10-15 22:29:58 +00:00
|
|
|
.rmcr_value = RMCR_RNC,
|
2011-03-07 21:59:49 +00:00
|
|
|
|
2013-06-06 09:49:30 +00:00
|
|
|
.irq_flags = IRQF_SHARED,
|
2011-03-07 21:59:49 +00:00
|
|
|
.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
|
|
|
};
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2013-06-07 13:58:18 +00:00
|
|
|
static void sh_eth_set_rate_gether(struct net_device *ndev)
|
2009-05-24 23:54:21 +00:00
|
|
|
{
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-06-07 13:58:18 +00:00
|
|
|
/* SH7734 */
|
|
|
|
static struct sh_eth_cpu_data sh7734_data = {
|
2009-05-24 23:54:21 +00:00
|
|
|
.chip_reset = sh_eth_chip_reset,
|
|
|
|
.set_duplex = sh_eth_set_duplex,
|
2013-06-07 13:58:18 +00:00
|
|
|
.set_rate = sh_eth_set_rate_gether,
|
|
|
|
|
2013-08-17 23:11:28 +00:00
|
|
|
.register_type = SH_ETH_REG_GIGABIT,
|
|
|
|
|
2013-06-07 13:58:18 +00:00
|
|
|
.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,
|
2013-06-20 21:12:21 +00:00
|
|
|
.eesr_err_check = EESR_TWB1 | EESR_TWB | EESR_TABT | EESR_RABT |
|
|
|
|
EESR_RFE | EESR_RDE | EESR_RFRMER | EESR_TFE |
|
|
|
|
EESR_TDE | EESR_ECI,
|
2013-06-07 13:58:18 +00:00
|
|
|
|
|
|
|
.apr = 1,
|
|
|
|
.mpr = 1,
|
|
|
|
.tpauser = 1,
|
|
|
|
.bculr = 1,
|
|
|
|
.hw_swap = 1,
|
|
|
|
.no_trimd = 1,
|
|
|
|
.no_ade = 1,
|
|
|
|
.tsu = 1,
|
|
|
|
.hw_crc = 1,
|
|
|
|
.select_mii = 1,
|
|
|
|
};
|
|
|
|
|
|
|
|
/* SH7763 */
|
|
|
|
static struct sh_eth_cpu_data sh7763_data = {
|
|
|
|
.chip_reset = sh_eth_chip_reset,
|
|
|
|
.set_duplex = sh_eth_set_duplex,
|
|
|
|
.set_rate = sh_eth_set_rate_gether,
|
2009-05-24 23:54:21 +00:00
|
|
|
|
2013-08-17 23:11:28 +00:00
|
|
|
.register_type = SH_ETH_REG_GIGABIT,
|
|
|
|
|
2009-05-24 23:54:21 +00:00
|
|
|
.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,
|
|
|
|
|
|
|
|
.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,
|
2013-06-06 09:49:30 +00:00
|
|
|
.irq_flags = IRQF_SHARED,
|
2009-05-24 23:54:21 +00:00
|
|
|
};
|
|
|
|
|
2013-06-07 13:57:12 +00:00
|
|
|
static void sh_eth_chip_reset_r8a7740(struct net_device *ndev)
|
2012-04-04 18:37:10 +00:00
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
|
|
|
|
/* reset device */
|
|
|
|
sh_eth_tsu_write(mdp, ARSTR_ARSTR, ARSTR);
|
|
|
|
mdelay(1);
|
|
|
|
|
2012-06-25 17:34:14 +00:00
|
|
|
sh_eth_select_mii(ndev);
|
2012-04-04 18:37:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* R8A7740 */
|
2013-06-07 13:57:12 +00:00
|
|
|
static struct sh_eth_cpu_data r8a7740_data = {
|
|
|
|
.chip_reset = sh_eth_chip_reset_r8a7740,
|
2012-04-04 18:37:10 +00:00
|
|
|
.set_duplex = sh_eth_set_duplex,
|
2013-06-07 13:57:12 +00:00
|
|
|
.set_rate = sh_eth_set_rate_gether,
|
2012-04-04 18:37:10 +00:00
|
|
|
|
2013-08-17 23:11:28 +00:00
|
|
|
.register_type = SH_ETH_REG_GIGABIT,
|
|
|
|
|
2012-04-04 18:37:10 +00:00
|
|
|
.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,
|
2013-06-20 21:12:21 +00:00
|
|
|
.eesr_err_check = EESR_TWB1 | EESR_TWB | EESR_TABT | EESR_RABT |
|
|
|
|
EESR_RFE | EESR_RDE | EESR_RFRMER | EESR_TFE |
|
|
|
|
EESR_TDE | EESR_ECI,
|
2013-10-10 05:51:16 +00:00
|
|
|
.fdr_value = 0x0000070f,
|
2013-10-15 22:29:58 +00:00
|
|
|
.rmcr_value = RMCR_RNC,
|
2012-04-04 18:37:10 +00:00
|
|
|
|
|
|
|
.apr = 1,
|
|
|
|
.mpr = 1,
|
|
|
|
.tpauser = 1,
|
|
|
|
.bculr = 1,
|
|
|
|
.hw_swap = 1,
|
2013-10-10 05:51:16 +00:00
|
|
|
.rpadir = 1,
|
|
|
|
.rpadir_value = 2 << 16,
|
2012-04-04 18:37:10 +00:00
|
|
|
.no_trimd = 1,
|
|
|
|
.no_ade = 1,
|
|
|
|
.tsu = 1,
|
2012-06-25 17:34:14 +00:00
|
|
|
.select_mii = 1,
|
2013-06-13 18:12:45 +00:00
|
|
|
.shift_rd0 = 1,
|
2012-04-04 18:37:10 +00:00
|
|
|
};
|
|
|
|
|
2013-06-07 13:56:05 +00:00
|
|
|
static struct sh_eth_cpu_data sh7619_data = {
|
2013-08-17 23:11:28 +00:00
|
|
|
.register_type = SH_ETH_REG_FAST_SH3_SH2,
|
|
|
|
|
2009-05-24 23:54:21 +00:00
|
|
|
.eesipr_value = DMAC_M_RFRMER | DMAC_M_ECI | 0x003fffff,
|
|
|
|
|
|
|
|
.apr = 1,
|
|
|
|
.mpr = 1,
|
|
|
|
.tpauser = 1,
|
|
|
|
.hw_swap = 1,
|
|
|
|
};
|
2013-06-07 13:55:08 +00:00
|
|
|
|
|
|
|
static struct sh_eth_cpu_data sh771x_data = {
|
2013-08-17 23:11:28 +00:00
|
|
|
.register_type = SH_ETH_REG_FAST_SH3_SH2,
|
|
|
|
|
2009-05-24 23:54:21 +00:00
|
|
|
.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
|
|
|
};
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2012-06-25 17:35:12 +00:00
|
|
|
static int sh_eth_check_reset(struct net_device *ndev)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
int cnt = 100;
|
|
|
|
|
|
|
|
while (cnt > 0) {
|
|
|
|
if (!(sh_eth_read(ndev, EDMR) & 0x3))
|
|
|
|
break;
|
|
|
|
mdelay(1);
|
|
|
|
cnt--;
|
|
|
|
}
|
2013-06-05 19:54:01 +00:00
|
|
|
if (cnt <= 0) {
|
|
|
|
pr_err("Device reset failed\n");
|
2012-06-25 17:35:12 +00:00
|
|
|
ret = -ETIMEDOUT;
|
|
|
|
}
|
|
|
|
return ret;
|
2009-05-24 23:54:21 +00:00
|
|
|
}
|
2013-06-06 09:51:39 +00:00
|
|
|
|
|
|
|
static int sh_eth_reset(struct net_device *ndev)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (sh_eth_is_gether(mdp)) {
|
|
|
|
sh_eth_write(ndev, EDSR_ENALL, EDSR);
|
|
|
|
sh_eth_write(ndev, sh_eth_read(ndev, EDMR) | EDMR_SRST_GETHER,
|
|
|
|
EDMR);
|
|
|
|
|
|
|
|
ret = sh_eth_check_reset(ndev);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/* 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);
|
|
|
|
|
|
|
|
/* Reset HW CRC register */
|
|
|
|
if (mdp->cd->hw_crc)
|
|
|
|
sh_eth_write(ndev, 0x0, CSMR);
|
|
|
|
|
|
|
|
/* Select MII mode */
|
|
|
|
if (mdp->cd->select_mii)
|
|
|
|
sh_eth_select_mii(ndev);
|
|
|
|
} 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);
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
2009-05-24 23:54:21 +00:00
|
|
|
|
2012-04-04 18:37:10 +00:00
|
|
|
#if defined(CONFIG_CPU_SH4) || defined(CONFIG_ARCH_SHMOBILE)
|
2009-05-24 23:54:21 +00:00
|
|
|
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]) {
|
2013-10-02 02:04:40 +00:00
|
|
|
memcpy(ndev->dev_addr, mac, ETH_ALEN);
|
2009-10-09 00:17:14 +00:00
|
|
|
} 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 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) {
|
2012-06-26 20:00:03 +00:00
|
|
|
for (i = 0; i < mdp->num_rx_ring; i++) {
|
2008-06-09 23:33:56 +00:00
|
|
|
if (mdp->rx_skbuff[i])
|
|
|
|
dev_kfree_skb(mdp->rx_skbuff[i]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
kfree(mdp->rx_skbuff);
|
2012-06-26 20:00:01 +00:00
|
|
|
mdp->rx_skbuff = NULL;
|
2008-06-09 23:33:56 +00:00
|
|
|
|
|
|
|
/* Free Tx skb ringbuffer */
|
|
|
|
if (mdp->tx_skbuff) {
|
2012-06-26 20:00:03 +00:00
|
|
|
for (i = 0; i < mdp->num_tx_ring; i++) {
|
2008-06-09 23:33:56 +00:00
|
|
|
if (mdp->tx_skbuff[i])
|
|
|
|
dev_kfree_skb(mdp->tx_skbuff[i]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
kfree(mdp->tx_skbuff);
|
2012-06-26 20:00:01 +00:00
|
|
|
mdp->tx_skbuff = NULL;
|
2008-06-09 23:33:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* 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;
|
2012-06-26 20:00:03 +00:00
|
|
|
int rx_ringsize = sizeof(*rxdesc) * mdp->num_rx_ring;
|
|
|
|
int tx_ringsize = sizeof(*txdesc) * mdp->num_tx_ring;
|
2008-06-09 23:33:56 +00:00
|
|
|
|
|
|
|
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 */
|
2012-06-26 20:00:03 +00:00
|
|
|
for (i = 0; i < mdp->num_rx_ring; i++) {
|
2008-06-09 23:33:56 +00:00
|
|
|
/* 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
|
|
|
}
|
|
|
|
|
2012-06-26 20:00:03 +00:00
|
|
|
mdp->dirty_rx = (u32) (i - mdp->num_rx_ring);
|
2008-06-09 23:33:56 +00:00
|
|
|
|
|
|
|
/* 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 */
|
2012-06-26 20:00:03 +00:00
|
|
|
for (i = 0; i < mdp->num_tx_ring; i++) {
|
2008-06-09 23:33:56 +00:00
|
|
|
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 */
|
2013-02-03 17:43:58 +00:00
|
|
|
mdp->rx_skbuff = kmalloc_array(mdp->num_rx_ring,
|
|
|
|
sizeof(*mdp->rx_skbuff), GFP_KERNEL);
|
2008-06-09 23:33:56 +00:00
|
|
|
if (!mdp->rx_skbuff) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2013-02-03 17:43:58 +00:00
|
|
|
mdp->tx_skbuff = kmalloc_array(mdp->num_tx_ring,
|
|
|
|
sizeof(*mdp->tx_skbuff), GFP_KERNEL);
|
2008-06-09 23:33:56 +00:00
|
|
|
if (!mdp->tx_skbuff) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto skb_ring_free;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Allocate all Rx descriptors. */
|
2012-06-26 20:00:03 +00:00
|
|
|
rx_ringsize = sizeof(struct sh_eth_rxdesc) * mdp->num_rx_ring;
|
2008-06-09 23:33:56 +00:00
|
|
|
mdp->rx_ring = dma_alloc_coherent(NULL, rx_ringsize, &mdp->rx_desc_dma,
|
2013-03-14 13:07:21 +00:00
|
|
|
GFP_KERNEL);
|
2008-06-09 23:33:56 +00:00
|
|
|
if (!mdp->rx_ring) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto desc_ring_free;
|
|
|
|
}
|
|
|
|
|
|
|
|
mdp->dirty_rx = 0;
|
|
|
|
|
|
|
|
/* Allocate all Tx descriptors. */
|
2012-06-26 20:00:03 +00:00
|
|
|
tx_ringsize = sizeof(struct sh_eth_txdesc) * mdp->num_tx_ring;
|
2008-06-09 23:33:56 +00:00
|
|
|
mdp->tx_ring = dma_alloc_coherent(NULL, tx_ringsize, &mdp->tx_desc_dma,
|
2013-03-14 13:07:21 +00:00
|
|
|
GFP_KERNEL);
|
2008-06-09 23:33:56 +00:00
|
|
|
if (!mdp->tx_ring) {
|
|
|
|
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);
|
2012-06-26 20:00:01 +00:00
|
|
|
mdp->tx_ring = NULL;
|
|
|
|
mdp->rx_ring = NULL;
|
2008-06-09 23:33:56 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-06-26 20:00:01 +00:00
|
|
|
static void sh_eth_free_dma_buffer(struct sh_eth_private *mdp)
|
|
|
|
{
|
|
|
|
int ringsize;
|
|
|
|
|
|
|
|
if (mdp->rx_ring) {
|
2012-06-26 20:00:03 +00:00
|
|
|
ringsize = sizeof(struct sh_eth_rxdesc) * mdp->num_rx_ring;
|
2012-06-26 20:00:01 +00:00
|
|
|
dma_free_coherent(NULL, ringsize, mdp->rx_ring,
|
|
|
|
mdp->rx_desc_dma);
|
|
|
|
mdp->rx_ring = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (mdp->tx_ring) {
|
2012-06-26 20:00:03 +00:00
|
|
|
ringsize = sizeof(struct sh_eth_txdesc) * mdp->num_tx_ring;
|
2012-06-26 20:00:01 +00:00
|
|
|
dma_free_coherent(NULL, ringsize, mdp->tx_ring,
|
|
|
|
mdp->tx_desc_dma);
|
|
|
|
mdp->tx_ring = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-06-26 20:00:03 +00:00
|
|
|
static int sh_eth_dev_init(struct net_device *ndev, bool start)
|
2008-06-09 23:33:56 +00:00
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
u32 val;
|
|
|
|
|
|
|
|
/* Soft Reset */
|
2012-06-25 17:35:12 +00:00
|
|
|
ret = sh_eth_reset(ndev);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
2008-06-09 23:33:56 +00:00
|
|
|
|
2013-07-23 01:18:04 +00:00
|
|
|
if (mdp->cd->rmiimode)
|
|
|
|
sh_eth_write(ndev, 0x1, RMIIMODE);
|
|
|
|
|
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
|
|
|
|
2012-06-26 19:59:58 +00:00
|
|
|
sh_eth_write(ndev, DESC_I_RINT8 | DESC_I_RINT5 | DESC_I_TINT2, 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);
|
2012-06-26 20:00:03 +00:00
|
|
|
if (start)
|
|
|
|
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 */
|
2012-06-26 20:00:03 +00:00
|
|
|
if (start)
|
|
|
|
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
|
|
|
|
2012-06-26 20:00:03 +00:00
|
|
|
if (start) {
|
|
|
|
/* Setting the Rx mode will start the Rx process. */
|
|
|
|
sh_eth_write(ndev, EDRRR_R, EDRRR);
|
2008-06-09 23:33:56 +00:00
|
|
|
|
2012-06-26 20:00:03 +00:00
|
|
|
netif_start_queue(ndev);
|
|
|
|
}
|
2008-06-09 23:33:56 +00:00
|
|
|
|
2012-06-25 17:35:12 +00:00
|
|
|
out:
|
2008-06-09 23:33:56 +00:00
|
|
|
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++) {
|
2012-06-26 20:00:03 +00:00
|
|
|
entry = mdp->dirty_tx % mdp->num_tx_ring;
|
2008-06-09 23:33:56 +00:00
|
|
|
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);
|
2012-06-26 20:00:03 +00:00
|
|
|
if (entry >= mdp->num_tx_ring - 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 */
|
2013-06-19 19:30:23 +00:00
|
|
|
static int sh_eth_rx(struct net_device *ndev, u32 intr_status, int *quota)
|
2008-06-09 23:33:56 +00:00
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
struct sh_eth_rxdesc *rxdesc;
|
|
|
|
|
2012-06-26 20:00:03 +00:00
|
|
|
int entry = mdp->cur_rx % mdp->num_rx_ring;
|
|
|
|
int boguscnt = (mdp->dirty_rx + mdp->num_rx_ring) - mdp->cur_rx;
|
2008-06-09 23:33:56 +00:00
|
|
|
struct sk_buff *skb;
|
2013-06-19 19:30:23 +00:00
|
|
|
int exceeded = 0;
|
2008-06-09 23:33:56 +00:00
|
|
|
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;
|
|
|
|
|
2013-06-19 19:30:23 +00:00
|
|
|
if (*quota <= 0) {
|
|
|
|
exceeded = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
(*quota)--;
|
|
|
|
|
2008-06-09 23:33:56 +00:00
|
|
|
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
|
|
|
|
2013-06-13 01:15:45 +00:00
|
|
|
/*
|
|
|
|
* In case of almost all GETHER/ETHERs, the Receive Frame State
|
|
|
|
* (RFS) bits in the Receive Descriptor 0 are from bit 9 to
|
|
|
|
* bit 0. However, in case of the R8A7740's GETHER, the RFS
|
|
|
|
* bits are from bit 25 to bit 16. So, the driver needs right
|
|
|
|
* shifting by 16.
|
|
|
|
*/
|
2013-06-13 18:12:45 +00:00
|
|
|
if (mdp->cd->shift_rd0)
|
|
|
|
desc_status >>= 16;
|
2013-06-13 01:15:45 +00:00
|
|
|
|
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);
|
2013-08-30 03:41:07 +00:00
|
|
|
dma_sync_single_for_cpu(&ndev->dev, rxdesc->addr,
|
|
|
|
mdp->rx_buf_sz,
|
|
|
|
DMA_FROM_DEVICE);
|
2008-06-09 23:33:56 +00:00
|
|
|
skb_put(skb, pkt_len);
|
|
|
|
skb->protocol = eth_type_trans(skb, ndev);
|
2013-09-02 23:03:10 +00:00
|
|
|
netif_receive_skb(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);
|
2012-06-26 20:00:03 +00:00
|
|
|
entry = (++mdp->cur_rx) % mdp->num_rx_ring;
|
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++) {
|
2012-06-26 20:00:03 +00:00
|
|
|
entry = mdp->dirty_rx % mdp->num_rx_ring;
|
2008-06-09 23:33:56 +00:00
|
|
|
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
|
|
|
}
|
2012-06-26 20:00:03 +00:00
|
|
|
if (entry >= mdp->num_rx_ring - 1)
|
2008-06-09 23:33:56 +00:00
|
|
|
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 */
|
2012-05-28 23:07:55 +00:00
|
|
|
if (!(sh_eth_read(ndev, EDRRR) & EDRRR_R)) {
|
2012-06-20 15:26:34 +00:00
|
|
|
/* fix the values for the next receiving if RDE is set */
|
|
|
|
if (intr_status & EESR_RDE)
|
|
|
|
mdp->cur_rx = mdp->dirty_rx =
|
|
|
|
(sh_eth_read(ndev, RDFAR) -
|
|
|
|
sh_eth_read(ndev, RDLAR)) >> 4;
|
2011-03-07 21:59:26 +00:00
|
|
|
sh_eth_write(ndev, EDRRR_R, EDRRR);
|
2012-05-28 23:07:55 +00:00
|
|
|
}
|
2008-06-09 23:33:56 +00:00
|
|
|
|
2013-06-19 19:30:23 +00:00
|
|
|
return exceeded;
|
2008-06-09 23:33:56 +00:00
|
|
|
}
|
|
|
|
|
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) {
|
2013-03-31 09:50:07 +00:00
|
|
|
goto ignore_link;
|
2009-05-24 23:54:21 +00:00
|
|
|
} 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
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-03-31 09:50:07 +00:00
|
|
|
ignore_link:
|
2008-06-09 23:33:56 +00:00
|
|
|
if (intr_status & EESR_TWB) {
|
2013-06-20 21:13:42 +00:00
|
|
|
/* 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");
|
2013-06-20 21:13:42 +00:00
|
|
|
}
|
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-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;
|
2013-06-19 19:30:23 +00:00
|
|
|
unsigned long intr_status, intr_enable;
|
2008-06-09 23:33:56 +00:00
|
|
|
|
|
|
|
spin_lock(&mdp->lock);
|
|
|
|
|
2013-03-31 09:54:20 +00:00
|
|
|
/* Get interrupt status */
|
2011-03-07 21:59:26 +00:00
|
|
|
intr_status = sh_eth_read(ndev, EESR);
|
2013-03-31 09:54:20 +00:00
|
|
|
/* Mask it with the interrupt mask, forcing ECI interrupt to be always
|
|
|
|
* enabled since it's the one that comes thru regardless of the mask,
|
|
|
|
* and we need to fully handle it in sh_eth_error() in order to quench
|
|
|
|
* it as it doesn't get cleared by just writing 1 to the ECI bit...
|
|
|
|
*/
|
2013-06-19 19:30:23 +00:00
|
|
|
intr_enable = sh_eth_read(ndev, EESIPR);
|
|
|
|
intr_status &= intr_enable | DMAC_M_ECI;
|
|
|
|
if (intr_status & (EESR_RX_CHECK | cd->tx_check | cd->eesr_err_check))
|
2009-03-16 19:50:57 +00:00
|
|
|
ret = IRQ_HANDLED;
|
2013-06-19 19:30:23 +00:00
|
|
|
else
|
2009-03-16 19:50:57 +00:00
|
|
|
goto other_irq;
|
2008-06-09 23:33:56 +00:00
|
|
|
|
2013-06-19 19:30:23 +00:00
|
|
|
if (intr_status & EESR_RX_CHECK) {
|
|
|
|
if (napi_schedule_prep(&mdp->napi)) {
|
|
|
|
/* Mask Rx interrupts */
|
|
|
|
sh_eth_write(ndev, intr_enable & ~EESR_RX_CHECK,
|
|
|
|
EESIPR);
|
|
|
|
__napi_schedule(&mdp->napi);
|
|
|
|
} else {
|
|
|
|
dev_warn(&ndev->dev,
|
|
|
|
"ignoring interrupt, status 0x%08lx, mask 0x%08lx.\n",
|
|
|
|
intr_status, intr_enable);
|
|
|
|
}
|
|
|
|
}
|
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) {
|
2013-06-19 19:30:23 +00:00
|
|
|
/* Clear Tx interrupts */
|
|
|
|
sh_eth_write(ndev, intr_status & cd->tx_check, EESR);
|
|
|
|
|
2008-06-09 23:33:56 +00:00
|
|
|
sh_eth_txfree(ndev);
|
|
|
|
netif_wake_queue(ndev);
|
|
|
|
}
|
|
|
|
|
2013-06-19 19:30:23 +00:00
|
|
|
if (intr_status & cd->eesr_err_check) {
|
|
|
|
/* Clear error interrupts */
|
|
|
|
sh_eth_write(ndev, intr_status & cd->eesr_err_check, EESR);
|
|
|
|
|
2008-06-09 23:33:56 +00:00
|
|
|
sh_eth_error(ndev, intr_status);
|
2013-06-19 19:30:23 +00:00
|
|
|
}
|
2008-06-09 23:33:56 +00:00
|
|
|
|
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
|
|
|
}
|
|
|
|
|
2013-06-19 19:30:23 +00:00
|
|
|
static int sh_eth_poll(struct napi_struct *napi, int budget)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = container_of(napi, struct sh_eth_private,
|
|
|
|
napi);
|
|
|
|
struct net_device *ndev = napi->dev;
|
|
|
|
int quota = budget;
|
|
|
|
unsigned long intr_status;
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
intr_status = sh_eth_read(ndev, EESR);
|
|
|
|
if (!(intr_status & EESR_RX_CHECK))
|
|
|
|
break;
|
|
|
|
/* Clear Rx interrupts */
|
|
|
|
sh_eth_write(ndev, intr_status & EESR_RX_CHECK, EESR);
|
|
|
|
|
|
|
|
if (sh_eth_rx(ndev, intr_status, "a))
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
napi_complete(napi);
|
|
|
|
|
|
|
|
/* Reenable Rx interrupts */
|
|
|
|
sh_eth_write(ndev, mdp->cd->eesipr_value, EESIPR);
|
|
|
|
out:
|
|
|
|
return budget - quota;
|
|
|
|
}
|
|
|
|
|
2008-06-09 23:33:56 +00:00
|
|
|
/* 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;
|
|
|
|
|
2013-03-31 10:11:04 +00:00
|
|
|
if (phydev->link) {
|
2008-06-09 23:33:56 +00:00
|
|
|
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
|
|
|
}
|
2013-03-31 10:11:04 +00:00
|
|
|
if (!mdp->link) {
|
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;
|
2013-03-31 09:50:07 +00:00
|
|
|
if (mdp->cd->no_psr || mdp->no_ether_link)
|
|
|
|
sh_eth_rcv_snd_enable(ndev);
|
2008-06-09 23:33:56 +00:00
|
|
|
}
|
|
|
|
} else if (mdp->link) {
|
|
|
|
new_state = 1;
|
2013-03-31 10:11:04 +00:00
|
|
|
mdp->link = 0;
|
2008-06-09 23:33:56 +00:00
|
|
|
mdp->speed = 0;
|
|
|
|
mdp->duplex = -1;
|
2013-03-31 09:50:07 +00:00
|
|
|
if (mdp->cd->no_psr || mdp->no_ether_link)
|
|
|
|
sh_eth_rcv_snd_disable(ndev);
|
2008-06-09 23:33:56 +00:00
|
|
|
}
|
|
|
|
|
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);
|
|
|
|
|
2013-03-31 10:11:04 +00:00
|
|
|
mdp->link = 0;
|
2008-06-09 23:33:56 +00:00
|
|
|
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,
|
2013-01-14 00:52:52 +00:00
|
|
|
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-06-26 20:00:03 +00:00
|
|
|
static void sh_eth_get_ringparam(struct net_device *ndev,
|
|
|
|
struct ethtool_ringparam *ring)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
|
|
|
|
ring->rx_max_pending = RX_RING_MAX;
|
|
|
|
ring->tx_max_pending = TX_RING_MAX;
|
|
|
|
ring->rx_pending = mdp->num_rx_ring;
|
|
|
|
ring->tx_pending = mdp->num_tx_ring;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sh_eth_set_ringparam(struct net_device *ndev,
|
|
|
|
struct ethtool_ringparam *ring)
|
|
|
|
{
|
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (ring->tx_pending > TX_RING_MAX ||
|
|
|
|
ring->rx_pending > RX_RING_MAX ||
|
|
|
|
ring->tx_pending < TX_RING_MIN ||
|
|
|
|
ring->rx_pending < RX_RING_MIN)
|
|
|
|
return -EINVAL;
|
|
|
|
if (ring->rx_mini_pending || ring->rx_jumbo_pending)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (netif_running(ndev)) {
|
|
|
|
netif_tx_disable(ndev);
|
|
|
|
/* Disable interrupts by clearing the interrupt mask. */
|
|
|
|
sh_eth_write(ndev, 0x0000, EESIPR);
|
|
|
|
/* Stop the chip's Tx and Rx processes. */
|
|
|
|
sh_eth_write(ndev, 0, EDTRR);
|
|
|
|
sh_eth_write(ndev, 0, EDRRR);
|
|
|
|
synchronize_irq(ndev->irq);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Free all the skbuffs in the Rx queue. */
|
|
|
|
sh_eth_ring_free(ndev);
|
|
|
|
/* Free DMA buffer */
|
|
|
|
sh_eth_free_dma_buffer(mdp);
|
|
|
|
|
|
|
|
/* Set new parameters */
|
|
|
|
mdp->num_rx_ring = ring->rx_pending;
|
|
|
|
mdp->num_tx_ring = ring->tx_pending;
|
|
|
|
|
|
|
|
ret = sh_eth_ring_init(ndev);
|
|
|
|
if (ret < 0) {
|
|
|
|
dev_err(&ndev->dev, "%s: sh_eth_ring_init failed.\n", __func__);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
ret = sh_eth_dev_init(ndev, false);
|
|
|
|
if (ret < 0) {
|
|
|
|
dev_err(&ndev->dev, "%s: sh_eth_dev_init failed.\n", __func__);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (netif_running(ndev)) {
|
|
|
|
sh_eth_write(ndev, mdp->cd->eesipr_value, EESIPR);
|
|
|
|
/* Setting the Rx mode will start the Rx process. */
|
|
|
|
sh_eth_write(ndev, EDRRR_R, EDRRR);
|
|
|
|
netif_wake_queue(ndev);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
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,
|
2012-06-26 20:00:03 +00:00
|
|
|
.get_ringparam = sh_eth_get_ringparam,
|
|
|
|
.set_ringparam = sh_eth_set_ringparam,
|
2011-02-15 21:17:32 +00:00
|
|
|
};
|
|
|
|
|
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);
|
|
|
|
|
2013-09-03 22:41:27 +00:00
|
|
|
napi_enable(&mdp->napi);
|
|
|
|
|
2009-11-19 07:29:17 +00:00
|
|
|
ret = request_irq(ndev->irq, sh_eth_interrupt,
|
2013-06-06 09:49:30 +00:00
|
|
|
mdp->cd->irq_flags, 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");
|
2013-09-03 22:41:27 +00:00
|
|
|
goto out_napi_off;
|
2008-06-09 23:33:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Descriptor set */
|
|
|
|
ret = sh_eth_ring_init(ndev);
|
|
|
|
if (ret)
|
|
|
|
goto out_free_irq;
|
|
|
|
|
|
|
|
/* device init */
|
2012-06-26 20:00:03 +00:00
|
|
|
ret = sh_eth_dev_init(ndev, true);
|
2008-06-09 23:33:56 +00:00
|
|
|
if (ret)
|
|
|
|
goto out_free_irq;
|
|
|
|
|
|
|
|
/* PHY control start*/
|
|
|
|
ret = sh_eth_phy_start(ndev);
|
|
|
|
if (ret)
|
|
|
|
goto out_free_irq;
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
out_free_irq:
|
|
|
|
free_irq(ndev->irq, ndev);
|
2013-09-03 22:41:27 +00:00
|
|
|
out_napi_off:
|
|
|
|
napi_disable(&mdp->napi);
|
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
|
|
|
|
|
|
|
/* Free all the skbuffs in the Rx queue. */
|
2012-06-26 20:00:03 +00:00
|
|
|
for (i = 0; i < mdp->num_rx_ring; i++) {
|
2008-06-09 23:33:56 +00:00
|
|
|
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;
|
|
|
|
}
|
2012-06-26 20:00:03 +00:00
|
|
|
for (i = 0; i < mdp->num_tx_ring; i++) {
|
2008-06-09 23:33:56 +00:00
|
|
|
if (mdp->tx_skbuff[i])
|
|
|
|
dev_kfree_skb(mdp->tx_skbuff[i]);
|
|
|
|
mdp->tx_skbuff[i] = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* device init */
|
2012-06-26 20:00:03 +00:00
|
|
|
sh_eth_dev_init(ndev, true);
|
2008-06-09 23:33:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* 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);
|
2012-06-26 20:00:03 +00:00
|
|
|
if ((mdp->cur_tx - mdp->dirty_tx) >= (mdp->num_tx_ring - 4)) {
|
2008-06-09 23:33:56 +00:00
|
|
|
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);
|
|
|
|
|
2012-06-26 20:00:03 +00:00
|
|
|
entry = mdp->cur_tx % mdp->num_tx_ring;
|
2008-06-09 23:33:56 +00:00
|
|
|
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;
|
|
|
|
|
2012-06-26 20:00:03 +00:00
|
|
|
if (entry >= mdp->num_tx_ring - 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);
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
2013-09-03 22:41:27 +00:00
|
|
|
napi_disable(&mdp->napi);
|
|
|
|
|
2008-06-09 23:33:56 +00:00
|
|
|
/* Free all the skbuffs in the Rx queue. */
|
|
|
|
sh_eth_ring_free(ndev);
|
|
|
|
|
|
|
|
/* free DMA buffer */
|
2012-06-26 20:00:01 +00:00
|
|
|
sh_eth_free_dma_buffer(mdp);
|
2008-06-09 23:33:56 +00:00
|
|
|
|
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
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2013-04-19 02:04:28 +00:00
|
|
|
static int sh_eth_vlan_rx_add_vid(struct net_device *ndev,
|
|
|
|
__be16 proto, u16 vid)
|
2012-02-15 17:55:06 +00:00
|
|
|
{
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2013-04-19 02:04:28 +00:00
|
|
|
static int sh_eth_vlan_rx_kill_vid(struct net_device *ndev,
|
|
|
|
__be16 proto, u16 vid)
|
2012-02-15 17:55:06 +00:00
|
|
|
{
|
|
|
|
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;
|
|
|
|
}
|
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);
|
|
|
|
|
|
|
|
/* 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 */
|
2013-03-21 10:41:11 +00:00
|
|
|
bitbang = devm_kzalloc(&ndev->dev, sizeof(struct bb_info),
|
|
|
|
GFP_KERNEL);
|
2008-06-09 23:33:56 +00:00
|
|
|
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;
|
2013-03-21 10:37:54 +00:00
|
|
|
bitbang->mdi_msk = PIR_MDI;
|
|
|
|
bitbang->mdo_msk = PIR_MDO;
|
|
|
|
bitbang->mmd_msk = PIR_MMD;
|
|
|
|
bitbang->mdc_msk = PIR_MDC;
|
2008-06-09 23:33:56 +00:00
|
|
|
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;
|
2013-03-21 10:41:11 +00:00
|
|
|
goto out;
|
2008-06-09 23:33:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* 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 */
|
2013-03-21 10:41:11 +00:00
|
|
|
mdp->mii_bus->irq = devm_kzalloc(&ndev->dev,
|
|
|
|
sizeof(int) * PHY_MAX_ADDR,
|
|
|
|
GFP_KERNEL);
|
2008-06-09 23:33:56 +00:00
|
|
|
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;
|
|
|
|
|
2012-11-02 04:45:07 +00:00
|
|
|
/* register mdio bus */
|
2008-06-09 23:33:56 +00:00
|
|
|
ret = mdiobus_register(mdp->mii_bus);
|
|
|
|
if (ret)
|
2013-03-21 10:41:11 +00:00
|
|
|
goto out_free_bus;
|
2008-06-09 23:33:56 +00:00
|
|
|
|
|
|
|
dev_set_drvdata(&ndev->dev, mdp->mii_bus);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
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:
|
|
|
|
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;
|
2013-03-28 11:51:31 +00:00
|
|
|
case SH_ETH_REG_FAST_RCAR:
|
|
|
|
reg_offset = sh_eth_offset_fast_rcar;
|
|
|
|
break;
|
2011-03-07 21:59:26 +00:00
|
|
|
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:
|
2013-03-20 22:46:55 +00:00
|
|
|
pr_err("Unknown register type (%d)\n", register_type);
|
2011-03-07 21:59:26 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return reg_offset;
|
|
|
|
}
|
|
|
|
|
2013-06-12 20:55:34 +00:00
|
|
|
static const struct net_device_ops sh_eth_netdev_ops = {
|
2009-04-11 07:40:49 +00:00
|
|
|
.ndo_open = sh_eth_open,
|
|
|
|
.ndo_stop = sh_eth_close,
|
|
|
|
.ndo_start_xmit = sh_eth_start_xmit,
|
|
|
|
.ndo_get_stats = sh_eth_get_stats,
|
|
|
|
.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,
|
|
|
|
};
|
|
|
|
|
2013-06-12 20:55:34 +00:00
|
|
|
static const struct net_device_ops sh_eth_netdev_ops_tsu = {
|
|
|
|
.ndo_open = sh_eth_open,
|
|
|
|
.ndo_stop = sh_eth_close,
|
|
|
|
.ndo_start_xmit = sh_eth_start_xmit,
|
|
|
|
.ndo_get_stats = sh_eth_get_stats,
|
|
|
|
.ndo_set_rx_mode = sh_eth_set_multicast_list,
|
|
|
|
.ndo_vlan_rx_add_vid = sh_eth_vlan_rx_add_vid,
|
|
|
|
.ndo_vlan_rx_kill_vid = sh_eth_vlan_rx_kill_vid,
|
|
|
|
.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;
|
2013-08-30 05:00:11 +00:00
|
|
|
struct sh_eth_plat_data *pd = dev_get_platdata(&pdev->dev);
|
2013-06-07 13:54:02 +00:00
|
|
|
const struct platform_device_id *id = platform_get_device_id(pdev);
|
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);
|
|
|
|
|
|
|
|
mdp = netdev_priv(ndev);
|
2012-06-26 20:00:03 +00:00
|
|
|
mdp->num_tx_ring = TX_RING_SIZE;
|
|
|
|
mdp->num_rx_ring = RX_RING_SIZE;
|
2013-03-21 10:41:11 +00:00
|
|
|
mdp->addr = devm_ioremap_resource(&pdev->dev, res);
|
|
|
|
if (IS_ERR(mdp->addr)) {
|
|
|
|
ret = PTR_ERR(mdp->addr);
|
2011-09-27 21:48:58 +00:00
|
|
|
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
|
|
|
|
|
|
|
/* 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;
|
2008-06-09 23:33:56 +00:00
|
|
|
|
2009-05-24 23:54:21 +00:00
|
|
|
/* set cpu data */
|
2013-06-07 14:05:59 +00:00
|
|
|
mdp->cd = (struct sh_eth_cpu_data *)id->driver_data;
|
2013-08-17 23:11:28 +00:00
|
|
|
mdp->reg_offset = sh_eth_get_register_offset(mdp->cd->register_type);
|
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 */
|
2013-06-12 20:55:34 +00:00
|
|
|
if (mdp->cd->tsu)
|
|
|
|
ndev->netdev_ops = &sh_eth_netdev_ops_tsu;
|
|
|
|
else
|
|
|
|
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
|
|
|
|
|
|
|
/* read and set MAC address */
|
2009-10-09 00:17:14 +00:00
|
|
|
read_mac_address(ndev, pd->mac_addr);
|
2013-04-29 09:49:42 +00:00
|
|
|
if (!is_valid_ether_addr(ndev->dev_addr)) {
|
|
|
|
dev_warn(&pdev->dev,
|
|
|
|
"no valid MAC address supplied, using a random one.\n");
|
|
|
|
eth_hw_addr_random(ndev);
|
|
|
|
}
|
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);
|
2013-03-21 10:41:11 +00:00
|
|
|
mdp->tsu_addr = devm_ioremap_resource(&pdev->dev, rtsu);
|
|
|
|
if (IS_ERR(mdp->tsu_addr)) {
|
|
|
|
ret = PTR_ERR(mdp->tsu_addr);
|
2013-03-19 13:41:32 +00:00
|
|
|
goto out_release;
|
|
|
|
}
|
2012-02-15 17:55:03 +00:00
|
|
|
mdp->port = devno % 2;
|
2013-04-19 02:04:27 +00:00
|
|
|
ndev->features = NETIF_F_HW_VLAN_CTAG_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
|
|
|
}
|
|
|
|
|
2013-06-19 19:30:23 +00:00
|
|
|
netif_napi_add(ndev, &mdp->napi, sh_eth_poll, 64);
|
|
|
|
|
2008-06-09 23:33:56 +00:00
|
|
|
/* network device register */
|
|
|
|
ret = register_netdev(ndev);
|
|
|
|
if (ret)
|
2013-06-19 19:30:23 +00:00
|
|
|
goto out_napi_del;
|
2008-06-09 23:33:56 +00:00
|
|
|
|
|
|
|
/* 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);
|
|
|
|
|
2013-06-19 19:30:23 +00:00
|
|
|
out_napi_del:
|
|
|
|
netif_napi_del(&mdp->napi);
|
|
|
|
|
2008-06-09 23:33:56 +00:00
|
|
|
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);
|
2013-06-19 19:30:23 +00:00
|
|
|
struct sh_eth_private *mdp = netdev_priv(ndev);
|
2008-06-09 23:33:56 +00:00
|
|
|
|
|
|
|
sh_mdio_release(ndev);
|
|
|
|
unregister_netdev(ndev);
|
2013-06-19 19:30:23 +00:00
|
|
|
netif_napi_del(&mdp->napi);
|
2009-10-09 00:20:04 +00:00
|
|
|
pm_runtime_disable(&pdev->dev);
|
2008-06-09 23:33:56 +00:00
|
|
|
free_netdev(ndev);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-06-06 09:52:37 +00:00
|
|
|
#ifdef CONFIG_PM
|
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;
|
|
|
|
}
|
|
|
|
|
2013-06-06 09:52:37 +00:00
|
|
|
static const struct dev_pm_ops sh_eth_dev_pm_ops = {
|
2009-10-09 00:20:04 +00:00
|
|
|
.runtime_suspend = sh_eth_runtime_nop,
|
|
|
|
.runtime_resume = sh_eth_runtime_nop,
|
|
|
|
};
|
2013-06-06 09:52:37 +00:00
|
|
|
#define SH_ETH_PM_OPS (&sh_eth_dev_pm_ops)
|
|
|
|
#else
|
|
|
|
#define SH_ETH_PM_OPS NULL
|
|
|
|
#endif
|
2009-10-09 00:20:04 +00:00
|
|
|
|
2013-06-07 13:54:02 +00:00
|
|
|
static struct platform_device_id sh_eth_id_table[] = {
|
2013-06-07 13:56:05 +00:00
|
|
|
{ "sh7619-ether", (kernel_ulong_t)&sh7619_data },
|
2013-06-07 13:55:08 +00:00
|
|
|
{ "sh771x-ether", (kernel_ulong_t)&sh771x_data },
|
2013-06-07 14:03:37 +00:00
|
|
|
{ "sh7724-ether", (kernel_ulong_t)&sh7724_data },
|
2013-06-07 13:58:18 +00:00
|
|
|
{ "sh7734-gether", (kernel_ulong_t)&sh7734_data },
|
2013-06-07 13:59:21 +00:00
|
|
|
{ "sh7757-ether", (kernel_ulong_t)&sh7757_data },
|
|
|
|
{ "sh7757-gether", (kernel_ulong_t)&sh7757_data_giga },
|
2013-06-07 13:58:18 +00:00
|
|
|
{ "sh7763-gether", (kernel_ulong_t)&sh7763_data },
|
2013-06-07 13:57:12 +00:00
|
|
|
{ "r8a7740-gether", (kernel_ulong_t)&r8a7740_data },
|
2013-06-07 14:05:59 +00:00
|
|
|
{ "r8a777x-ether", (kernel_ulong_t)&r8a777x_data },
|
2013-07-23 01:18:05 +00:00
|
|
|
{ "r8a7790-ether", (kernel_ulong_t)&r8a7790_data },
|
2013-06-07 13:54:02 +00:00
|
|
|
{ }
|
|
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(platform, sh_eth_id_table);
|
|
|
|
|
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,
|
2013-06-07 13:54:02 +00:00
|
|
|
.id_table = sh_eth_id_table,
|
2008-06-09 23:33:56 +00:00
|
|
|
.driver = {
|
|
|
|
.name = CARDNAME,
|
2013-06-06 09:52:37 +00:00
|
|
|
.pm = SH_ETH_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");
|