2005-08-31 16:53:10 +00:00
|
|
|
/*
|
|
|
|
* ASIX AX8817X based USB 2.0 Ethernet Devices
|
2006-07-29 14:12:50 +00:00
|
|
|
* Copyright (C) 2003-2006 David Hollis <dhollis@davehollis.com>
|
2005-08-31 16:53:10 +00:00
|
|
|
* Copyright (C) 2005 Phil Chang <pchang23@sbcglobal.net>
|
2006-07-29 14:12:50 +00:00
|
|
|
* Copyright (C) 2006 James Painter <jamie.painter@iname.com>
|
2005-08-31 16:53:10 +00:00
|
|
|
* Copyright (c) 2002-2003 TiVo Inc.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
|
|
*/
|
|
|
|
|
|
|
|
// #define DEBUG // error path messages, extra info
|
|
|
|
// #define VERBOSE // more; success messages
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/kmod.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/netdevice.h>
|
|
|
|
#include <linux/etherdevice.h>
|
|
|
|
#include <linux/ethtool.h>
|
|
|
|
#include <linux/workqueue.h>
|
|
|
|
#include <linux/mii.h>
|
|
|
|
#include <linux/usb.h>
|
|
|
|
#include <linux/crc32.h>
|
2008-01-25 22:51:45 +00:00
|
|
|
#include <linux/usb/usbnet.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>
|
2005-08-31 16:53:10 +00:00
|
|
|
|
2011-10-04 09:55:16 +00:00
|
|
|
#define DRIVER_VERSION "26-Sep-2011"
|
2011-10-04 09:55:18 +00:00
|
|
|
#define DRIVER_NAME "asix"
|
2006-07-29 14:12:50 +00:00
|
|
|
|
2005-08-31 16:53:10 +00:00
|
|
|
/* ASIX AX8817X based USB 2.0 Ethernet Devices */
|
|
|
|
|
|
|
|
#define AX_CMD_SET_SW_MII 0x06
|
|
|
|
#define AX_CMD_READ_MII_REG 0x07
|
|
|
|
#define AX_CMD_WRITE_MII_REG 0x08
|
|
|
|
#define AX_CMD_SET_HW_MII 0x0a
|
|
|
|
#define AX_CMD_READ_EEPROM 0x0b
|
|
|
|
#define AX_CMD_WRITE_EEPROM 0x0c
|
|
|
|
#define AX_CMD_WRITE_ENABLE 0x0d
|
|
|
|
#define AX_CMD_WRITE_DISABLE 0x0e
|
2006-07-29 14:12:50 +00:00
|
|
|
#define AX_CMD_READ_RX_CTL 0x0f
|
2005-08-31 16:53:10 +00:00
|
|
|
#define AX_CMD_WRITE_RX_CTL 0x10
|
|
|
|
#define AX_CMD_READ_IPG012 0x11
|
|
|
|
#define AX_CMD_WRITE_IPG0 0x12
|
|
|
|
#define AX_CMD_WRITE_IPG1 0x13
|
2006-07-29 14:12:50 +00:00
|
|
|
#define AX_CMD_READ_NODE_ID 0x13
|
2010-03-09 12:24:38 +00:00
|
|
|
#define AX_CMD_WRITE_NODE_ID 0x14
|
2005-08-31 16:53:10 +00:00
|
|
|
#define AX_CMD_WRITE_IPG2 0x14
|
|
|
|
#define AX_CMD_WRITE_MULTI_FILTER 0x16
|
2006-07-29 14:12:50 +00:00
|
|
|
#define AX88172_CMD_READ_NODE_ID 0x17
|
2005-08-31 16:53:10 +00:00
|
|
|
#define AX_CMD_READ_PHY_ID 0x19
|
|
|
|
#define AX_CMD_READ_MEDIUM_STATUS 0x1a
|
|
|
|
#define AX_CMD_WRITE_MEDIUM_MODE 0x1b
|
|
|
|
#define AX_CMD_READ_MONITOR_MODE 0x1c
|
|
|
|
#define AX_CMD_WRITE_MONITOR_MODE 0x1d
|
2006-07-29 14:12:50 +00:00
|
|
|
#define AX_CMD_READ_GPIOS 0x1e
|
2005-08-31 16:53:10 +00:00
|
|
|
#define AX_CMD_WRITE_GPIOS 0x1f
|
|
|
|
#define AX_CMD_SW_RESET 0x20
|
|
|
|
#define AX_CMD_SW_PHY_STATUS 0x21
|
|
|
|
#define AX_CMD_SW_PHY_SELECT 0x22
|
|
|
|
|
|
|
|
#define AX_MONITOR_MODE 0x01
|
|
|
|
#define AX_MONITOR_LINK 0x02
|
|
|
|
#define AX_MONITOR_MAGIC 0x04
|
|
|
|
#define AX_MONITOR_HSFS 0x10
|
|
|
|
|
|
|
|
/* AX88172 Medium Status Register values */
|
2006-07-29 14:12:50 +00:00
|
|
|
#define AX88172_MEDIUM_FD 0x02
|
|
|
|
#define AX88172_MEDIUM_TX 0x04
|
|
|
|
#define AX88172_MEDIUM_FC 0x10
|
|
|
|
#define AX88172_MEDIUM_DEFAULT \
|
|
|
|
( AX88172_MEDIUM_FD | AX88172_MEDIUM_TX | AX88172_MEDIUM_FC )
|
2005-08-31 16:53:10 +00:00
|
|
|
|
|
|
|
#define AX_MCAST_FILTER_SIZE 8
|
|
|
|
#define AX_MAX_MCAST 64
|
|
|
|
|
|
|
|
#define AX_SWRESET_CLEAR 0x00
|
|
|
|
#define AX_SWRESET_RR 0x01
|
|
|
|
#define AX_SWRESET_RT 0x02
|
|
|
|
#define AX_SWRESET_PRTE 0x04
|
|
|
|
#define AX_SWRESET_PRL 0x08
|
|
|
|
#define AX_SWRESET_BZ 0x10
|
|
|
|
#define AX_SWRESET_IPRL 0x20
|
|
|
|
#define AX_SWRESET_IPPD 0x40
|
|
|
|
|
|
|
|
#define AX88772_IPG0_DEFAULT 0x15
|
|
|
|
#define AX88772_IPG1_DEFAULT 0x0c
|
|
|
|
#define AX88772_IPG2_DEFAULT 0x12
|
|
|
|
|
2006-07-29 14:12:50 +00:00
|
|
|
/* AX88772 & AX88178 Medium Mode Register */
|
|
|
|
#define AX_MEDIUM_PF 0x0080
|
|
|
|
#define AX_MEDIUM_JFE 0x0040
|
|
|
|
#define AX_MEDIUM_TFC 0x0020
|
|
|
|
#define AX_MEDIUM_RFC 0x0010
|
|
|
|
#define AX_MEDIUM_ENCK 0x0008
|
|
|
|
#define AX_MEDIUM_AC 0x0004
|
|
|
|
#define AX_MEDIUM_FD 0x0002
|
|
|
|
#define AX_MEDIUM_GM 0x0001
|
|
|
|
#define AX_MEDIUM_SM 0x1000
|
|
|
|
#define AX_MEDIUM_SBP 0x0800
|
|
|
|
#define AX_MEDIUM_PS 0x0200
|
|
|
|
#define AX_MEDIUM_RE 0x0100
|
|
|
|
|
|
|
|
#define AX88178_MEDIUM_DEFAULT \
|
|
|
|
(AX_MEDIUM_PS | AX_MEDIUM_FD | AX_MEDIUM_AC | \
|
|
|
|
AX_MEDIUM_RFC | AX_MEDIUM_TFC | AX_MEDIUM_JFE | \
|
2011-10-04 09:55:18 +00:00
|
|
|
AX_MEDIUM_RE)
|
2005-08-31 16:53:10 +00:00
|
|
|
|
2006-07-29 14:12:50 +00:00
|
|
|
#define AX88772_MEDIUM_DEFAULT \
|
|
|
|
(AX_MEDIUM_FD | AX_MEDIUM_RFC | \
|
|
|
|
AX_MEDIUM_TFC | AX_MEDIUM_PS | \
|
2011-10-04 09:55:18 +00:00
|
|
|
AX_MEDIUM_AC | AX_MEDIUM_RE)
|
2006-07-29 14:12:50 +00:00
|
|
|
|
|
|
|
/* AX88772 & AX88178 RX_CTL values */
|
2011-10-04 09:55:18 +00:00
|
|
|
#define AX_RX_CTL_SO 0x0080
|
|
|
|
#define AX_RX_CTL_AP 0x0020
|
|
|
|
#define AX_RX_CTL_AM 0x0010
|
|
|
|
#define AX_RX_CTL_AB 0x0008
|
|
|
|
#define AX_RX_CTL_SEP 0x0004
|
|
|
|
#define AX_RX_CTL_AMALL 0x0002
|
|
|
|
#define AX_RX_CTL_PRO 0x0001
|
|
|
|
#define AX_RX_CTL_MFB_2048 0x0000
|
|
|
|
#define AX_RX_CTL_MFB_4096 0x0100
|
|
|
|
#define AX_RX_CTL_MFB_8192 0x0200
|
|
|
|
#define AX_RX_CTL_MFB_16384 0x0300
|
|
|
|
|
|
|
|
#define AX_DEFAULT_RX_CTL (AX_RX_CTL_SO | AX_RX_CTL_AB)
|
2006-07-29 14:12:50 +00:00
|
|
|
|
|
|
|
/* GPIO 0 .. 2 toggles */
|
|
|
|
#define AX_GPIO_GPO0EN 0x01 /* GPIO0 Output enable */
|
|
|
|
#define AX_GPIO_GPO_0 0x02 /* GPIO0 Output value */
|
|
|
|
#define AX_GPIO_GPO1EN 0x04 /* GPIO1 Output enable */
|
|
|
|
#define AX_GPIO_GPO_1 0x08 /* GPIO1 Output value */
|
|
|
|
#define AX_GPIO_GPO2EN 0x10 /* GPIO2 Output enable */
|
|
|
|
#define AX_GPIO_GPO_2 0x20 /* GPIO2 Output value */
|
|
|
|
#define AX_GPIO_RESERVED 0x40 /* Reserved */
|
|
|
|
#define AX_GPIO_RSE 0x80 /* Reload serial EEPROM */
|
|
|
|
|
|
|
|
#define AX_EEPROM_MAGIC 0xdeadbeef
|
|
|
|
#define AX88172_EEPROM_LEN 0x40
|
|
|
|
#define AX88772_EEPROM_LEN 0xff
|
|
|
|
|
|
|
|
#define PHY_MODE_MARVELL 0x0000
|
|
|
|
#define MII_MARVELL_LED_CTRL 0x0018
|
|
|
|
#define MII_MARVELL_STATUS 0x001b
|
|
|
|
#define MII_MARVELL_CTRL 0x0014
|
|
|
|
|
|
|
|
#define MARVELL_LED_MANUAL 0x0019
|
|
|
|
|
|
|
|
#define MARVELL_STATUS_HWCFG 0x0004
|
|
|
|
|
|
|
|
#define MARVELL_CTRL_TXDELAY 0x0002
|
|
|
|
#define MARVELL_CTRL_RXDELAY 0x0080
|
2005-08-31 16:53:10 +00:00
|
|
|
|
2011-11-15 07:12:39 +00:00
|
|
|
#define PHY_MODE_RTL8211CL 0x000C
|
2011-10-04 09:55:17 +00:00
|
|
|
|
2005-08-31 16:53:10 +00:00
|
|
|
/* This structure cannot exceed sizeof(unsigned long [5]) AKA 20 bytes */
|
2006-03-29 01:15:42 +00:00
|
|
|
struct asix_data {
|
2005-08-31 16:53:10 +00:00
|
|
|
u8 multi_filter[AX_MCAST_FILTER_SIZE];
|
2010-03-09 12:24:38 +00:00
|
|
|
u8 mac_addr[ETH_ALEN];
|
2006-07-29 14:12:50 +00:00
|
|
|
u8 phymode;
|
|
|
|
u8 ledmode;
|
|
|
|
u8 eeprom_len;
|
2005-08-31 16:53:10 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct ax88172_int_data {
|
2007-12-22 17:42:36 +00:00
|
|
|
__le16 res1;
|
2005-08-31 16:53:10 +00:00
|
|
|
u8 link;
|
2007-12-22 17:42:36 +00:00
|
|
|
__le16 res2;
|
2005-08-31 16:53:10 +00:00
|
|
|
u8 status;
|
2007-12-22 17:42:36 +00:00
|
|
|
__le16 res3;
|
2010-06-02 18:10:09 +00:00
|
|
|
} __packed;
|
2005-08-31 16:53:10 +00:00
|
|
|
|
2006-03-29 01:15:42 +00:00
|
|
|
static int asix_read_cmd(struct usbnet *dev, u8 cmd, u16 value, u16 index,
|
2005-08-31 16:53:10 +00:00
|
|
|
u16 size, void *data)
|
|
|
|
{
|
2007-12-22 17:42:36 +00:00
|
|
|
void *buf;
|
|
|
|
int err = -ENOMEM;
|
|
|
|
|
2010-02-17 10:30:23 +00:00
|
|
|
netdev_dbg(dev->net, "asix_read_cmd() cmd=0x%02x value=0x%04x index=0x%04x size=%d\n",
|
|
|
|
cmd, value, index, size);
|
2007-12-22 17:42:36 +00:00
|
|
|
|
|
|
|
buf = kmalloc(size, GFP_KERNEL);
|
|
|
|
if (!buf)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
err = usb_control_msg(
|
2005-08-31 16:53:10 +00:00
|
|
|
dev->udev,
|
|
|
|
usb_rcvctrlpipe(dev->udev, 0),
|
|
|
|
cmd,
|
|
|
|
USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
|
|
|
|
value,
|
|
|
|
index,
|
2007-12-22 17:42:36 +00:00
|
|
|
buf,
|
2005-08-31 16:53:10 +00:00
|
|
|
size,
|
|
|
|
USB_CTRL_GET_TIMEOUT);
|
2008-01-10 04:32:07 +00:00
|
|
|
if (err == size)
|
2007-12-22 17:42:36 +00:00
|
|
|
memcpy(data, buf, size);
|
2008-01-10 04:32:07 +00:00
|
|
|
else if (err >= 0)
|
|
|
|
err = -EINVAL;
|
2007-12-22 17:42:36 +00:00
|
|
|
kfree(buf);
|
|
|
|
|
|
|
|
out:
|
|
|
|
return err;
|
2005-08-31 16:53:10 +00:00
|
|
|
}
|
|
|
|
|
2006-03-29 01:15:42 +00:00
|
|
|
static int asix_write_cmd(struct usbnet *dev, u8 cmd, u16 value, u16 index,
|
2005-08-31 16:53:10 +00:00
|
|
|
u16 size, void *data)
|
|
|
|
{
|
2007-12-22 17:42:36 +00:00
|
|
|
void *buf = NULL;
|
|
|
|
int err = -ENOMEM;
|
|
|
|
|
2010-02-17 10:30:23 +00:00
|
|
|
netdev_dbg(dev->net, "asix_write_cmd() cmd=0x%02x value=0x%04x index=0x%04x size=%d\n",
|
|
|
|
cmd, value, index, size);
|
2007-12-22 17:42:36 +00:00
|
|
|
|
|
|
|
if (data) {
|
2010-05-15 11:20:45 +00:00
|
|
|
buf = kmemdup(data, size, GFP_KERNEL);
|
2007-12-22 17:42:36 +00:00
|
|
|
if (!buf)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
err = usb_control_msg(
|
2005-08-31 16:53:10 +00:00
|
|
|
dev->udev,
|
|
|
|
usb_sndctrlpipe(dev->udev, 0),
|
|
|
|
cmd,
|
|
|
|
USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
|
|
|
|
value,
|
|
|
|
index,
|
2007-12-22 17:42:36 +00:00
|
|
|
buf,
|
2005-08-31 16:53:10 +00:00
|
|
|
size,
|
|
|
|
USB_CTRL_SET_TIMEOUT);
|
2007-12-22 17:42:36 +00:00
|
|
|
kfree(buf);
|
|
|
|
|
|
|
|
out:
|
|
|
|
return err;
|
2005-08-31 16:53:10 +00:00
|
|
|
}
|
|
|
|
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 13:55:46 +00:00
|
|
|
static void asix_async_cmd_callback(struct urb *urb)
|
2005-08-31 16:53:10 +00:00
|
|
|
{
|
|
|
|
struct usb_ctrlrequest *req = (struct usb_ctrlrequest *)urb->context;
|
2008-12-19 07:00:59 +00:00
|
|
|
int status = urb->status;
|
2005-08-31 16:53:10 +00:00
|
|
|
|
2008-12-19 07:00:59 +00:00
|
|
|
if (status < 0)
|
2006-03-29 01:15:42 +00:00
|
|
|
printk(KERN_DEBUG "asix_async_cmd_callback() failed with %d",
|
2008-12-19 07:00:59 +00:00
|
|
|
status);
|
2005-08-31 16:53:10 +00:00
|
|
|
|
|
|
|
kfree(req);
|
|
|
|
usb_free_urb(urb);
|
|
|
|
}
|
|
|
|
|
2006-07-29 14:12:50 +00:00
|
|
|
static void
|
|
|
|
asix_write_cmd_async(struct usbnet *dev, u8 cmd, u16 value, u16 index,
|
|
|
|
u16 size, void *data)
|
|
|
|
{
|
|
|
|
struct usb_ctrlrequest *req;
|
|
|
|
int status;
|
|
|
|
struct urb *urb;
|
|
|
|
|
2010-02-17 10:30:23 +00:00
|
|
|
netdev_dbg(dev->net, "asix_write_cmd_async() cmd=0x%02x value=0x%04x index=0x%04x size=%d\n",
|
|
|
|
cmd, value, index, size);
|
2011-10-04 09:55:18 +00:00
|
|
|
|
|
|
|
urb = usb_alloc_urb(0, GFP_ATOMIC);
|
|
|
|
if (!urb) {
|
2010-02-17 10:30:23 +00:00
|
|
|
netdev_err(dev->net, "Error allocating URB in write_cmd_async!\n");
|
2006-07-29 14:12:50 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2011-10-04 09:55:18 +00:00
|
|
|
req = kmalloc(sizeof(struct usb_ctrlrequest), GFP_ATOMIC);
|
|
|
|
if (!req) {
|
2010-02-17 10:30:23 +00:00
|
|
|
netdev_err(dev->net, "Failed to allocate memory for control request\n");
|
2006-07-29 14:12:50 +00:00
|
|
|
usb_free_urb(urb);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
req->bRequestType = USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE;
|
|
|
|
req->bRequest = cmd;
|
2006-11-23 11:45:31 +00:00
|
|
|
req->wValue = cpu_to_le16(value);
|
|
|
|
req->wIndex = cpu_to_le16(index);
|
|
|
|
req->wLength = cpu_to_le16(size);
|
2006-07-29 14:12:50 +00:00
|
|
|
|
|
|
|
usb_fill_control_urb(urb, dev->udev,
|
|
|
|
usb_sndctrlpipe(dev->udev, 0),
|
|
|
|
(void *)req, data, size,
|
|
|
|
asix_async_cmd_callback, req);
|
|
|
|
|
2011-10-04 09:55:18 +00:00
|
|
|
status = usb_submit_urb(urb, GFP_ATOMIC);
|
|
|
|
if (status < 0) {
|
2010-02-17 10:30:23 +00:00
|
|
|
netdev_err(dev->net, "Error submitting the control message: status=%d\n",
|
|
|
|
status);
|
2006-07-29 14:12:50 +00:00
|
|
|
kfree(req);
|
|
|
|
usb_free_urb(urb);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int asix_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
u8 *head;
|
|
|
|
u32 header;
|
|
|
|
char *packet;
|
|
|
|
struct sk_buff *ax_skb;
|
|
|
|
u16 size;
|
|
|
|
|
|
|
|
head = (u8 *) skb->data;
|
|
|
|
memcpy(&header, head, sizeof(header));
|
|
|
|
le32_to_cpus(&header);
|
|
|
|
packet = head + sizeof(header);
|
|
|
|
|
|
|
|
skb_pull(skb, 4);
|
|
|
|
|
|
|
|
while (skb->len > 0) {
|
2011-07-26 16:44:47 +00:00
|
|
|
if ((header & 0x07ff) != ((~header >> 16) & 0x07ff))
|
2010-02-17 10:30:23 +00:00
|
|
|
netdev_err(dev->net, "asix_rx_fixup() Bad Header Length\n");
|
2011-07-26 16:44:46 +00:00
|
|
|
|
2006-07-29 14:12:50 +00:00
|
|
|
/* get the packet length */
|
2011-07-26 16:44:47 +00:00
|
|
|
size = (u16) (header & 0x000007ff);
|
2006-07-29 14:12:50 +00:00
|
|
|
|
2010-05-18 00:18:28 +00:00
|
|
|
if ((skb->len) - ((size + 1) & 0xfffe) == 0) {
|
2010-05-25 23:24:03 +00:00
|
|
|
u8 alignment = (unsigned long)skb->data & 0x3;
|
2010-05-18 00:18:28 +00:00
|
|
|
if (alignment != 0x2) {
|
|
|
|
/*
|
|
|
|
* not 16bit aligned so use the room provided by
|
|
|
|
* the 32 bit header to align the data
|
|
|
|
*
|
|
|
|
* note we want 16bit alignment as MAC header is
|
|
|
|
* 14bytes thus ip header will be aligned on
|
|
|
|
* 32bit boundary so accessing ipheader elements
|
|
|
|
* using a cast to struct ip header wont cause
|
|
|
|
* an unaligned accesses.
|
|
|
|
*/
|
|
|
|
u8 realignment = (alignment + 2) & 0x3;
|
|
|
|
memmove(skb->data - realignment,
|
|
|
|
skb->data,
|
|
|
|
size);
|
|
|
|
skb->data -= realignment;
|
|
|
|
skb_set_tail_pointer(skb, size);
|
|
|
|
}
|
2006-07-29 14:12:50 +00:00
|
|
|
return 2;
|
2010-05-18 00:18:28 +00:00
|
|
|
}
|
|
|
|
|
2010-06-07 07:56:27 +00:00
|
|
|
if (size > dev->net->mtu + ETH_HLEN) {
|
2010-02-17 10:30:23 +00:00
|
|
|
netdev_err(dev->net, "asix_rx_fixup() Bad RX Length %d\n",
|
|
|
|
size);
|
2006-07-29 14:12:50 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
ax_skb = skb_clone(skb, GFP_ATOMIC);
|
|
|
|
if (ax_skb) {
|
2010-05-25 23:24:03 +00:00
|
|
|
u8 alignment = (unsigned long)packet & 0x3;
|
2006-07-29 14:12:50 +00:00
|
|
|
ax_skb->len = size;
|
2010-05-18 00:18:28 +00:00
|
|
|
|
|
|
|
if (alignment != 0x2) {
|
|
|
|
/*
|
|
|
|
* not 16bit aligned use the room provided by
|
|
|
|
* the 32 bit header to align the data
|
|
|
|
*/
|
|
|
|
u8 realignment = (alignment + 2) & 0x3;
|
|
|
|
memmove(packet - realignment, packet, size);
|
|
|
|
packet -= realignment;
|
|
|
|
}
|
2006-07-29 14:12:50 +00:00
|
|
|
ax_skb->data = packet;
|
2007-04-20 03:29:13 +00:00
|
|
|
skb_set_tail_pointer(ax_skb, size);
|
2006-07-29 14:12:50 +00:00
|
|
|
usbnet_skb_return(dev, ax_skb);
|
|
|
|
} else {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
skb_pull(skb, (size + 1) & 0xfffe);
|
|
|
|
|
|
|
|
if (skb->len == 0)
|
|
|
|
break;
|
|
|
|
|
|
|
|
head = (u8 *) skb->data;
|
|
|
|
memcpy(&header, head, sizeof(header));
|
|
|
|
le32_to_cpus(&header);
|
|
|
|
packet = head + sizeof(header);
|
|
|
|
skb_pull(skb, 4);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (skb->len < 0) {
|
2010-02-17 10:30:23 +00:00
|
|
|
netdev_err(dev->net, "asix_rx_fixup() Bad SKB Length %d\n",
|
|
|
|
skb->len);
|
2006-07-29 14:12:50 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct sk_buff *asix_tx_fixup(struct usbnet *dev, struct sk_buff *skb,
|
|
|
|
gfp_t flags)
|
|
|
|
{
|
|
|
|
int padlen;
|
|
|
|
int headroom = skb_headroom(skb);
|
|
|
|
int tailroom = skb_tailroom(skb);
|
|
|
|
u32 packet_len;
|
|
|
|
u32 padbytes = 0xffff0000;
|
|
|
|
|
|
|
|
padlen = ((skb->len + 4) % 512) ? 0 : 4;
|
|
|
|
|
2009-12-03 07:58:21 +00:00
|
|
|
if ((!skb_cloned(skb)) &&
|
|
|
|
((headroom + tailroom) >= (4 + padlen))) {
|
2006-07-29 14:12:50 +00:00
|
|
|
if ((headroom < 4) || (tailroom < padlen)) {
|
|
|
|
skb->data = memmove(skb->head + 4, skb->data, skb->len);
|
2007-04-20 03:29:13 +00:00
|
|
|
skb_set_tail_pointer(skb, skb->len);
|
2006-07-29 14:12:50 +00:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
struct sk_buff *skb2;
|
|
|
|
skb2 = skb_copy_expand(skb, 4, padlen, flags);
|
|
|
|
dev_kfree_skb_any(skb);
|
|
|
|
skb = skb2;
|
|
|
|
if (!skb)
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
skb_push(skb, 4);
|
|
|
|
packet_len = (((skb->len - 4) ^ 0x0000ffff) << 16) + (skb->len - 4);
|
2007-02-05 17:03:03 +00:00
|
|
|
cpu_to_le32s(&packet_len);
|
2007-03-31 14:55:19 +00:00
|
|
|
skb_copy_to_linear_data(skb, &packet_len, sizeof(packet_len));
|
2006-07-29 14:12:50 +00:00
|
|
|
|
|
|
|
if ((skb->len % 512) == 0) {
|
2007-02-05 17:03:03 +00:00
|
|
|
cpu_to_le32s(&padbytes);
|
2007-04-20 03:29:13 +00:00
|
|
|
memcpy(skb_tail_pointer(skb), &padbytes, sizeof(padbytes));
|
2006-07-29 14:12:50 +00:00
|
|
|
skb_put(skb, sizeof(padbytes));
|
|
|
|
}
|
|
|
|
return skb;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void asix_status(struct usbnet *dev, struct urb *urb)
|
|
|
|
{
|
|
|
|
struct ax88172_int_data *event;
|
|
|
|
int link;
|
|
|
|
|
|
|
|
if (urb->actual_length < 8)
|
|
|
|
return;
|
|
|
|
|
|
|
|
event = urb->transfer_buffer;
|
|
|
|
link = event->link & 0x01;
|
|
|
|
if (netif_carrier_ok(dev->net) != link) {
|
|
|
|
if (link) {
|
|
|
|
netif_carrier_on(dev->net);
|
|
|
|
usbnet_defer_kevent (dev, EVENT_LINK_RESET );
|
|
|
|
} else
|
|
|
|
netif_carrier_off(dev->net);
|
2010-02-17 10:30:23 +00:00
|
|
|
netdev_dbg(dev->net, "Link Status is: %d\n", link);
|
2006-07-29 14:12:50 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-03-29 01:15:42 +00:00
|
|
|
static inline int asix_set_sw_mii(struct usbnet *dev)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
ret = asix_write_cmd(dev, AX_CMD_SET_SW_MII, 0x0000, 0, 0, NULL);
|
|
|
|
if (ret < 0)
|
2010-02-17 10:30:23 +00:00
|
|
|
netdev_err(dev->net, "Failed to enable software MII access\n");
|
2006-03-29 01:15:42 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int asix_set_hw_mii(struct usbnet *dev)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
ret = asix_write_cmd(dev, AX_CMD_SET_HW_MII, 0x0000, 0, 0, NULL);
|
|
|
|
if (ret < 0)
|
2010-02-17 10:30:23 +00:00
|
|
|
netdev_err(dev->net, "Failed to enable hardware MII access\n");
|
2006-03-29 01:15:42 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2006-07-29 14:12:50 +00:00
|
|
|
static inline int asix_get_phy_addr(struct usbnet *dev)
|
2006-03-29 01:15:42 +00:00
|
|
|
{
|
2007-12-22 17:42:36 +00:00
|
|
|
u8 buf[2];
|
|
|
|
int ret = asix_read_cmd(dev, AX_CMD_READ_PHY_ID, 0, 0, 2, buf);
|
2006-03-29 01:15:42 +00:00
|
|
|
|
2010-02-17 10:30:23 +00:00
|
|
|
netdev_dbg(dev->net, "asix_get_phy_addr()\n");
|
2006-07-29 14:12:50 +00:00
|
|
|
|
2007-12-22 17:42:36 +00:00
|
|
|
if (ret < 0) {
|
2010-02-17 10:30:23 +00:00
|
|
|
netdev_err(dev->net, "Error reading PHYID register: %02x\n", ret);
|
2007-12-22 17:42:36 +00:00
|
|
|
goto out;
|
2006-03-29 01:15:42 +00:00
|
|
|
}
|
2010-02-17 10:30:23 +00:00
|
|
|
netdev_dbg(dev->net, "asix_get_phy_addr() returning 0x%04x\n",
|
|
|
|
*((__le16 *)buf));
|
2007-12-22 17:42:36 +00:00
|
|
|
ret = buf[1];
|
|
|
|
|
|
|
|
out:
|
2006-03-29 01:15:42 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int asix_sw_reset(struct usbnet *dev, u8 flags)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = asix_write_cmd(dev, AX_CMD_SW_RESET, flags, 0, 0, NULL);
|
|
|
|
if (ret < 0)
|
2010-02-17 10:30:23 +00:00
|
|
|
netdev_err(dev->net, "Failed to send software reset: %02x\n", ret);
|
2006-07-29 14:12:50 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2006-03-29 01:15:42 +00:00
|
|
|
|
2006-07-29 14:12:50 +00:00
|
|
|
static u16 asix_read_rx_ctl(struct usbnet *dev)
|
|
|
|
{
|
2007-12-22 17:42:36 +00:00
|
|
|
__le16 v;
|
|
|
|
int ret = asix_read_cmd(dev, AX_CMD_READ_RX_CTL, 0, 0, 2, &v);
|
2006-07-29 14:12:50 +00:00
|
|
|
|
2007-12-22 17:42:36 +00:00
|
|
|
if (ret < 0) {
|
2010-02-17 10:30:23 +00:00
|
|
|
netdev_err(dev->net, "Error reading RX_CTL register: %02x\n", ret);
|
2007-12-22 17:42:36 +00:00
|
|
|
goto out;
|
2006-07-29 14:12:50 +00:00
|
|
|
}
|
2007-12-22 17:42:36 +00:00
|
|
|
ret = le16_to_cpu(v);
|
|
|
|
out:
|
2006-03-29 01:15:42 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int asix_write_rx_ctl(struct usbnet *dev, u16 mode)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
2010-02-17 10:30:23 +00:00
|
|
|
netdev_dbg(dev->net, "asix_write_rx_ctl() - mode = 0x%04x\n", mode);
|
2006-03-29 01:15:42 +00:00
|
|
|
ret = asix_write_cmd(dev, AX_CMD_WRITE_RX_CTL, mode, 0, 0, NULL);
|
|
|
|
if (ret < 0)
|
2010-02-17 10:30:23 +00:00
|
|
|
netdev_err(dev->net, "Failed to write RX_CTL mode to 0x%04x: %02x\n",
|
|
|
|
mode, ret);
|
2006-03-29 01:15:42 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2006-07-29 14:12:50 +00:00
|
|
|
static u16 asix_read_medium_status(struct usbnet *dev)
|
2005-08-31 16:53:10 +00:00
|
|
|
{
|
2007-12-22 17:42:36 +00:00
|
|
|
__le16 v;
|
|
|
|
int ret = asix_read_cmd(dev, AX_CMD_READ_MEDIUM_STATUS, 0, 0, 2, &v);
|
2005-08-31 16:53:10 +00:00
|
|
|
|
2007-12-22 17:42:36 +00:00
|
|
|
if (ret < 0) {
|
2010-02-17 10:30:23 +00:00
|
|
|
netdev_err(dev->net, "Error reading Medium Status register: %02x\n",
|
|
|
|
ret);
|
2011-10-04 09:55:18 +00:00
|
|
|
return ret; /* TODO: callers not checking for error ret */
|
2005-08-31 16:53:10 +00:00
|
|
|
}
|
2011-10-04 09:55:18 +00:00
|
|
|
|
|
|
|
return le16_to_cpu(v);
|
|
|
|
|
2005-08-31 16:53:10 +00:00
|
|
|
}
|
|
|
|
|
2006-07-29 14:12:50 +00:00
|
|
|
static int asix_write_medium_mode(struct usbnet *dev, u16 mode)
|
2005-08-31 16:53:10 +00:00
|
|
|
{
|
2006-07-29 14:12:50 +00:00
|
|
|
int ret;
|
2005-08-31 16:53:10 +00:00
|
|
|
|
2010-02-17 10:30:23 +00:00
|
|
|
netdev_dbg(dev->net, "asix_write_medium_mode() - mode = 0x%04x\n", mode);
|
2006-07-29 14:12:50 +00:00
|
|
|
ret = asix_write_cmd(dev, AX_CMD_WRITE_MEDIUM_MODE, mode, 0, 0, NULL);
|
|
|
|
if (ret < 0)
|
2010-02-17 10:30:23 +00:00
|
|
|
netdev_err(dev->net, "Failed to write Medium Mode mode to 0x%04x: %02x\n",
|
|
|
|
mode, ret);
|
2005-08-31 16:53:10 +00:00
|
|
|
|
2006-07-29 14:12:50 +00:00
|
|
|
return ret;
|
|
|
|
}
|
2005-08-31 16:53:10 +00:00
|
|
|
|
2006-07-29 14:12:50 +00:00
|
|
|
static int asix_write_gpio(struct usbnet *dev, u16 value, int sleep)
|
|
|
|
{
|
|
|
|
int ret;
|
2005-08-31 16:53:10 +00:00
|
|
|
|
2010-02-17 10:30:23 +00:00
|
|
|
netdev_dbg(dev->net, "asix_write_gpio() - value = 0x%04x\n", value);
|
2006-07-29 14:12:50 +00:00
|
|
|
ret = asix_write_cmd(dev, AX_CMD_WRITE_GPIOS, value, 0, 0, NULL);
|
|
|
|
if (ret < 0)
|
2010-02-17 10:30:23 +00:00
|
|
|
netdev_err(dev->net, "Failed to write GPIO value 0x%04x: %02x\n",
|
|
|
|
value, ret);
|
2005-08-31 16:53:10 +00:00
|
|
|
|
2006-07-29 14:12:50 +00:00
|
|
|
if (sleep)
|
|
|
|
msleep(sleep);
|
|
|
|
|
|
|
|
return ret;
|
2005-08-31 16:53:10 +00:00
|
|
|
}
|
|
|
|
|
2006-07-29 14:12:50 +00:00
|
|
|
/*
|
|
|
|
* AX88772 & AX88178 have a 16-bit RX_CTL value
|
|
|
|
*/
|
2006-03-29 01:15:42 +00:00
|
|
|
static void asix_set_multicast(struct net_device *net)
|
2005-08-31 16:53:10 +00:00
|
|
|
{
|
|
|
|
struct usbnet *dev = netdev_priv(net);
|
2006-03-29 01:15:42 +00:00
|
|
|
struct asix_data *data = (struct asix_data *)&dev->data;
|
2006-07-29 14:12:50 +00:00
|
|
|
u16 rx_ctl = AX_DEFAULT_RX_CTL;
|
2005-08-31 16:53:10 +00:00
|
|
|
|
|
|
|
if (net->flags & IFF_PROMISC) {
|
2006-07-29 14:12:50 +00:00
|
|
|
rx_ctl |= AX_RX_CTL_PRO;
|
2009-12-03 07:58:21 +00:00
|
|
|
} else if (net->flags & IFF_ALLMULTI ||
|
2010-02-08 04:30:35 +00:00
|
|
|
netdev_mc_count(net) > AX_MAX_MCAST) {
|
2006-07-29 14:12:50 +00:00
|
|
|
rx_ctl |= AX_RX_CTL_AMALL;
|
2010-02-08 04:30:35 +00:00
|
|
|
} else if (netdev_mc_empty(net)) {
|
2005-08-31 16:53:10 +00:00
|
|
|
/* just broadcast and directed */
|
|
|
|
} else {
|
|
|
|
/* We use the 20 byte dev->data
|
|
|
|
* for our 8 byte filter buffer
|
|
|
|
* to avoid allocating memory that
|
|
|
|
* is tricky to free later */
|
2010-04-01 21:22:57 +00:00
|
|
|
struct netdev_hw_addr *ha;
|
2005-08-31 16:53:10 +00:00
|
|
|
u32 crc_bits;
|
|
|
|
|
|
|
|
memset(data->multi_filter, 0, AX_MCAST_FILTER_SIZE);
|
|
|
|
|
|
|
|
/* Build the multicast hash filter. */
|
2010-04-01 21:22:57 +00:00
|
|
|
netdev_for_each_mc_addr(ha, net) {
|
|
|
|
crc_bits = ether_crc(ETH_ALEN, ha->addr) >> 26;
|
2005-08-31 16:53:10 +00:00
|
|
|
data->multi_filter[crc_bits >> 3] |=
|
|
|
|
1 << (crc_bits & 7);
|
|
|
|
}
|
|
|
|
|
2006-03-29 01:15:42 +00:00
|
|
|
asix_write_cmd_async(dev, AX_CMD_WRITE_MULTI_FILTER, 0, 0,
|
2005-08-31 16:53:10 +00:00
|
|
|
AX_MCAST_FILTER_SIZE, data->multi_filter);
|
|
|
|
|
2006-07-29 14:12:50 +00:00
|
|
|
rx_ctl |= AX_RX_CTL_AM;
|
2005-08-31 16:53:10 +00:00
|
|
|
}
|
|
|
|
|
2006-03-29 01:15:42 +00:00
|
|
|
asix_write_cmd_async(dev, AX_CMD_WRITE_RX_CTL, rx_ctl, 0, 0, NULL);
|
2005-08-31 16:53:10 +00:00
|
|
|
}
|
|
|
|
|
2006-03-29 01:15:42 +00:00
|
|
|
static int asix_mdio_read(struct net_device *netdev, int phy_id, int loc)
|
2005-08-31 16:53:10 +00:00
|
|
|
{
|
|
|
|
struct usbnet *dev = netdev_priv(netdev);
|
2007-12-22 17:42:36 +00:00
|
|
|
__le16 res;
|
2005-08-31 16:53:10 +00:00
|
|
|
|
2006-10-08 22:08:02 +00:00
|
|
|
mutex_lock(&dev->phy_mutex);
|
2006-03-29 01:15:42 +00:00
|
|
|
asix_set_sw_mii(dev);
|
|
|
|
asix_read_cmd(dev, AX_CMD_READ_MII_REG, phy_id,
|
2007-12-22 17:42:36 +00:00
|
|
|
(__u16)loc, 2, &res);
|
2006-03-29 01:15:42 +00:00
|
|
|
asix_set_hw_mii(dev);
|
2006-10-08 22:08:02 +00:00
|
|
|
mutex_unlock(&dev->phy_mutex);
|
2005-08-31 16:53:10 +00:00
|
|
|
|
2010-02-17 10:30:23 +00:00
|
|
|
netdev_dbg(dev->net, "asix_mdio_read() phy_id=0x%02x, loc=0x%02x, returns=0x%04x\n",
|
|
|
|
phy_id, loc, le16_to_cpu(res));
|
2005-08-31 16:53:10 +00:00
|
|
|
|
2007-12-22 17:42:36 +00:00
|
|
|
return le16_to_cpu(res);
|
2005-08-31 16:53:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2006-03-29 01:15:42 +00:00
|
|
|
asix_mdio_write(struct net_device *netdev, int phy_id, int loc, int val)
|
2005-08-31 16:53:10 +00:00
|
|
|
{
|
|
|
|
struct usbnet *dev = netdev_priv(netdev);
|
2007-12-22 17:42:36 +00:00
|
|
|
__le16 res = cpu_to_le16(val);
|
2005-08-31 16:53:10 +00:00
|
|
|
|
2010-02-17 10:30:23 +00:00
|
|
|
netdev_dbg(dev->net, "asix_mdio_write() phy_id=0x%02x, loc=0x%02x, val=0x%04x\n",
|
|
|
|
phy_id, loc, val);
|
2006-10-08 22:08:02 +00:00
|
|
|
mutex_lock(&dev->phy_mutex);
|
2006-03-29 01:15:42 +00:00
|
|
|
asix_set_sw_mii(dev);
|
2007-12-22 17:42:36 +00:00
|
|
|
asix_write_cmd(dev, AX_CMD_WRITE_MII_REG, phy_id, (__u16)loc, 2, &res);
|
2006-03-29 01:15:42 +00:00
|
|
|
asix_set_hw_mii(dev);
|
2006-10-08 22:08:02 +00:00
|
|
|
mutex_unlock(&dev->phy_mutex);
|
2005-08-31 16:53:10 +00:00
|
|
|
}
|
|
|
|
|
2006-07-29 14:12:50 +00:00
|
|
|
/* Get the PHY Identifier from the PHYSID1 & PHYSID2 MII registers */
|
|
|
|
static u32 asix_get_phyid(struct usbnet *dev)
|
2005-08-31 16:53:10 +00:00
|
|
|
{
|
2006-07-29 14:12:50 +00:00
|
|
|
int phy_reg;
|
|
|
|
u32 phy_id;
|
2011-11-15 07:12:40 +00:00
|
|
|
int i;
|
2005-08-31 16:53:10 +00:00
|
|
|
|
2011-11-15 07:12:40 +00:00
|
|
|
/* Poll for the rare case the FW or phy isn't ready yet. */
|
|
|
|
for (i = 0; i < 100; i++) {
|
|
|
|
phy_reg = asix_mdio_read(dev->net, dev->mii.phy_id, MII_PHYSID1);
|
|
|
|
if (phy_reg != 0 && phy_reg != 0xFFFF)
|
|
|
|
break;
|
|
|
|
mdelay(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (phy_reg <= 0 || phy_reg == 0xFFFF)
|
2006-07-29 14:12:50 +00:00
|
|
|
return 0;
|
2005-08-31 16:53:10 +00:00
|
|
|
|
2006-07-29 14:12:50 +00:00
|
|
|
phy_id = (phy_reg & 0xffff) << 16;
|
2005-08-31 16:53:10 +00:00
|
|
|
|
2006-07-29 14:12:50 +00:00
|
|
|
phy_reg = asix_mdio_read(dev->net, dev->mii.phy_id, MII_PHYSID2);
|
|
|
|
if (phy_reg < 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
phy_id |= (phy_reg & 0xffff);
|
|
|
|
|
|
|
|
return phy_id;
|
2005-08-31 16:53:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2006-03-29 01:15:42 +00:00
|
|
|
asix_get_wol(struct net_device *net, struct ethtool_wolinfo *wolinfo)
|
2005-08-31 16:53:10 +00:00
|
|
|
{
|
|
|
|
struct usbnet *dev = netdev_priv(net);
|
|
|
|
u8 opt;
|
|
|
|
|
2006-03-29 01:15:42 +00:00
|
|
|
if (asix_read_cmd(dev, AX_CMD_READ_MONITOR_MODE, 0, 0, 1, &opt) < 0) {
|
2005-08-31 16:53:10 +00:00
|
|
|
wolinfo->supported = 0;
|
|
|
|
wolinfo->wolopts = 0;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
wolinfo->supported = WAKE_PHY | WAKE_MAGIC;
|
|
|
|
wolinfo->wolopts = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2006-03-29 01:15:42 +00:00
|
|
|
asix_set_wol(struct net_device *net, struct ethtool_wolinfo *wolinfo)
|
2005-08-31 16:53:10 +00:00
|
|
|
{
|
|
|
|
struct usbnet *dev = netdev_priv(net);
|
|
|
|
u8 opt = 0;
|
|
|
|
|
|
|
|
if (wolinfo->wolopts & WAKE_PHY)
|
|
|
|
opt |= AX_MONITOR_LINK;
|
|
|
|
if (wolinfo->wolopts & WAKE_MAGIC)
|
|
|
|
opt |= AX_MONITOR_MAGIC;
|
|
|
|
|
2006-03-29 01:15:42 +00:00
|
|
|
if (asix_write_cmd(dev, AX_CMD_WRITE_MONITOR_MODE,
|
2007-12-22 17:42:36 +00:00
|
|
|
opt, 0, 0, NULL) < 0)
|
2005-08-31 16:53:10 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-03-29 01:15:42 +00:00
|
|
|
static int asix_get_eeprom_len(struct net_device *net)
|
2005-08-31 16:53:10 +00:00
|
|
|
{
|
2006-07-29 14:12:50 +00:00
|
|
|
struct usbnet *dev = netdev_priv(net);
|
|
|
|
struct asix_data *data = (struct asix_data *)&dev->data;
|
|
|
|
|
|
|
|
return data->eeprom_len;
|
2005-08-31 16:53:10 +00:00
|
|
|
}
|
|
|
|
|
2006-03-29 01:15:42 +00:00
|
|
|
static int asix_get_eeprom(struct net_device *net,
|
2005-08-31 16:53:10 +00:00
|
|
|
struct ethtool_eeprom *eeprom, u8 *data)
|
|
|
|
{
|
|
|
|
struct usbnet *dev = netdev_priv(net);
|
2007-12-22 17:42:36 +00:00
|
|
|
__le16 *ebuf = (__le16 *)data;
|
2005-08-31 16:53:10 +00:00
|
|
|
int i;
|
|
|
|
|
|
|
|
/* Crude hack to ensure that we don't overwrite memory
|
|
|
|
* if an odd length is supplied
|
|
|
|
*/
|
|
|
|
if (eeprom->len % 2)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
eeprom->magic = AX_EEPROM_MAGIC;
|
|
|
|
|
|
|
|
/* ax8817x returns 2 bytes from eeprom on read */
|
|
|
|
for (i=0; i < eeprom->len / 2; i++) {
|
2006-03-29 01:15:42 +00:00
|
|
|
if (asix_read_cmd(dev, AX_CMD_READ_EEPROM,
|
2005-08-31 16:53:10 +00:00
|
|
|
eeprom->offset + i, 0, 2, &ebuf[i]) < 0)
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-03-29 01:15:42 +00:00
|
|
|
static void asix_get_drvinfo (struct net_device *net,
|
2005-08-31 16:53:10 +00:00
|
|
|
struct ethtool_drvinfo *info)
|
|
|
|
{
|
2006-07-29 14:12:50 +00:00
|
|
|
struct usbnet *dev = netdev_priv(net);
|
|
|
|
struct asix_data *data = (struct asix_data *)&dev->data;
|
|
|
|
|
2005-08-31 16:53:10 +00:00
|
|
|
/* Inherit standard device info */
|
|
|
|
usbnet_get_drvinfo(net, info);
|
2011-10-04 09:55:18 +00:00
|
|
|
strncpy (info->driver, DRIVER_NAME, sizeof info->driver);
|
2006-07-29 14:12:50 +00:00
|
|
|
strncpy (info->version, DRIVER_VERSION, sizeof info->version);
|
|
|
|
info->eedump_len = data->eeprom_len;
|
2005-08-31 16:53:10 +00:00
|
|
|
}
|
|
|
|
|
2006-07-29 14:12:50 +00:00
|
|
|
static u32 asix_get_link(struct net_device *net)
|
|
|
|
{
|
|
|
|
struct usbnet *dev = netdev_priv(net);
|
|
|
|
|
|
|
|
return mii_link_ok(&dev->mii);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int asix_ioctl (struct net_device *net, struct ifreq *rq, int cmd)
|
|
|
|
{
|
|
|
|
struct usbnet *dev = netdev_priv(net);
|
|
|
|
|
|
|
|
return generic_mii_ioctl(&dev->mii, if_mii(rq), cmd, NULL);
|
|
|
|
}
|
|
|
|
|
2010-03-09 12:24:38 +00:00
|
|
|
static int asix_set_mac_address(struct net_device *net, void *p)
|
|
|
|
{
|
|
|
|
struct usbnet *dev = netdev_priv(net);
|
|
|
|
struct asix_data *data = (struct asix_data *)&dev->data;
|
|
|
|
struct sockaddr *addr = p;
|
|
|
|
|
|
|
|
if (netif_running(net))
|
|
|
|
return -EBUSY;
|
|
|
|
if (!is_valid_ether_addr(addr->sa_data))
|
|
|
|
return -EADDRNOTAVAIL;
|
|
|
|
|
|
|
|
memcpy(net->dev_addr, addr->sa_data, ETH_ALEN);
|
|
|
|
|
|
|
|
/* We use the 20 byte dev->data
|
|
|
|
* for our 6 byte mac buffer
|
|
|
|
* to avoid allocating memory that
|
|
|
|
* is tricky to free later */
|
|
|
|
memcpy(data->mac_addr, addr->sa_data, ETH_ALEN);
|
|
|
|
asix_write_cmd_async(dev, AX_CMD_WRITE_NODE_ID, 0, 0, ETH_ALEN,
|
|
|
|
data->mac_addr);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-07-29 14:12:50 +00:00
|
|
|
/* We need to override some ethtool_ops so we require our
|
|
|
|
own structure so we don't interfere with other usbnet
|
|
|
|
devices that may be connected at the same time. */
|
2009-09-02 08:03:33 +00:00
|
|
|
static const struct ethtool_ops ax88172_ethtool_ops = {
|
2006-07-29 14:12:50 +00:00
|
|
|
.get_drvinfo = asix_get_drvinfo,
|
|
|
|
.get_link = asix_get_link,
|
|
|
|
.get_msglevel = usbnet_get_msglevel,
|
2005-08-31 16:53:10 +00:00
|
|
|
.set_msglevel = usbnet_set_msglevel,
|
2006-03-29 01:15:42 +00:00
|
|
|
.get_wol = asix_get_wol,
|
|
|
|
.set_wol = asix_set_wol,
|
|
|
|
.get_eeprom_len = asix_get_eeprom_len,
|
|
|
|
.get_eeprom = asix_get_eeprom,
|
2006-10-08 22:08:01 +00:00
|
|
|
.get_settings = usbnet_get_settings,
|
|
|
|
.set_settings = usbnet_set_settings,
|
|
|
|
.nway_reset = usbnet_nway_reset,
|
2005-08-31 16:53:10 +00:00
|
|
|
};
|
|
|
|
|
2006-07-29 14:12:50 +00:00
|
|
|
static void ax88172_set_multicast(struct net_device *net)
|
2005-08-31 16:53:10 +00:00
|
|
|
{
|
|
|
|
struct usbnet *dev = netdev_priv(net);
|
2006-07-29 14:12:50 +00:00
|
|
|
struct asix_data *data = (struct asix_data *)&dev->data;
|
|
|
|
u8 rx_ctl = 0x8c;
|
2005-08-31 16:53:10 +00:00
|
|
|
|
2006-07-29 14:12:50 +00:00
|
|
|
if (net->flags & IFF_PROMISC) {
|
|
|
|
rx_ctl |= 0x01;
|
2009-12-03 07:58:21 +00:00
|
|
|
} else if (net->flags & IFF_ALLMULTI ||
|
2010-02-08 04:30:35 +00:00
|
|
|
netdev_mc_count(net) > AX_MAX_MCAST) {
|
2006-07-29 14:12:50 +00:00
|
|
|
rx_ctl |= 0x02;
|
2010-02-08 04:30:35 +00:00
|
|
|
} else if (netdev_mc_empty(net)) {
|
2006-07-29 14:12:50 +00:00
|
|
|
/* just broadcast and directed */
|
|
|
|
} else {
|
|
|
|
/* We use the 20 byte dev->data
|
|
|
|
* for our 8 byte filter buffer
|
|
|
|
* to avoid allocating memory that
|
|
|
|
* is tricky to free later */
|
2010-04-01 21:22:57 +00:00
|
|
|
struct netdev_hw_addr *ha;
|
2006-07-29 14:12:50 +00:00
|
|
|
u32 crc_bits;
|
|
|
|
|
|
|
|
memset(data->multi_filter, 0, AX_MCAST_FILTER_SIZE);
|
|
|
|
|
|
|
|
/* Build the multicast hash filter. */
|
2010-04-01 21:22:57 +00:00
|
|
|
netdev_for_each_mc_addr(ha, net) {
|
|
|
|
crc_bits = ether_crc(ETH_ALEN, ha->addr) >> 26;
|
2006-07-29 14:12:50 +00:00
|
|
|
data->multi_filter[crc_bits >> 3] |=
|
|
|
|
1 << (crc_bits & 7);
|
|
|
|
}
|
|
|
|
|
|
|
|
asix_write_cmd_async(dev, AX_CMD_WRITE_MULTI_FILTER, 0, 0,
|
|
|
|
AX_MCAST_FILTER_SIZE, data->multi_filter);
|
|
|
|
|
|
|
|
rx_ctl |= 0x10;
|
|
|
|
}
|
|
|
|
|
|
|
|
asix_write_cmd_async(dev, AX_CMD_WRITE_RX_CTL, rx_ctl, 0, 0, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ax88172_link_reset(struct usbnet *dev)
|
|
|
|
{
|
|
|
|
u8 mode;
|
2011-04-27 18:32:38 +00:00
|
|
|
struct ethtool_cmd ecmd = { .cmd = ETHTOOL_GSET };
|
2006-07-29 14:12:50 +00:00
|
|
|
|
|
|
|
mii_check_media(&dev->mii, 1, 1);
|
|
|
|
mii_ethtool_gset(&dev->mii, &ecmd);
|
|
|
|
mode = AX88172_MEDIUM_DEFAULT;
|
|
|
|
|
|
|
|
if (ecmd.duplex != DUPLEX_FULL)
|
|
|
|
mode |= ~AX88172_MEDIUM_FD;
|
|
|
|
|
2011-04-27 18:32:38 +00:00
|
|
|
netdev_dbg(dev->net, "ax88172_link_reset() speed: %u duplex: %d setting mode to 0x%04x\n",
|
|
|
|
ethtool_cmd_speed(&ecmd), ecmd.duplex, mode);
|
2006-07-29 14:12:50 +00:00
|
|
|
|
|
|
|
asix_write_medium_mode(dev, mode);
|
|
|
|
|
|
|
|
return 0;
|
2005-08-31 16:53:10 +00:00
|
|
|
}
|
|
|
|
|
2009-03-20 19:35:55 +00:00
|
|
|
static const struct net_device_ops ax88172_netdev_ops = {
|
|
|
|
.ndo_open = usbnet_open,
|
|
|
|
.ndo_stop = usbnet_stop,
|
|
|
|
.ndo_start_xmit = usbnet_start_xmit,
|
|
|
|
.ndo_tx_timeout = usbnet_tx_timeout,
|
|
|
|
.ndo_change_mtu = usbnet_change_mtu,
|
|
|
|
.ndo_set_mac_address = eth_mac_addr,
|
|
|
|
.ndo_validate_addr = eth_validate_addr,
|
|
|
|
.ndo_do_ioctl = asix_ioctl,
|
2011-08-16 06:29:01 +00:00
|
|
|
.ndo_set_rx_mode = ax88172_set_multicast,
|
2009-03-20 19:35:55 +00:00
|
|
|
};
|
|
|
|
|
2006-03-29 01:15:42 +00:00
|
|
|
static int ax88172_bind(struct usbnet *dev, struct usb_interface *intf)
|
2005-08-31 16:53:10 +00:00
|
|
|
{
|
|
|
|
int ret = 0;
|
2007-12-22 17:42:36 +00:00
|
|
|
u8 buf[ETH_ALEN];
|
2005-08-31 16:53:10 +00:00
|
|
|
int i;
|
|
|
|
unsigned long gpio_bits = dev->driver_info->data;
|
2006-07-29 14:12:50 +00:00
|
|
|
struct asix_data *data = (struct asix_data *)&dev->data;
|
|
|
|
|
|
|
|
data->eeprom_len = AX88172_EEPROM_LEN;
|
2005-08-31 16:53:10 +00:00
|
|
|
|
|
|
|
usbnet_get_endpoints(dev,intf);
|
|
|
|
|
|
|
|
/* Toggle the GPIOs in a manufacturer/model specific way */
|
|
|
|
for (i = 2; i >= 0; i--) {
|
2011-10-04 09:55:18 +00:00
|
|
|
ret = asix_write_cmd(dev, AX_CMD_WRITE_GPIOS,
|
|
|
|
(gpio_bits >> (i * 8)) & 0xff, 0, 0, NULL);
|
|
|
|
if (ret < 0)
|
2007-12-22 17:42:36 +00:00
|
|
|
goto out;
|
2005-08-31 16:53:10 +00:00
|
|
|
msleep(5);
|
|
|
|
}
|
|
|
|
|
2011-10-04 09:55:18 +00:00
|
|
|
ret = asix_write_rx_ctl(dev, 0x80);
|
|
|
|
if (ret < 0)
|
2007-12-22 17:42:36 +00:00
|
|
|
goto out;
|
2005-08-31 16:53:10 +00:00
|
|
|
|
|
|
|
/* Get the MAC address */
|
2011-10-04 09:55:18 +00:00
|
|
|
ret = asix_read_cmd(dev, AX88172_CMD_READ_NODE_ID, 0, 0, ETH_ALEN, buf);
|
|
|
|
if (ret < 0) {
|
2005-08-31 16:53:10 +00:00
|
|
|
dbg("read AX_CMD_READ_NODE_ID failed: %d", ret);
|
2007-12-22 17:42:36 +00:00
|
|
|
goto out;
|
2005-08-31 16:53:10 +00:00
|
|
|
}
|
|
|
|
memcpy(dev->net->dev_addr, buf, ETH_ALEN);
|
|
|
|
|
|
|
|
/* Initialize MII structure */
|
|
|
|
dev->mii.dev = dev->net;
|
2006-03-29 01:15:42 +00:00
|
|
|
dev->mii.mdio_read = asix_mdio_read;
|
|
|
|
dev->mii.mdio_write = asix_mdio_write;
|
2005-08-31 16:53:10 +00:00
|
|
|
dev->mii.phy_id_mask = 0x3f;
|
|
|
|
dev->mii.reg_num_mask = 0x1f;
|
2006-07-29 14:12:50 +00:00
|
|
|
dev->mii.phy_id = asix_get_phy_addr(dev);
|
2005-08-31 16:53:10 +00:00
|
|
|
|
2009-03-20 19:35:55 +00:00
|
|
|
dev->net->netdev_ops = &ax88172_netdev_ops;
|
2006-03-29 01:15:42 +00:00
|
|
|
dev->net->ethtool_ops = &ax88172_ethtool_ops;
|
2005-08-31 16:53:10 +00:00
|
|
|
|
2006-07-29 14:12:50 +00:00
|
|
|
asix_mdio_write(dev->net, dev->mii.phy_id, MII_BMCR, BMCR_RESET);
|
|
|
|
asix_mdio_write(dev->net, dev->mii.phy_id, MII_ADVERTISE,
|
2005-08-31 16:53:10 +00:00
|
|
|
ADVERTISE_ALL | ADVERTISE_CSMA | ADVERTISE_PAUSE_CAP);
|
|
|
|
mii_nway_restart(&dev->mii);
|
|
|
|
|
|
|
|
return 0;
|
2007-12-22 17:42:36 +00:00
|
|
|
|
|
|
|
out:
|
2005-08-31 16:53:10 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-09-02 08:03:33 +00:00
|
|
|
static const struct ethtool_ops ax88772_ethtool_ops = {
|
2006-03-29 01:15:42 +00:00
|
|
|
.get_drvinfo = asix_get_drvinfo,
|
2006-07-29 14:12:50 +00:00
|
|
|
.get_link = asix_get_link,
|
2005-08-31 16:53:10 +00:00
|
|
|
.get_msglevel = usbnet_get_msglevel,
|
|
|
|
.set_msglevel = usbnet_set_msglevel,
|
2006-03-29 01:15:42 +00:00
|
|
|
.get_wol = asix_get_wol,
|
|
|
|
.set_wol = asix_set_wol,
|
|
|
|
.get_eeprom_len = asix_get_eeprom_len,
|
|
|
|
.get_eeprom = asix_get_eeprom,
|
2006-10-08 22:08:01 +00:00
|
|
|
.get_settings = usbnet_get_settings,
|
|
|
|
.set_settings = usbnet_set_settings,
|
|
|
|
.nway_reset = usbnet_nway_reset,
|
2005-08-31 16:53:10 +00:00
|
|
|
};
|
|
|
|
|
2006-07-29 14:12:50 +00:00
|
|
|
static int ax88772_link_reset(struct usbnet *dev)
|
|
|
|
{
|
|
|
|
u16 mode;
|
2011-04-27 18:32:38 +00:00
|
|
|
struct ethtool_cmd ecmd = { .cmd = ETHTOOL_GSET };
|
2006-07-29 14:12:50 +00:00
|
|
|
|
|
|
|
mii_check_media(&dev->mii, 1, 1);
|
|
|
|
mii_ethtool_gset(&dev->mii, &ecmd);
|
|
|
|
mode = AX88772_MEDIUM_DEFAULT;
|
|
|
|
|
2011-04-27 18:32:38 +00:00
|
|
|
if (ethtool_cmd_speed(&ecmd) != SPEED_100)
|
2006-07-29 14:12:50 +00:00
|
|
|
mode &= ~AX_MEDIUM_PS;
|
|
|
|
|
|
|
|
if (ecmd.duplex != DUPLEX_FULL)
|
|
|
|
mode &= ~AX_MEDIUM_FD;
|
|
|
|
|
2011-04-27 18:32:38 +00:00
|
|
|
netdev_dbg(dev->net, "ax88772_link_reset() speed: %u duplex: %d setting mode to 0x%04x\n",
|
|
|
|
ethtool_cmd_speed(&ecmd), ecmd.duplex, mode);
|
2006-07-29 14:12:50 +00:00
|
|
|
|
|
|
|
asix_write_medium_mode(dev, mode);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-10-04 09:55:16 +00:00
|
|
|
static int ax88772_reset(struct usbnet *dev)
|
2005-08-31 16:53:10 +00:00
|
|
|
{
|
2007-01-11 23:39:16 +00:00
|
|
|
int ret, embd_phy;
|
2006-07-29 14:12:50 +00:00
|
|
|
u16 rx_ctl;
|
2005-08-31 16:53:10 +00:00
|
|
|
|
2011-10-04 09:55:18 +00:00
|
|
|
ret = asix_write_gpio(dev,
|
|
|
|
AX_GPIO_RSE | AX_GPIO_GPO_2 | AX_GPIO_GPO2EN, 5);
|
|
|
|
if (ret < 0)
|
2007-12-22 17:42:36 +00:00
|
|
|
goto out;
|
2005-08-31 16:53:10 +00:00
|
|
|
|
2007-01-11 23:39:16 +00:00
|
|
|
embd_phy = ((asix_get_phy_addr(dev) & 0x1f) == 0x10 ? 1 : 0);
|
2011-10-04 09:55:16 +00:00
|
|
|
|
2011-10-04 09:55:18 +00:00
|
|
|
ret = asix_write_cmd(dev, AX_CMD_SW_PHY_SELECT, embd_phy, 0, 0, NULL);
|
|
|
|
if (ret < 0) {
|
2005-08-31 16:53:10 +00:00
|
|
|
dbg("Select PHY #1 failed: %d", ret);
|
2007-12-22 17:42:36 +00:00
|
|
|
goto out;
|
2005-08-31 16:53:10 +00:00
|
|
|
}
|
|
|
|
|
2011-10-04 09:55:18 +00:00
|
|
|
ret = asix_sw_reset(dev, AX_SWRESET_IPPD | AX_SWRESET_PRL);
|
|
|
|
if (ret < 0)
|
2007-12-22 17:42:36 +00:00
|
|
|
goto out;
|
2005-08-31 16:53:10 +00:00
|
|
|
|
|
|
|
msleep(150);
|
2011-10-04 09:55:18 +00:00
|
|
|
|
|
|
|
ret = asix_sw_reset(dev, AX_SWRESET_CLEAR);
|
|
|
|
if (ret < 0)
|
2007-12-22 17:42:36 +00:00
|
|
|
goto out;
|
2005-08-31 16:53:10 +00:00
|
|
|
|
|
|
|
msleep(150);
|
2011-10-04 09:55:16 +00:00
|
|
|
|
2007-01-11 23:39:16 +00:00
|
|
|
if (embd_phy) {
|
2011-10-04 09:55:18 +00:00
|
|
|
ret = asix_sw_reset(dev, AX_SWRESET_IPRL);
|
|
|
|
if (ret < 0)
|
2007-12-22 17:42:36 +00:00
|
|
|
goto out;
|
2011-10-04 09:55:18 +00:00
|
|
|
} else {
|
|
|
|
ret = asix_sw_reset(dev, AX_SWRESET_PRTE);
|
|
|
|
if (ret < 0)
|
2007-12-22 17:42:36 +00:00
|
|
|
goto out;
|
2007-01-11 23:39:16 +00:00
|
|
|
}
|
2005-08-31 16:53:10 +00:00
|
|
|
|
|
|
|
msleep(150);
|
2006-07-29 14:12:50 +00:00
|
|
|
rx_ctl = asix_read_rx_ctl(dev);
|
|
|
|
dbg("RX_CTL is 0x%04x after software reset", rx_ctl);
|
2011-10-04 09:55:18 +00:00
|
|
|
ret = asix_write_rx_ctl(dev, 0x0000);
|
|
|
|
if (ret < 0)
|
2007-12-22 17:42:36 +00:00
|
|
|
goto out;
|
2005-08-31 16:53:10 +00:00
|
|
|
|
2006-07-29 14:12:50 +00:00
|
|
|
rx_ctl = asix_read_rx_ctl(dev);
|
|
|
|
dbg("RX_CTL is 0x%04x setting to 0x0000", rx_ctl);
|
|
|
|
|
2011-10-04 09:55:18 +00:00
|
|
|
ret = asix_sw_reset(dev, AX_SWRESET_PRL);
|
|
|
|
if (ret < 0)
|
2007-12-22 17:42:36 +00:00
|
|
|
goto out;
|
2005-08-31 16:53:10 +00:00
|
|
|
|
|
|
|
msleep(150);
|
2006-03-29 01:15:42 +00:00
|
|
|
|
2011-10-04 09:55:18 +00:00
|
|
|
ret = asix_sw_reset(dev, AX_SWRESET_IPRL | AX_SWRESET_PRL);
|
|
|
|
if (ret < 0)
|
2007-12-22 17:42:36 +00:00
|
|
|
goto out;
|
2005-08-31 16:53:10 +00:00
|
|
|
|
2006-03-29 01:15:42 +00:00
|
|
|
msleep(150);
|
2005-08-31 16:53:10 +00:00
|
|
|
|
2006-07-29 14:12:50 +00:00
|
|
|
asix_mdio_write(dev->net, dev->mii.phy_id, MII_BMCR, BMCR_RESET);
|
|
|
|
asix_mdio_write(dev->net, dev->mii.phy_id, MII_ADVERTISE,
|
2005-08-31 16:53:10 +00:00
|
|
|
ADVERTISE_ALL | ADVERTISE_CSMA);
|
|
|
|
mii_nway_restart(&dev->mii);
|
|
|
|
|
2011-10-04 09:55:18 +00:00
|
|
|
ret = asix_write_medium_mode(dev, AX88772_MEDIUM_DEFAULT);
|
|
|
|
if (ret < 0)
|
2007-12-22 17:42:36 +00:00
|
|
|
goto out;
|
2005-08-31 16:53:10 +00:00
|
|
|
|
2011-10-04 09:55:18 +00:00
|
|
|
ret = asix_write_cmd(dev, AX_CMD_WRITE_IPG0,
|
2005-08-31 16:53:10 +00:00
|
|
|
AX88772_IPG0_DEFAULT | AX88772_IPG1_DEFAULT,
|
2011-10-04 09:55:18 +00:00
|
|
|
AX88772_IPG2_DEFAULT, 0, NULL);
|
|
|
|
if (ret < 0) {
|
2005-08-31 16:53:10 +00:00
|
|
|
dbg("Write IPG,IPG1,IPG2 failed: %d", ret);
|
2007-12-22 17:42:36 +00:00
|
|
|
goto out;
|
2005-08-31 16:53:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Set RX_CTL to default values with 2k buffer, and enable cactus */
|
2011-10-04 09:55:18 +00:00
|
|
|
ret = asix_write_rx_ctl(dev, AX_DEFAULT_RX_CTL);
|
|
|
|
if (ret < 0)
|
2007-12-22 17:42:36 +00:00
|
|
|
goto out;
|
2005-08-31 16:53:10 +00:00
|
|
|
|
2006-07-29 14:12:50 +00:00
|
|
|
rx_ctl = asix_read_rx_ctl(dev);
|
|
|
|
dbg("RX_CTL is 0x%04x after all initializations", rx_ctl);
|
|
|
|
|
|
|
|
rx_ctl = asix_read_medium_status(dev);
|
|
|
|
dbg("Medium Status is 0x%04x after all initializations", rx_ctl);
|
|
|
|
|
2011-10-04 09:55:16 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct net_device_ops ax88772_netdev_ops = {
|
|
|
|
.ndo_open = usbnet_open,
|
|
|
|
.ndo_stop = usbnet_stop,
|
|
|
|
.ndo_start_xmit = usbnet_start_xmit,
|
|
|
|
.ndo_tx_timeout = usbnet_tx_timeout,
|
|
|
|
.ndo_change_mtu = usbnet_change_mtu,
|
|
|
|
.ndo_set_mac_address = asix_set_mac_address,
|
|
|
|
.ndo_validate_addr = eth_validate_addr,
|
|
|
|
.ndo_do_ioctl = asix_ioctl,
|
|
|
|
.ndo_set_rx_mode = asix_set_multicast,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int ax88772_bind(struct usbnet *dev, struct usb_interface *intf)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct asix_data *data = (struct asix_data *)&dev->data;
|
|
|
|
u8 buf[ETH_ALEN];
|
|
|
|
u32 phyid;
|
|
|
|
|
|
|
|
data->eeprom_len = AX88772_EEPROM_LEN;
|
|
|
|
|
|
|
|
usbnet_get_endpoints(dev,intf);
|
|
|
|
|
|
|
|
/* Get the MAC address */
|
2011-10-04 09:55:18 +00:00
|
|
|
ret = asix_read_cmd(dev, AX_CMD_READ_NODE_ID, 0, 0, ETH_ALEN, buf);
|
|
|
|
if (ret < 0) {
|
2011-10-04 09:55:16 +00:00
|
|
|
dbg("Failed to read MAC address: %d", ret);
|
2011-10-04 09:55:18 +00:00
|
|
|
return ret;
|
2011-10-04 09:55:16 +00:00
|
|
|
}
|
|
|
|
memcpy(dev->net->dev_addr, buf, ETH_ALEN);
|
|
|
|
|
|
|
|
/* Initialize MII structure */
|
|
|
|
dev->mii.dev = dev->net;
|
|
|
|
dev->mii.mdio_read = asix_mdio_read;
|
|
|
|
dev->mii.mdio_write = asix_mdio_write;
|
|
|
|
dev->mii.phy_id_mask = 0x1f;
|
|
|
|
dev->mii.reg_num_mask = 0x1f;
|
|
|
|
dev->mii.phy_id = asix_get_phy_addr(dev);
|
|
|
|
|
|
|
|
phyid = asix_get_phyid(dev);
|
|
|
|
dbg("PHYID=0x%08x", phyid);
|
|
|
|
|
|
|
|
dev->net->netdev_ops = &ax88772_netdev_ops;
|
|
|
|
dev->net->ethtool_ops = &ax88772_ethtool_ops;
|
|
|
|
|
2011-10-04 09:55:18 +00:00
|
|
|
ret = ax88772_reset(dev);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2011-10-04 09:55:16 +00:00
|
|
|
|
2005-08-31 16:53:10 +00:00
|
|
|
/* Asix framing packs multiple eth frames into a 2K usb bulk transfer */
|
|
|
|
if (dev->driver_info->flags & FLAG_FRAMING_AX) {
|
|
|
|
/* hard_mtu is still the default - the device does not support
|
|
|
|
jumbo eth frames */
|
|
|
|
dev->rx_urb_size = 2048;
|
|
|
|
}
|
2011-10-04 09:55:18 +00:00
|
|
|
|
2005-08-31 16:53:10 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-07-29 14:12:50 +00:00
|
|
|
static struct ethtool_ops ax88178_ethtool_ops = {
|
|
|
|
.get_drvinfo = asix_get_drvinfo,
|
|
|
|
.get_link = asix_get_link,
|
|
|
|
.get_msglevel = usbnet_get_msglevel,
|
|
|
|
.set_msglevel = usbnet_set_msglevel,
|
|
|
|
.get_wol = asix_get_wol,
|
|
|
|
.set_wol = asix_set_wol,
|
|
|
|
.get_eeprom_len = asix_get_eeprom_len,
|
|
|
|
.get_eeprom = asix_get_eeprom,
|
2006-10-08 22:08:01 +00:00
|
|
|
.get_settings = usbnet_get_settings,
|
|
|
|
.set_settings = usbnet_set_settings,
|
|
|
|
.nway_reset = usbnet_nway_reset,
|
2006-07-29 14:12:50 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static int marvell_phy_init(struct usbnet *dev)
|
2005-08-31 16:53:10 +00:00
|
|
|
{
|
2006-07-29 14:12:50 +00:00
|
|
|
struct asix_data *data = (struct asix_data *)&dev->data;
|
|
|
|
u16 reg;
|
2005-08-31 16:53:10 +00:00
|
|
|
|
2010-02-17 10:30:23 +00:00
|
|
|
netdev_dbg(dev->net, "marvell_phy_init()\n");
|
2005-08-31 16:53:10 +00:00
|
|
|
|
2006-07-29 14:12:50 +00:00
|
|
|
reg = asix_mdio_read(dev->net, dev->mii.phy_id, MII_MARVELL_STATUS);
|
2010-02-17 10:30:23 +00:00
|
|
|
netdev_dbg(dev->net, "MII_MARVELL_STATUS = 0x%04x\n", reg);
|
2005-08-31 16:53:10 +00:00
|
|
|
|
2006-07-29 14:12:50 +00:00
|
|
|
asix_mdio_write(dev->net, dev->mii.phy_id, MII_MARVELL_CTRL,
|
|
|
|
MARVELL_CTRL_RXDELAY | MARVELL_CTRL_TXDELAY);
|
2005-08-31 16:53:10 +00:00
|
|
|
|
2006-07-29 14:12:50 +00:00
|
|
|
if (data->ledmode) {
|
|
|
|
reg = asix_mdio_read(dev->net, dev->mii.phy_id,
|
|
|
|
MII_MARVELL_LED_CTRL);
|
2010-02-17 10:30:23 +00:00
|
|
|
netdev_dbg(dev->net, "MII_MARVELL_LED_CTRL (1) = 0x%04x\n", reg);
|
2005-08-31 16:53:10 +00:00
|
|
|
|
2006-07-29 14:12:50 +00:00
|
|
|
reg &= 0xf8ff;
|
|
|
|
reg |= (1 + 0x0100);
|
|
|
|
asix_mdio_write(dev->net, dev->mii.phy_id,
|
|
|
|
MII_MARVELL_LED_CTRL, reg);
|
2005-08-31 16:53:10 +00:00
|
|
|
|
2006-07-29 14:12:50 +00:00
|
|
|
reg = asix_mdio_read(dev->net, dev->mii.phy_id,
|
|
|
|
MII_MARVELL_LED_CTRL);
|
2010-02-17 10:30:23 +00:00
|
|
|
netdev_dbg(dev->net, "MII_MARVELL_LED_CTRL (2) = 0x%04x\n", reg);
|
2006-07-29 14:12:50 +00:00
|
|
|
reg &= 0xfc0f;
|
|
|
|
}
|
2005-08-31 16:53:10 +00:00
|
|
|
|
2006-07-29 14:12:50 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-10-04 09:55:17 +00:00
|
|
|
static int rtl8211cl_phy_init(struct usbnet *dev)
|
|
|
|
{
|
|
|
|
struct asix_data *data = (struct asix_data *)&dev->data;
|
|
|
|
|
|
|
|
netdev_dbg(dev->net, "rtl8211cl_phy_init()\n");
|
|
|
|
|
|
|
|
asix_mdio_write (dev->net, dev->mii.phy_id, 0x1f, 0x0005);
|
|
|
|
asix_mdio_write (dev->net, dev->mii.phy_id, 0x0c, 0);
|
|
|
|
asix_mdio_write (dev->net, dev->mii.phy_id, 0x01,
|
|
|
|
asix_mdio_read (dev->net, dev->mii.phy_id, 0x01) | 0x0080);
|
|
|
|
asix_mdio_write (dev->net, dev->mii.phy_id, 0x1f, 0);
|
|
|
|
|
|
|
|
if (data->ledmode == 12) {
|
|
|
|
asix_mdio_write (dev->net, dev->mii.phy_id, 0x1f, 0x0002);
|
|
|
|
asix_mdio_write (dev->net, dev->mii.phy_id, 0x1a, 0x00cb);
|
|
|
|
asix_mdio_write (dev->net, dev->mii.phy_id, 0x1f, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-07-29 14:12:50 +00:00
|
|
|
static int marvell_led_status(struct usbnet *dev, u16 speed)
|
|
|
|
{
|
|
|
|
u16 reg = asix_mdio_read(dev->net, dev->mii.phy_id, MARVELL_LED_MANUAL);
|
|
|
|
|
2010-02-17 10:30:23 +00:00
|
|
|
netdev_dbg(dev->net, "marvell_led_status() read 0x%04x\n", reg);
|
2006-07-29 14:12:50 +00:00
|
|
|
|
|
|
|
/* Clear out the center LED bits - 0x03F0 */
|
|
|
|
reg &= 0xfc0f;
|
|
|
|
|
|
|
|
switch (speed) {
|
|
|
|
case SPEED_1000:
|
|
|
|
reg |= 0x03e0;
|
|
|
|
break;
|
|
|
|
case SPEED_100:
|
|
|
|
reg |= 0x03b0;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
reg |= 0x02f0;
|
2005-08-31 16:53:10 +00:00
|
|
|
}
|
|
|
|
|
2010-02-17 10:30:23 +00:00
|
|
|
netdev_dbg(dev->net, "marvell_led_status() writing 0x%04x\n", reg);
|
2006-07-29 14:12:50 +00:00
|
|
|
asix_mdio_write(dev->net, dev->mii.phy_id, MARVELL_LED_MANUAL, reg);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-10-04 09:55:17 +00:00
|
|
|
static int ax88178_reset(struct usbnet *dev)
|
|
|
|
{
|
|
|
|
struct asix_data *data = (struct asix_data *)&dev->data;
|
|
|
|
int ret;
|
|
|
|
__le16 eeprom;
|
|
|
|
u8 status;
|
|
|
|
int gpio0 = 0;
|
|
|
|
|
|
|
|
asix_read_cmd(dev, AX_CMD_READ_GPIOS, 0, 0, 1, &status);
|
|
|
|
dbg("GPIO Status: 0x%04x", status);
|
|
|
|
|
|
|
|
asix_write_cmd(dev, AX_CMD_WRITE_ENABLE, 0, 0, 0, NULL);
|
|
|
|
asix_read_cmd(dev, AX_CMD_READ_EEPROM, 0x0017, 0, 2, &eeprom);
|
|
|
|
asix_write_cmd(dev, AX_CMD_WRITE_DISABLE, 0, 0, 0, NULL);
|
|
|
|
|
|
|
|
dbg("EEPROM index 0x17 is 0x%04x", eeprom);
|
|
|
|
|
|
|
|
if (eeprom == cpu_to_le16(0xffff)) {
|
|
|
|
data->phymode = PHY_MODE_MARVELL;
|
|
|
|
data->ledmode = 0;
|
|
|
|
gpio0 = 1;
|
|
|
|
} else {
|
|
|
|
data->phymode = le16_to_cpu(eeprom) & 7;
|
|
|
|
data->ledmode = le16_to_cpu(eeprom) >> 8;
|
|
|
|
gpio0 = (le16_to_cpu(eeprom) & 0x80) ? 0 : 1;
|
|
|
|
}
|
|
|
|
dbg("GPIO0: %d, PhyMode: %d", gpio0, data->phymode);
|
|
|
|
|
|
|
|
asix_write_gpio(dev, AX_GPIO_RSE | AX_GPIO_GPO_1 | AX_GPIO_GPO1EN, 40);
|
|
|
|
if ((le16_to_cpu(eeprom) >> 8) != 1) {
|
|
|
|
asix_write_gpio(dev, 0x003c, 30);
|
|
|
|
asix_write_gpio(dev, 0x001c, 300);
|
|
|
|
asix_write_gpio(dev, 0x003c, 30);
|
|
|
|
} else {
|
|
|
|
dbg("gpio phymode == 1 path");
|
|
|
|
asix_write_gpio(dev, AX_GPIO_GPO1EN, 30);
|
|
|
|
asix_write_gpio(dev, AX_GPIO_GPO1EN | AX_GPIO_GPO_1, 30);
|
|
|
|
}
|
|
|
|
|
|
|
|
asix_sw_reset(dev, 0);
|
|
|
|
msleep(150);
|
|
|
|
|
|
|
|
asix_sw_reset(dev, AX_SWRESET_PRL | AX_SWRESET_IPPD);
|
|
|
|
msleep(150);
|
|
|
|
|
|
|
|
asix_write_rx_ctl(dev, 0);
|
|
|
|
|
|
|
|
if (data->phymode == PHY_MODE_MARVELL) {
|
|
|
|
marvell_phy_init(dev);
|
|
|
|
msleep(60);
|
|
|
|
} else if (data->phymode == PHY_MODE_RTL8211CL)
|
|
|
|
rtl8211cl_phy_init(dev);
|
|
|
|
|
|
|
|
asix_mdio_write(dev->net, dev->mii.phy_id, MII_BMCR,
|
|
|
|
BMCR_RESET | BMCR_ANENABLE);
|
|
|
|
asix_mdio_write(dev->net, dev->mii.phy_id, MII_ADVERTISE,
|
|
|
|
ADVERTISE_ALL | ADVERTISE_CSMA | ADVERTISE_PAUSE_CAP);
|
|
|
|
asix_mdio_write(dev->net, dev->mii.phy_id, MII_CTRL1000,
|
|
|
|
ADVERTISE_1000FULL);
|
|
|
|
|
|
|
|
mii_nway_restart(&dev->mii);
|
|
|
|
|
2011-10-04 09:55:18 +00:00
|
|
|
ret = asix_write_medium_mode(dev, AX88178_MEDIUM_DEFAULT);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2011-10-04 09:55:17 +00:00
|
|
|
|
2011-10-04 09:55:18 +00:00
|
|
|
ret = asix_write_rx_ctl(dev, AX_DEFAULT_RX_CTL);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2011-10-04 09:55:17 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-07-29 14:12:50 +00:00
|
|
|
static int ax88178_link_reset(struct usbnet *dev)
|
|
|
|
{
|
|
|
|
u16 mode;
|
2011-04-27 18:32:38 +00:00
|
|
|
struct ethtool_cmd ecmd = { .cmd = ETHTOOL_GSET };
|
2006-07-29 14:12:50 +00:00
|
|
|
struct asix_data *data = (struct asix_data *)&dev->data;
|
2011-04-27 18:32:38 +00:00
|
|
|
u32 speed;
|
2006-07-29 14:12:50 +00:00
|
|
|
|
2010-02-17 10:30:23 +00:00
|
|
|
netdev_dbg(dev->net, "ax88178_link_reset()\n");
|
2006-07-29 14:12:50 +00:00
|
|
|
|
|
|
|
mii_check_media(&dev->mii, 1, 1);
|
|
|
|
mii_ethtool_gset(&dev->mii, &ecmd);
|
|
|
|
mode = AX88178_MEDIUM_DEFAULT;
|
2011-04-27 18:32:38 +00:00
|
|
|
speed = ethtool_cmd_speed(&ecmd);
|
2006-07-29 14:12:50 +00:00
|
|
|
|
2011-04-27 18:32:38 +00:00
|
|
|
if (speed == SPEED_1000)
|
2008-11-20 09:48:46 +00:00
|
|
|
mode |= AX_MEDIUM_GM;
|
2011-04-27 18:32:38 +00:00
|
|
|
else if (speed == SPEED_100)
|
2006-07-29 14:12:50 +00:00
|
|
|
mode |= AX_MEDIUM_PS;
|
|
|
|
else
|
|
|
|
mode &= ~(AX_MEDIUM_PS | AX_MEDIUM_GM);
|
|
|
|
|
2008-11-20 09:48:46 +00:00
|
|
|
mode |= AX_MEDIUM_ENCK;
|
|
|
|
|
2006-07-29 14:12:50 +00:00
|
|
|
if (ecmd.duplex == DUPLEX_FULL)
|
|
|
|
mode |= AX_MEDIUM_FD;
|
|
|
|
else
|
|
|
|
mode &= ~AX_MEDIUM_FD;
|
|
|
|
|
2011-04-27 18:32:38 +00:00
|
|
|
netdev_dbg(dev->net, "ax88178_link_reset() speed: %u duplex: %d setting mode to 0x%04x\n",
|
|
|
|
speed, ecmd.duplex, mode);
|
2006-07-29 14:12:50 +00:00
|
|
|
|
|
|
|
asix_write_medium_mode(dev, mode);
|
|
|
|
|
|
|
|
if (data->phymode == PHY_MODE_MARVELL && data->ledmode)
|
2011-04-27 18:32:38 +00:00
|
|
|
marvell_led_status(dev, speed);
|
2006-07-29 14:12:50 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ax88178_set_mfb(struct usbnet *dev)
|
|
|
|
{
|
|
|
|
u16 mfb = AX_RX_CTL_MFB_16384;
|
|
|
|
u16 rxctl;
|
|
|
|
u16 medium;
|
|
|
|
int old_rx_urb_size = dev->rx_urb_size;
|
|
|
|
|
|
|
|
if (dev->hard_mtu < 2048) {
|
|
|
|
dev->rx_urb_size = 2048;
|
|
|
|
mfb = AX_RX_CTL_MFB_2048;
|
|
|
|
} else if (dev->hard_mtu < 4096) {
|
|
|
|
dev->rx_urb_size = 4096;
|
|
|
|
mfb = AX_RX_CTL_MFB_4096;
|
|
|
|
} else if (dev->hard_mtu < 8192) {
|
|
|
|
dev->rx_urb_size = 8192;
|
|
|
|
mfb = AX_RX_CTL_MFB_8192;
|
|
|
|
} else if (dev->hard_mtu < 16384) {
|
|
|
|
dev->rx_urb_size = 16384;
|
|
|
|
mfb = AX_RX_CTL_MFB_16384;
|
2005-08-31 16:53:10 +00:00
|
|
|
}
|
2006-07-29 14:12:50 +00:00
|
|
|
|
|
|
|
rxctl = asix_read_rx_ctl(dev);
|
|
|
|
asix_write_rx_ctl(dev, (rxctl & ~AX_RX_CTL_MFB_16384) | mfb);
|
|
|
|
|
|
|
|
medium = asix_read_medium_status(dev);
|
|
|
|
if (dev->net->mtu > 1500)
|
|
|
|
medium |= AX_MEDIUM_JFE;
|
|
|
|
else
|
|
|
|
medium &= ~AX_MEDIUM_JFE;
|
|
|
|
asix_write_medium_mode(dev, medium);
|
|
|
|
|
|
|
|
if (dev->rx_urb_size > old_rx_urb_size)
|
|
|
|
usbnet_unlink_rx_urbs(dev);
|
2005-08-31 16:53:10 +00:00
|
|
|
}
|
|
|
|
|
2006-07-29 14:12:50 +00:00
|
|
|
static int ax88178_change_mtu(struct net_device *net, int new_mtu)
|
2005-08-31 16:53:10 +00:00
|
|
|
{
|
2006-07-29 14:12:50 +00:00
|
|
|
struct usbnet *dev = netdev_priv(net);
|
|
|
|
int ll_mtu = new_mtu + net->hard_header_len + 4;
|
2005-08-31 16:53:10 +00:00
|
|
|
|
2010-02-17 10:30:23 +00:00
|
|
|
netdev_dbg(dev->net, "ax88178_change_mtu() new_mtu=%d\n", new_mtu);
|
2005-08-31 16:53:10 +00:00
|
|
|
|
2006-07-29 14:12:50 +00:00
|
|
|
if (new_mtu <= 0 || ll_mtu > 16384)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if ((ll_mtu % dev->maxpacket) == 0)
|
|
|
|
return -EDOM;
|
|
|
|
|
|
|
|
net->mtu = new_mtu;
|
|
|
|
dev->hard_mtu = net->mtu + net->hard_header_len;
|
|
|
|
ax88178_set_mfb(dev);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-03-20 19:35:55 +00:00
|
|
|
static const struct net_device_ops ax88178_netdev_ops = {
|
|
|
|
.ndo_open = usbnet_open,
|
|
|
|
.ndo_stop = usbnet_stop,
|
|
|
|
.ndo_start_xmit = usbnet_start_xmit,
|
|
|
|
.ndo_tx_timeout = usbnet_tx_timeout,
|
2010-03-09 12:24:38 +00:00
|
|
|
.ndo_set_mac_address = asix_set_mac_address,
|
2009-03-20 19:35:55 +00:00
|
|
|
.ndo_validate_addr = eth_validate_addr,
|
2011-08-16 06:29:01 +00:00
|
|
|
.ndo_set_rx_mode = asix_set_multicast,
|
2009-03-20 19:35:55 +00:00
|
|
|
.ndo_do_ioctl = asix_ioctl,
|
|
|
|
.ndo_change_mtu = ax88178_change_mtu,
|
|
|
|
};
|
|
|
|
|
2006-07-29 14:12:50 +00:00
|
|
|
static int ax88178_bind(struct usbnet *dev, struct usb_interface *intf)
|
|
|
|
{
|
|
|
|
int ret;
|
2007-12-22 17:42:36 +00:00
|
|
|
u8 buf[ETH_ALEN];
|
2006-07-29 14:12:50 +00:00
|
|
|
u32 phyid;
|
2011-10-17 05:51:06 +00:00
|
|
|
struct asix_data *data = (struct asix_data *)&dev->data;
|
|
|
|
|
|
|
|
data->eeprom_len = AX88772_EEPROM_LEN;
|
2006-07-29 14:12:50 +00:00
|
|
|
|
|
|
|
usbnet_get_endpoints(dev,intf);
|
|
|
|
|
|
|
|
/* Get the MAC address */
|
2011-10-04 09:55:18 +00:00
|
|
|
ret = asix_read_cmd(dev, AX_CMD_READ_NODE_ID, 0, 0, ETH_ALEN, buf);
|
|
|
|
if (ret < 0) {
|
2006-07-29 14:12:50 +00:00
|
|
|
dbg("Failed to read MAC address: %d", ret);
|
2011-10-04 09:55:18 +00:00
|
|
|
return ret;
|
2005-08-31 16:53:10 +00:00
|
|
|
}
|
2006-07-29 14:12:50 +00:00
|
|
|
memcpy(dev->net->dev_addr, buf, ETH_ALEN);
|
2005-08-31 16:53:10 +00:00
|
|
|
|
2006-07-29 14:12:50 +00:00
|
|
|
/* Initialize MII structure */
|
|
|
|
dev->mii.dev = dev->net;
|
|
|
|
dev->mii.mdio_read = asix_mdio_read;
|
|
|
|
dev->mii.mdio_write = asix_mdio_write;
|
|
|
|
dev->mii.phy_id_mask = 0x1f;
|
|
|
|
dev->mii.reg_num_mask = 0xff;
|
|
|
|
dev->mii.supports_gmii = 1;
|
|
|
|
dev->mii.phy_id = asix_get_phy_addr(dev);
|
2009-03-20 19:35:55 +00:00
|
|
|
|
|
|
|
dev->net->netdev_ops = &ax88178_netdev_ops;
|
2006-07-29 14:12:50 +00:00
|
|
|
dev->net->ethtool_ops = &ax88178_ethtool_ops;
|
2005-08-31 16:53:10 +00:00
|
|
|
|
2006-07-29 14:12:50 +00:00
|
|
|
phyid = asix_get_phyid(dev);
|
|
|
|
dbg("PHYID=0x%08x", phyid);
|
2005-08-31 16:53:10 +00:00
|
|
|
|
2011-10-04 09:55:17 +00:00
|
|
|
ret = ax88178_reset(dev);
|
|
|
|
if (ret < 0)
|
2011-10-04 09:55:18 +00:00
|
|
|
return ret;
|
2006-07-29 14:12:50 +00:00
|
|
|
|
|
|
|
/* Asix framing packs multiple eth frames into a 2K usb bulk transfer */
|
|
|
|
if (dev->driver_info->flags & FLAG_FRAMING_AX) {
|
|
|
|
/* hard_mtu is still the default - the device does not support
|
|
|
|
jumbo eth frames */
|
|
|
|
dev->rx_urb_size = 2048;
|
|
|
|
}
|
|
|
|
|
2011-10-04 09:55:18 +00:00
|
|
|
return 0;
|
2005-08-31 16:53:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static const struct driver_info ax8817x_info = {
|
|
|
|
.description = "ASIX AX8817x USB 2.0 Ethernet",
|
2006-03-29 01:15:42 +00:00
|
|
|
.bind = ax88172_bind,
|
|
|
|
.status = asix_status,
|
2005-08-31 16:53:10 +00:00
|
|
|
.link_reset = ax88172_link_reset,
|
|
|
|
.reset = ax88172_link_reset,
|
2009-11-04 15:29:52 +00:00
|
|
|
.flags = FLAG_ETHER | FLAG_LINK_INTR,
|
2005-08-31 16:53:10 +00:00
|
|
|
.data = 0x00130103,
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct driver_info dlink_dub_e100_info = {
|
|
|
|
.description = "DLink DUB-E100 USB Ethernet",
|
2006-03-29 01:15:42 +00:00
|
|
|
.bind = ax88172_bind,
|
|
|
|
.status = asix_status,
|
2005-08-31 16:53:10 +00:00
|
|
|
.link_reset = ax88172_link_reset,
|
|
|
|
.reset = ax88172_link_reset,
|
2009-11-04 15:29:52 +00:00
|
|
|
.flags = FLAG_ETHER | FLAG_LINK_INTR,
|
2005-08-31 16:53:10 +00:00
|
|
|
.data = 0x009f9d9f,
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct driver_info netgear_fa120_info = {
|
|
|
|
.description = "Netgear FA-120 USB Ethernet",
|
2006-03-29 01:15:42 +00:00
|
|
|
.bind = ax88172_bind,
|
|
|
|
.status = asix_status,
|
2005-08-31 16:53:10 +00:00
|
|
|
.link_reset = ax88172_link_reset,
|
|
|
|
.reset = ax88172_link_reset,
|
2009-11-04 15:29:52 +00:00
|
|
|
.flags = FLAG_ETHER | FLAG_LINK_INTR,
|
2005-08-31 16:53:10 +00:00
|
|
|
.data = 0x00130103,
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct driver_info hawking_uf200_info = {
|
|
|
|
.description = "Hawking UF200 USB Ethernet",
|
2006-03-29 01:15:42 +00:00
|
|
|
.bind = ax88172_bind,
|
|
|
|
.status = asix_status,
|
2005-08-31 16:53:10 +00:00
|
|
|
.link_reset = ax88172_link_reset,
|
|
|
|
.reset = ax88172_link_reset,
|
2009-11-04 15:29:52 +00:00
|
|
|
.flags = FLAG_ETHER | FLAG_LINK_INTR,
|
2005-08-31 16:53:10 +00:00
|
|
|
.data = 0x001f1d1f,
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct driver_info ax88772_info = {
|
|
|
|
.description = "ASIX AX88772 USB 2.0 Ethernet",
|
|
|
|
.bind = ax88772_bind,
|
2006-03-29 01:15:42 +00:00
|
|
|
.status = asix_status,
|
2005-08-31 16:53:10 +00:00
|
|
|
.link_reset = ax88772_link_reset,
|
2011-10-04 09:55:16 +00:00
|
|
|
.reset = ax88772_reset,
|
2009-11-04 15:29:52 +00:00
|
|
|
.flags = FLAG_ETHER | FLAG_FRAMING_AX | FLAG_LINK_INTR,
|
2006-07-29 14:12:50 +00:00
|
|
|
.rx_fixup = asix_rx_fixup,
|
|
|
|
.tx_fixup = asix_tx_fixup,
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct driver_info ax88178_info = {
|
|
|
|
.description = "ASIX AX88178 USB 2.0 Ethernet",
|
|
|
|
.bind = ax88178_bind,
|
|
|
|
.status = asix_status,
|
|
|
|
.link_reset = ax88178_link_reset,
|
2011-10-04 09:55:17 +00:00
|
|
|
.reset = ax88178_reset,
|
2009-11-04 15:29:52 +00:00
|
|
|
.flags = FLAG_ETHER | FLAG_FRAMING_AX | FLAG_LINK_INTR,
|
2006-07-29 14:12:50 +00:00
|
|
|
.rx_fixup = asix_rx_fixup,
|
|
|
|
.tx_fixup = asix_tx_fixup,
|
2005-08-31 16:53:10 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static const struct usb_device_id products [] = {
|
|
|
|
{
|
|
|
|
// Linksys USB200M
|
|
|
|
USB_DEVICE (0x077b, 0x2226),
|
|
|
|
.driver_info = (unsigned long) &ax8817x_info,
|
|
|
|
}, {
|
|
|
|
// Netgear FA120
|
|
|
|
USB_DEVICE (0x0846, 0x1040),
|
|
|
|
.driver_info = (unsigned long) &netgear_fa120_info,
|
|
|
|
}, {
|
|
|
|
// DLink DUB-E100
|
|
|
|
USB_DEVICE (0x2001, 0x1a00),
|
|
|
|
.driver_info = (unsigned long) &dlink_dub_e100_info,
|
|
|
|
}, {
|
|
|
|
// Intellinet, ST Lab USB Ethernet
|
|
|
|
USB_DEVICE (0x0b95, 0x1720),
|
|
|
|
.driver_info = (unsigned long) &ax8817x_info,
|
|
|
|
}, {
|
|
|
|
// Hawking UF200, TrendNet TU2-ET100
|
|
|
|
USB_DEVICE (0x07b8, 0x420a),
|
|
|
|
.driver_info = (unsigned long) &hawking_uf200_info,
|
|
|
|
}, {
|
2007-02-20 13:02:24 +00:00
|
|
|
// Billionton Systems, USB2AR
|
|
|
|
USB_DEVICE (0x08dd, 0x90ff),
|
|
|
|
.driver_info = (unsigned long) &ax8817x_info,
|
2005-08-31 16:53:10 +00:00
|
|
|
}, {
|
|
|
|
// ATEN UC210T
|
|
|
|
USB_DEVICE (0x0557, 0x2009),
|
|
|
|
.driver_info = (unsigned long) &ax8817x_info,
|
|
|
|
}, {
|
|
|
|
// Buffalo LUA-U2-KTX
|
|
|
|
USB_DEVICE (0x0411, 0x003d),
|
|
|
|
.driver_info = (unsigned long) &ax8817x_info,
|
2008-05-07 03:42:35 +00:00
|
|
|
}, {
|
|
|
|
// Buffalo LUA-U2-GT 10/100/1000
|
|
|
|
USB_DEVICE (0x0411, 0x006e),
|
|
|
|
.driver_info = (unsigned long) &ax88178_info,
|
2005-08-31 16:53:10 +00:00
|
|
|
}, {
|
|
|
|
// Sitecom LN-029 "USB 2.0 10/100 Ethernet adapter"
|
|
|
|
USB_DEVICE (0x6189, 0x182d),
|
|
|
|
.driver_info = (unsigned long) &ax8817x_info,
|
|
|
|
}, {
|
|
|
|
// corega FEther USB2-TX
|
|
|
|
USB_DEVICE (0x07aa, 0x0017),
|
|
|
|
.driver_info = (unsigned long) &ax8817x_info,
|
|
|
|
}, {
|
|
|
|
// Surecom EP-1427X-2
|
|
|
|
USB_DEVICE (0x1189, 0x0893),
|
|
|
|
.driver_info = (unsigned long) &ax8817x_info,
|
|
|
|
}, {
|
|
|
|
// goodway corp usb gwusb2e
|
|
|
|
USB_DEVICE (0x1631, 0x6200),
|
|
|
|
.driver_info = (unsigned long) &ax8817x_info,
|
2007-02-20 13:02:24 +00:00
|
|
|
}, {
|
|
|
|
// JVC MP-PRX1 Port Replicator
|
|
|
|
USB_DEVICE (0x04f1, 0x3008),
|
|
|
|
.driver_info = (unsigned long) &ax8817x_info,
|
2011-07-20 05:57:04 +00:00
|
|
|
}, {
|
|
|
|
// ASIX AX88772B 10/100
|
|
|
|
USB_DEVICE (0x0b95, 0x772b),
|
|
|
|
.driver_info = (unsigned long) &ax88772_info,
|
2005-08-31 16:53:10 +00:00
|
|
|
}, {
|
|
|
|
// ASIX AX88772 10/100
|
2007-02-20 13:02:24 +00:00
|
|
|
USB_DEVICE (0x0b95, 0x7720),
|
|
|
|
.driver_info = (unsigned long) &ax88772_info,
|
2006-05-18 08:13:17 +00:00
|
|
|
}, {
|
|
|
|
// ASIX AX88178 10/100/1000
|
|
|
|
USB_DEVICE (0x0b95, 0x1780),
|
2006-07-29 14:12:50 +00:00
|
|
|
.driver_info = (unsigned long) &ax88178_info,
|
2010-12-15 12:16:30 +00:00
|
|
|
}, {
|
|
|
|
// Logitec LAN-GTJ/U2A
|
|
|
|
USB_DEVICE (0x0789, 0x0160),
|
|
|
|
.driver_info = (unsigned long) &ax88178_info,
|
2005-12-19 18:58:38 +00:00
|
|
|
}, {
|
|
|
|
// Linksys USB200M Rev 2
|
|
|
|
USB_DEVICE (0x13b1, 0x0018),
|
|
|
|
.driver_info = (unsigned long) &ax88772_info,
|
2006-01-05 19:39:49 +00:00
|
|
|
}, {
|
|
|
|
// 0Q0 cable ethernet
|
|
|
|
USB_DEVICE (0x1557, 0x7720),
|
|
|
|
.driver_info = (unsigned long) &ax88772_info,
|
2006-07-29 14:12:50 +00:00
|
|
|
}, {
|
|
|
|
// DLink DUB-E100 H/W Ver B1
|
|
|
|
USB_DEVICE (0x07d1, 0x3c05),
|
|
|
|
.driver_info = (unsigned long) &ax88772_info,
|
2006-09-21 12:09:29 +00:00
|
|
|
}, {
|
|
|
|
// DLink DUB-E100 H/W Ver B1 Alternate
|
|
|
|
USB_DEVICE (0x2001, 0x3c05),
|
|
|
|
.driver_info = (unsigned long) &ax88772_info,
|
2006-07-29 14:12:50 +00:00
|
|
|
}, {
|
|
|
|
// Linksys USB1000
|
|
|
|
USB_DEVICE (0x1737, 0x0039),
|
|
|
|
.driver_info = (unsigned long) &ax88178_info,
|
2007-01-26 13:57:38 +00:00
|
|
|
}, {
|
|
|
|
// IO-DATA ETG-US2
|
|
|
|
USB_DEVICE (0x04bb, 0x0930),
|
|
|
|
.driver_info = (unsigned long) &ax88178_info,
|
2007-05-23 11:33:17 +00:00
|
|
|
}, {
|
|
|
|
// Belkin F5D5055
|
|
|
|
USB_DEVICE(0x050d, 0x5055),
|
|
|
|
.driver_info = (unsigned long) &ax88178_info,
|
2008-05-15 00:04:13 +00:00
|
|
|
}, {
|
|
|
|
// Apple USB Ethernet Adapter
|
|
|
|
USB_DEVICE(0x05ac, 0x1402),
|
|
|
|
.driver_info = (unsigned long) &ax88772_info,
|
2008-11-11 18:02:53 +00:00
|
|
|
}, {
|
|
|
|
// Cables-to-Go USB Ethernet Adapter
|
|
|
|
USB_DEVICE(0x0b95, 0x772a),
|
|
|
|
.driver_info = (unsigned long) &ax88772_info,
|
2009-02-25 07:52:24 +00:00
|
|
|
}, {
|
|
|
|
// ABOCOM for pci
|
|
|
|
USB_DEVICE(0x14ea, 0xab11),
|
|
|
|
.driver_info = (unsigned long) &ax88178_info,
|
|
|
|
}, {
|
|
|
|
// ASIX 88772a
|
|
|
|
USB_DEVICE(0x0db0, 0xa877),
|
|
|
|
.driver_info = (unsigned long) &ax88772_info,
|
2005-08-31 16:53:10 +00:00
|
|
|
},
|
|
|
|
{ }, // END
|
|
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(usb, products);
|
|
|
|
|
|
|
|
static struct usb_driver asix_driver = {
|
2011-10-04 09:55:18 +00:00
|
|
|
.name = DRIVER_NAME,
|
2005-08-31 16:53:10 +00:00
|
|
|
.id_table = products,
|
|
|
|
.probe = usbnet_probe,
|
|
|
|
.suspend = usbnet_suspend,
|
|
|
|
.resume = usbnet_resume,
|
|
|
|
.disconnect = usbnet_disconnect,
|
2007-08-03 11:52:19 +00:00
|
|
|
.supports_autosuspend = 1,
|
2005-08-31 16:53:10 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static int __init asix_init(void)
|
|
|
|
{
|
|
|
|
return usb_register(&asix_driver);
|
|
|
|
}
|
|
|
|
module_init(asix_init);
|
|
|
|
|
|
|
|
static void __exit asix_exit(void)
|
|
|
|
{
|
|
|
|
usb_deregister(&asix_driver);
|
|
|
|
}
|
|
|
|
module_exit(asix_exit);
|
|
|
|
|
|
|
|
MODULE_AUTHOR("David Hollis");
|
2011-10-04 09:55:16 +00:00
|
|
|
MODULE_VERSION(DRIVER_VERSION);
|
2005-08-31 16:53:10 +00:00
|
|
|
MODULE_DESCRIPTION("ASIX AX8817X based USB 2.0 Ethernet Devices");
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
|