102ac6454SAndrew Thompson /*-
2df57947fSPedro F. Giffuni * SPDX-License-Identifier: BSD-4-Clause
3df57947fSPedro F. Giffuni *
402ac6454SAndrew Thompson * Copyright (c) 1997, 1998, 1999, 2000-2003
502ac6454SAndrew Thompson * Bill Paul <wpaul@windriver.com>. All rights reserved.
602ac6454SAndrew Thompson *
702ac6454SAndrew Thompson * Redistribution and use in source and binary forms, with or without
802ac6454SAndrew Thompson * modification, are permitted provided that the following conditions
902ac6454SAndrew Thompson * are met:
1002ac6454SAndrew Thompson * 1. Redistributions of source code must retain the above copyright
1102ac6454SAndrew Thompson * notice, this list of conditions and the following disclaimer.
1202ac6454SAndrew Thompson * 2. Redistributions in binary form must reproduce the above copyright
1302ac6454SAndrew Thompson * notice, this list of conditions and the following disclaimer in the
1402ac6454SAndrew Thompson * documentation and/or other materials provided with the distribution.
1502ac6454SAndrew Thompson * 3. All advertising materials mentioning features or use of this software
1602ac6454SAndrew Thompson * must display the following acknowledgement:
1702ac6454SAndrew Thompson * This product includes software developed by Bill Paul.
1802ac6454SAndrew Thompson * 4. Neither the name of the author nor the names of any co-contributors
1902ac6454SAndrew Thompson * may be used to endorse or promote products derived from this software
2002ac6454SAndrew Thompson * without specific prior written permission.
2102ac6454SAndrew Thompson *
2202ac6454SAndrew Thompson * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND
2302ac6454SAndrew Thompson * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
2402ac6454SAndrew Thompson * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
2502ac6454SAndrew Thompson * ARE DISCLAIMED. IN NO EVENT SHALL Bill Paul OR THE VOICES IN HIS HEAD
2602ac6454SAndrew Thompson * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
2702ac6454SAndrew Thompson * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
2802ac6454SAndrew Thompson * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
2902ac6454SAndrew Thompson * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
3002ac6454SAndrew Thompson * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
3102ac6454SAndrew Thompson * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
3202ac6454SAndrew Thompson * THE POSSIBILITY OF SUCH DAMAGE.
3302ac6454SAndrew Thompson */
3402ac6454SAndrew Thompson
3502ac6454SAndrew Thompson #include <sys/cdefs.h>
3602ac6454SAndrew Thompson /*
3702ac6454SAndrew Thompson * ASIX Electronics AX88172/AX88178/AX88778 USB 2.0 ethernet driver.
3802ac6454SAndrew Thompson * Used in the LinkSys USB200M and various other adapters.
3902ac6454SAndrew Thompson *
4002ac6454SAndrew Thompson * Manuals available from:
4102ac6454SAndrew Thompson * http://www.asix.com.tw/datasheet/mac/Ax88172.PDF
4202ac6454SAndrew Thompson * Note: you need the manual for the AX88170 chip (USB 1.x ethernet
4302ac6454SAndrew Thompson * controller) to find the definitions for the RX control register.
4402ac6454SAndrew Thompson * http://www.asix.com.tw/datasheet/mac/Ax88170.PDF
4502ac6454SAndrew Thompson *
4602ac6454SAndrew Thompson * Written by Bill Paul <wpaul@windriver.com>
4702ac6454SAndrew Thompson * Senior Engineer
4802ac6454SAndrew Thompson * Wind River Systems
4902ac6454SAndrew Thompson */
5002ac6454SAndrew Thompson
5102ac6454SAndrew Thompson /*
5202ac6454SAndrew Thompson * The AX88172 provides USB ethernet supports at 10 and 100Mbps.
5302ac6454SAndrew Thompson * It uses an external PHY (reference designs use a RealTek chip),
5402ac6454SAndrew Thompson * and has a 64-bit multicast hash filter. There is some information
5502ac6454SAndrew Thompson * missing from the manual which one needs to know in order to make
5602ac6454SAndrew Thompson * the chip function:
5702ac6454SAndrew Thompson *
5802ac6454SAndrew Thompson * - You must set bit 7 in the RX control register, otherwise the
5902ac6454SAndrew Thompson * chip won't receive any packets.
6002ac6454SAndrew Thompson * - You must initialize all 3 IPG registers, or you won't be able
6102ac6454SAndrew Thompson * to send any packets.
6202ac6454SAndrew Thompson *
6302ac6454SAndrew Thompson * Note that this device appears to only support loading the station
645aa0576bSEd Maste * address via autload from the EEPROM (i.e. there's no way to manually
6502ac6454SAndrew Thompson * set it).
6602ac6454SAndrew Thompson *
6702ac6454SAndrew Thompson * (Adam Weinberger wanted me to name this driver if_gir.c.)
6802ac6454SAndrew Thompson */
6902ac6454SAndrew Thompson
7002ac6454SAndrew Thompson /*
7102ac6454SAndrew Thompson * Ax88178 and Ax88772 support backported from the OpenBSD driver.
7202ac6454SAndrew Thompson * 2007/02/12, J.R. Oldroyd, fbsd@opal.com
7302ac6454SAndrew Thompson *
7402ac6454SAndrew Thompson * Manual here:
7502ac6454SAndrew Thompson * http://www.asix.com.tw/FrootAttach/datasheet/AX88178_datasheet_Rev10.pdf
7602ac6454SAndrew Thompson * http://www.asix.com.tw/FrootAttach/datasheet/AX88772_datasheet_Rev10.pdf
7702ac6454SAndrew Thompson */
7802ac6454SAndrew Thompson
79ed6d949aSAndrew Thompson #include <sys/param.h>
80ed6d949aSAndrew Thompson #include <sys/systm.h>
81ed6d949aSAndrew Thompson #include <sys/bus.h>
82ed6d949aSAndrew Thompson #include <sys/condvar.h>
83cdc2a5ecSPyun YongHyeon #include <sys/endian.h>
84cdc2a5ecSPyun YongHyeon #include <sys/kernel.h>
85cdc2a5ecSPyun YongHyeon #include <sys/lock.h>
86cdc2a5ecSPyun YongHyeon #include <sys/malloc.h>
87cdc2a5ecSPyun YongHyeon #include <sys/mbuf.h>
88cdc2a5ecSPyun YongHyeon #include <sys/module.h>
89cdc2a5ecSPyun YongHyeon #include <sys/mutex.h>
90cdc2a5ecSPyun YongHyeon #include <sys/socket.h>
91cdc2a5ecSPyun YongHyeon #include <sys/sockio.h>
92ed6d949aSAndrew Thompson #include <sys/sysctl.h>
93ed6d949aSAndrew Thompson #include <sys/sx.h>
94cdc2a5ecSPyun YongHyeon
95cdc2a5ecSPyun YongHyeon #include <net/if.h>
9676039bc8SGleb Smirnoff #include <net/if_var.h>
97cdc2a5ecSPyun YongHyeon #include <net/ethernet.h>
98cdc2a5ecSPyun YongHyeon #include <net/if_types.h>
99cdc2a5ecSPyun YongHyeon #include <net/if_media.h>
100cdc2a5ecSPyun YongHyeon #include <net/if_vlan_var.h>
101cdc2a5ecSPyun YongHyeon
102cdc2a5ecSPyun YongHyeon #include <dev/mii/mii.h>
103cdc2a5ecSPyun YongHyeon #include <dev/mii/miivar.h>
104ed6d949aSAndrew Thompson
10502ac6454SAndrew Thompson #include <dev/usb/usb.h>
106ed6d949aSAndrew Thompson #include <dev/usb/usbdi.h>
107ed6d949aSAndrew Thompson #include <dev/usb/usbdi_util.h>
108ed6d949aSAndrew Thompson #include "usbdevs.h"
10902ac6454SAndrew Thompson
11002ac6454SAndrew Thompson #define USB_DEBUG_VAR axe_debug
11102ac6454SAndrew Thompson #include <dev/usb/usb_debug.h>
112ed6d949aSAndrew Thompson #include <dev/usb/usb_process.h>
11302ac6454SAndrew Thompson
11402ac6454SAndrew Thompson #include <dev/usb/net/usb_ethernet.h>
11502ac6454SAndrew Thompson #include <dev/usb/net/if_axereg.h>
11602ac6454SAndrew Thompson
11731c484adSJustin Hibbits #include "miibus_if.h"
11831c484adSJustin Hibbits
11902ac6454SAndrew Thompson /*
12002ac6454SAndrew Thompson * AXE_178_MAX_FRAME_BURST
12102ac6454SAndrew Thompson * max frame burst size for Ax88178 and Ax88772
12202ac6454SAndrew Thompson * 0 2048 bytes
12302ac6454SAndrew Thompson * 1 4096 bytes
12402ac6454SAndrew Thompson * 2 8192 bytes
12502ac6454SAndrew Thompson * 3 16384 bytes
12602ac6454SAndrew Thompson * use the largest your system can handle without USB stalling.
12702ac6454SAndrew Thompson *
12802ac6454SAndrew Thompson * NB: 88772 parts appear to generate lots of input errors with
12902ac6454SAndrew Thompson * a 2K rx buffer and 8K is only slightly faster than 4K on an
13002ac6454SAndrew Thompson * EHCI port on a T42 so change at your own risk.
13102ac6454SAndrew Thompson */
13202ac6454SAndrew Thompson #define AXE_178_MAX_FRAME_BURST 1
13302ac6454SAndrew Thompson
134cdc2a5ecSPyun YongHyeon #define AXE_CSUM_FEATURES (CSUM_IP | CSUM_TCP | CSUM_UDP)
135cdc2a5ecSPyun YongHyeon
136b850ecc1SAndrew Thompson #ifdef USB_DEBUG
13702ac6454SAndrew Thompson static int axe_debug = 0;
13802ac6454SAndrew Thompson
139f8d2b1f3SPawel Biernacki static SYSCTL_NODE(_hw_usb, OID_AUTO, axe, CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
140f8d2b1f3SPawel Biernacki "USB axe");
141ece4b0bdSHans Petter Selasky SYSCTL_INT(_hw_usb_axe, OID_AUTO, debug, CTLFLAG_RWTUN, &axe_debug, 0,
14202ac6454SAndrew Thompson "Debug level");
14302ac6454SAndrew Thompson #endif
14402ac6454SAndrew Thompson
14502ac6454SAndrew Thompson /*
14602ac6454SAndrew Thompson * Various supported device vendors/products.
14702ac6454SAndrew Thompson */
148f1a16106SHans Petter Selasky static const STRUCT_USB_HOST_ID axe_devs[] = {
1499e6b5313SAndrew Thompson #define AXE_DEV(v,p,i) { USB_VPI(USB_VENDOR_##v, USB_PRODUCT_##v##_##p, i) }
1509e6b5313SAndrew Thompson AXE_DEV(ABOCOM, UF200, 0),
1519e6b5313SAndrew Thompson AXE_DEV(ACERCM, EP1427X2, 0),
1529e6b5313SAndrew Thompson AXE_DEV(APPLE, ETHERNET, AXE_FLAG_772),
1539e6b5313SAndrew Thompson AXE_DEV(ASIX, AX88172, 0),
1549e6b5313SAndrew Thompson AXE_DEV(ASIX, AX88178, AXE_FLAG_178),
1559e6b5313SAndrew Thompson AXE_DEV(ASIX, AX88772, AXE_FLAG_772),
15645b0a349SPyun YongHyeon AXE_DEV(ASIX, AX88772A, AXE_FLAG_772A),
15714ae1fa4SPyun YongHyeon AXE_DEV(ASIX, AX88772B, AXE_FLAG_772B),
1580022629fSKevin Lo AXE_DEV(ASIX, AX88772B_1, AXE_FLAG_772B),
1599e6b5313SAndrew Thompson AXE_DEV(ATEN, UC210T, 0),
1609e6b5313SAndrew Thompson AXE_DEV(BELKIN, F5D5055, AXE_FLAG_178),
1619e6b5313SAndrew Thompson AXE_DEV(BILLIONTON, USB2AR, 0),
16245b0a349SPyun YongHyeon AXE_DEV(CISCOLINKSYS, USB200MV2, AXE_FLAG_772A),
1639e6b5313SAndrew Thompson AXE_DEV(COREGA, FETHER_USB2_TX, 0),
1649e6b5313SAndrew Thompson AXE_DEV(DLINK, DUBE100, 0),
1659e6b5313SAndrew Thompson AXE_DEV(DLINK, DUBE100B1, AXE_FLAG_772),
1661ef133b3SHans Petter Selasky AXE_DEV(DLINK, DUBE100C1, AXE_FLAG_772B),
1679e6b5313SAndrew Thompson AXE_DEV(GOODWAY, GWUSB2E, 0),
1689e6b5313SAndrew Thompson AXE_DEV(IODATA, ETGUS2, AXE_FLAG_178),
1699e6b5313SAndrew Thompson AXE_DEV(JVC, MP_PRX1, 0),
1707008404dSPyun YongHyeon AXE_DEV(LENOVO, ETHERNET, AXE_FLAG_772B),
1719e6b5313SAndrew Thompson AXE_DEV(LINKSYS2, USB200M, 0),
1729e6b5313SAndrew Thompson AXE_DEV(LINKSYS4, USB1000, AXE_FLAG_178),
17387b6f185SMIHIRA Sanpei Yoshiro AXE_DEV(LOGITEC, LAN_GTJU2A, AXE_FLAG_178),
1749e6b5313SAndrew Thompson AXE_DEV(MELCO, LUAU2KTX, 0),
17587b6f185SMIHIRA Sanpei Yoshiro AXE_DEV(MELCO, LUA3U2AGT, AXE_FLAG_178),
1769e6b5313SAndrew Thompson AXE_DEV(NETGEAR, FA120, 0),
1779e6b5313SAndrew Thompson AXE_DEV(OQO, ETHER01PLUS, AXE_FLAG_772),
1789e6b5313SAndrew Thompson AXE_DEV(PLANEX3, GU1000T, AXE_FLAG_178),
1799e6b5313SAndrew Thompson AXE_DEV(SITECOM, LN029, 0),
1809e6b5313SAndrew Thompson AXE_DEV(SITECOMEU, LN028, AXE_FLAG_178),
181dd876af4SKristof Provost AXE_DEV(SITECOMEU, LN031, AXE_FLAG_178),
1829e6b5313SAndrew Thompson AXE_DEV(SYSTEMTALKS, SGCX2UL, 0),
1839e6b5313SAndrew Thompson #undef AXE_DEV
18402ac6454SAndrew Thompson };
18502ac6454SAndrew Thompson
18602ac6454SAndrew Thompson static device_probe_t axe_probe;
18702ac6454SAndrew Thompson static device_attach_t axe_attach;
18802ac6454SAndrew Thompson static device_detach_t axe_detach;
18902ac6454SAndrew Thompson
190e0a69b51SAndrew Thompson static usb_callback_t axe_bulk_read_callback;
191e0a69b51SAndrew Thompson static usb_callback_t axe_bulk_write_callback;
19202ac6454SAndrew Thompson
19302ac6454SAndrew Thompson static miibus_readreg_t axe_miibus_readreg;
19402ac6454SAndrew Thompson static miibus_writereg_t axe_miibus_writereg;
19502ac6454SAndrew Thompson static miibus_statchg_t axe_miibus_statchg;
19602ac6454SAndrew Thompson
197e0a69b51SAndrew Thompson static uether_fn_t axe_attach_post;
198e0a69b51SAndrew Thompson static uether_fn_t axe_init;
199e0a69b51SAndrew Thompson static uether_fn_t axe_stop;
200e0a69b51SAndrew Thompson static uether_fn_t axe_start;
201e0a69b51SAndrew Thompson static uether_fn_t axe_tick;
202e0a69b51SAndrew Thompson static uether_fn_t axe_setmulti;
203e0a69b51SAndrew Thompson static uether_fn_t axe_setpromisc;
20402ac6454SAndrew Thompson
205cdc2a5ecSPyun YongHyeon static int axe_attach_post_sub(struct usb_ether *);
206*935b194dSJustin Hibbits static int axe_ifmedia_upd(if_t);
207*935b194dSJustin Hibbits static void axe_ifmedia_sts(if_t, struct ifmediareq *);
20802ac6454SAndrew Thompson static int axe_cmd(struct axe_softc *, int, int, int, void *);
20902ac6454SAndrew Thompson static void axe_ax88178_init(struct axe_softc *);
21002ac6454SAndrew Thompson static void axe_ax88772_init(struct axe_softc *);
21114ae1fa4SPyun YongHyeon static void axe_ax88772_phywake(struct axe_softc *);
21245b0a349SPyun YongHyeon static void axe_ax88772a_init(struct axe_softc *);
21314ae1fa4SPyun YongHyeon static void axe_ax88772b_init(struct axe_softc *);
21402ac6454SAndrew Thompson static int axe_get_phyno(struct axe_softc *, int);
215*935b194dSJustin Hibbits static int axe_ioctl(if_t, u_long, caddr_t);
216cdc2a5ecSPyun YongHyeon static int axe_rx_frame(struct usb_ether *, struct usb_page_cache *, int);
217cdc2a5ecSPyun YongHyeon static int axe_rxeof(struct usb_ether *, struct usb_page_cache *,
21862d42655SHans Petter Selasky unsigned offset, unsigned, struct axe_csum_hdr *);
219cdc2a5ecSPyun YongHyeon static void axe_csum_cfg(struct usb_ether *);
22002ac6454SAndrew Thompson
221760bc48eSAndrew Thompson static const struct usb_config axe_config[AXE_N_TRANSFER] = {
22202ac6454SAndrew Thompson [AXE_BULK_DT_WR] = {
22302ac6454SAndrew Thompson .type = UE_BULK,
22402ac6454SAndrew Thompson .endpoint = UE_ADDR_ANY,
22502ac6454SAndrew Thompson .direction = UE_DIR_OUT,
22665c12bf5SPyun YongHyeon .frames = 16,
22765c12bf5SPyun YongHyeon .bufsize = 16 * MCLBYTES,
2284eae601eSAndrew Thompson .flags = {.pipe_bof = 1,.force_short_xfer = 1,},
2294eae601eSAndrew Thompson .callback = axe_bulk_write_callback,
2304eae601eSAndrew Thompson .timeout = 10000, /* 10 seconds */
23102ac6454SAndrew Thompson },
23202ac6454SAndrew Thompson
23302ac6454SAndrew Thompson [AXE_BULK_DT_RD] = {
23402ac6454SAndrew Thompson .type = UE_BULK,
23502ac6454SAndrew Thompson .endpoint = UE_ADDR_ANY,
23602ac6454SAndrew Thompson .direction = UE_DIR_IN,
2373ac526e0SAndrew Thompson .bufsize = 16384, /* bytes */
2384eae601eSAndrew Thompson .flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
2394eae601eSAndrew Thompson .callback = axe_bulk_read_callback,
2404eae601eSAndrew Thompson .timeout = 0, /* no timeout */
24102ac6454SAndrew Thompson },
24202ac6454SAndrew Thompson };
24302ac6454SAndrew Thompson
24414ae1fa4SPyun YongHyeon static const struct ax88772b_mfb ax88772b_mfb_table[] = {
24514ae1fa4SPyun YongHyeon { 0x8000, 0x8001, 2048 },
24614ae1fa4SPyun YongHyeon { 0x8100, 0x8147, 4096},
24714ae1fa4SPyun YongHyeon { 0x8200, 0x81EB, 6144},
24814ae1fa4SPyun YongHyeon { 0x8300, 0x83D7, 8192},
24914ae1fa4SPyun YongHyeon { 0x8400, 0x851E, 16384},
25014ae1fa4SPyun YongHyeon { 0x8500, 0x8666, 20480},
25114ae1fa4SPyun YongHyeon { 0x8600, 0x87AE, 24576},
25214ae1fa4SPyun YongHyeon { 0x8700, 0x8A3D, 32768}
25314ae1fa4SPyun YongHyeon };
25414ae1fa4SPyun YongHyeon
25502ac6454SAndrew Thompson static device_method_t axe_methods[] = {
25602ac6454SAndrew Thompson /* Device interface */
25702ac6454SAndrew Thompson DEVMETHOD(device_probe, axe_probe),
25802ac6454SAndrew Thompson DEVMETHOD(device_attach, axe_attach),
25902ac6454SAndrew Thompson DEVMETHOD(device_detach, axe_detach),
26002ac6454SAndrew Thompson
26102ac6454SAndrew Thompson /* MII interface */
26202ac6454SAndrew Thompson DEVMETHOD(miibus_readreg, axe_miibus_readreg),
26302ac6454SAndrew Thompson DEVMETHOD(miibus_writereg, axe_miibus_writereg),
26402ac6454SAndrew Thompson DEVMETHOD(miibus_statchg, axe_miibus_statchg),
26502ac6454SAndrew Thompson
2664b7ec270SMarius Strobl DEVMETHOD_END
26702ac6454SAndrew Thompson };
26802ac6454SAndrew Thompson
26902ac6454SAndrew Thompson static driver_t axe_driver = {
27002ac6454SAndrew Thompson .name = "axe",
27102ac6454SAndrew Thompson .methods = axe_methods,
27202ac6454SAndrew Thompson .size = sizeof(struct axe_softc),
27302ac6454SAndrew Thompson };
27402ac6454SAndrew Thompson
275bc9372d7SJohn Baldwin DRIVER_MODULE(axe, uhub, axe_driver, NULL, NULL);
2763e38757dSJohn Baldwin DRIVER_MODULE(miibus, axe, miibus_driver, 0, 0);
27702ac6454SAndrew Thompson MODULE_DEPEND(axe, uether, 1, 1, 1);
27802ac6454SAndrew Thompson MODULE_DEPEND(axe, usb, 1, 1, 1);
27902ac6454SAndrew Thompson MODULE_DEPEND(axe, ether, 1, 1, 1);
28002ac6454SAndrew Thompson MODULE_DEPEND(axe, miibus, 1, 1, 1);
281910cb8feSAndrew Thompson MODULE_VERSION(axe, 1);
282f809f280SWarner Losh USB_PNP_HOST_INFO(axe_devs);
28302ac6454SAndrew Thompson
284760bc48eSAndrew Thompson static const struct usb_ether_methods axe_ue_methods = {
28502ac6454SAndrew Thompson .ue_attach_post = axe_attach_post,
286cdc2a5ecSPyun YongHyeon .ue_attach_post_sub = axe_attach_post_sub,
28702ac6454SAndrew Thompson .ue_start = axe_start,
28802ac6454SAndrew Thompson .ue_init = axe_init,
28902ac6454SAndrew Thompson .ue_stop = axe_stop,
29002ac6454SAndrew Thompson .ue_tick = axe_tick,
29102ac6454SAndrew Thompson .ue_setmulti = axe_setmulti,
29202ac6454SAndrew Thompson .ue_setpromisc = axe_setpromisc,
29302ac6454SAndrew Thompson .ue_mii_upd = axe_ifmedia_upd,
29402ac6454SAndrew Thompson .ue_mii_sts = axe_ifmedia_sts,
29502ac6454SAndrew Thompson };
29602ac6454SAndrew Thompson
29702ac6454SAndrew Thompson static int
axe_cmd(struct axe_softc * sc,int cmd,int index,int val,void * buf)29802ac6454SAndrew Thompson axe_cmd(struct axe_softc *sc, int cmd, int index, int val, void *buf)
29902ac6454SAndrew Thompson {
300760bc48eSAndrew Thompson struct usb_device_request req;
301e0a69b51SAndrew Thompson usb_error_t err;
30202ac6454SAndrew Thompson
30302ac6454SAndrew Thompson AXE_LOCK_ASSERT(sc, MA_OWNED);
30402ac6454SAndrew Thompson
30502ac6454SAndrew Thompson req.bmRequestType = (AXE_CMD_IS_WRITE(cmd) ?
30602ac6454SAndrew Thompson UT_WRITE_VENDOR_DEVICE :
30702ac6454SAndrew Thompson UT_READ_VENDOR_DEVICE);
30802ac6454SAndrew Thompson req.bRequest = AXE_CMD_CMD(cmd);
30902ac6454SAndrew Thompson USETW(req.wValue, val);
31002ac6454SAndrew Thompson USETW(req.wIndex, index);
31102ac6454SAndrew Thompson USETW(req.wLength, AXE_CMD_LEN(cmd));
31202ac6454SAndrew Thompson
313a593f6b8SAndrew Thompson err = uether_do_request(&sc->sc_ue, &req, buf, 1000);
31402ac6454SAndrew Thompson
31502ac6454SAndrew Thompson return (err);
31602ac6454SAndrew Thompson }
31702ac6454SAndrew Thompson
31802ac6454SAndrew Thompson static int
axe_miibus_readreg(device_t dev,int phy,int reg)31902ac6454SAndrew Thompson axe_miibus_readreg(device_t dev, int phy, int reg)
32002ac6454SAndrew Thompson {
32102ac6454SAndrew Thompson struct axe_softc *sc = device_get_softc(dev);
32202ac6454SAndrew Thompson uint16_t val;
32302ac6454SAndrew Thompson int locked;
32402ac6454SAndrew Thompson
32502ac6454SAndrew Thompson locked = mtx_owned(&sc->sc_mtx);
32602ac6454SAndrew Thompson if (!locked)
32702ac6454SAndrew Thompson AXE_LOCK(sc);
32802ac6454SAndrew Thompson
32902ac6454SAndrew Thompson axe_cmd(sc, AXE_CMD_MII_OPMODE_SW, 0, 0, NULL);
33002ac6454SAndrew Thompson axe_cmd(sc, AXE_CMD_MII_READ_REG, reg, phy, &val);
33102ac6454SAndrew Thompson axe_cmd(sc, AXE_CMD_MII_OPMODE_HW, 0, 0, NULL);
33202ac6454SAndrew Thompson
33302ac6454SAndrew Thompson val = le16toh(val);
3348c09fbe4SPyun YongHyeon if (AXE_IS_772(sc) && reg == MII_BMSR) {
33502ac6454SAndrew Thompson /*
33602ac6454SAndrew Thompson * BMSR of AX88772 indicates that it supports extended
33702ac6454SAndrew Thompson * capability but the extended status register is
33802ac6454SAndrew Thompson * revered for embedded ethernet PHY. So clear the
33902ac6454SAndrew Thompson * extended capability bit of BMSR.
34002ac6454SAndrew Thompson */
34102ac6454SAndrew Thompson val &= ~BMSR_EXTCAP;
34202ac6454SAndrew Thompson }
34302ac6454SAndrew Thompson
34402ac6454SAndrew Thompson if (!locked)
34502ac6454SAndrew Thompson AXE_UNLOCK(sc);
34602ac6454SAndrew Thompson return (val);
34702ac6454SAndrew Thompson }
34802ac6454SAndrew Thompson
34902ac6454SAndrew Thompson static int
axe_miibus_writereg(device_t dev,int phy,int reg,int val)35002ac6454SAndrew Thompson axe_miibus_writereg(device_t dev, int phy, int reg, int val)
35102ac6454SAndrew Thompson {
35202ac6454SAndrew Thompson struct axe_softc *sc = device_get_softc(dev);
35302ac6454SAndrew Thompson int locked;
35402ac6454SAndrew Thompson
35536002e92SAndrew Thompson val = htole32(val);
35602ac6454SAndrew Thompson locked = mtx_owned(&sc->sc_mtx);
35702ac6454SAndrew Thompson if (!locked)
35802ac6454SAndrew Thompson AXE_LOCK(sc);
35902ac6454SAndrew Thompson
36002ac6454SAndrew Thompson axe_cmd(sc, AXE_CMD_MII_OPMODE_SW, 0, 0, NULL);
36102ac6454SAndrew Thompson axe_cmd(sc, AXE_CMD_MII_WRITE_REG, reg, phy, &val);
36202ac6454SAndrew Thompson axe_cmd(sc, AXE_CMD_MII_OPMODE_HW, 0, 0, NULL);
36302ac6454SAndrew Thompson
36402ac6454SAndrew Thompson if (!locked)
36502ac6454SAndrew Thompson AXE_UNLOCK(sc);
36602ac6454SAndrew Thompson return (0);
36702ac6454SAndrew Thompson }
36802ac6454SAndrew Thompson
36902ac6454SAndrew Thompson static void
axe_miibus_statchg(device_t dev)37002ac6454SAndrew Thompson axe_miibus_statchg(device_t dev)
37102ac6454SAndrew Thompson {
37202ac6454SAndrew Thompson struct axe_softc *sc = device_get_softc(dev);
37302ac6454SAndrew Thompson struct mii_data *mii = GET_MII(sc);
374*935b194dSJustin Hibbits if_t ifp;
37502ac6454SAndrew Thompson uint16_t val;
37602ac6454SAndrew Thompson int err, locked;
37702ac6454SAndrew Thompson
37802ac6454SAndrew Thompson locked = mtx_owned(&sc->sc_mtx);
37902ac6454SAndrew Thompson if (!locked)
38002ac6454SAndrew Thompson AXE_LOCK(sc);
38102ac6454SAndrew Thompson
382a593f6b8SAndrew Thompson ifp = uether_getifp(&sc->sc_ue);
38302ac6454SAndrew Thompson if (mii == NULL || ifp == NULL ||
384*935b194dSJustin Hibbits (if_getdrvflags(ifp) & IFF_DRV_RUNNING) == 0)
38502ac6454SAndrew Thompson goto done;
38602ac6454SAndrew Thompson
38702ac6454SAndrew Thompson sc->sc_flags &= ~AXE_FLAG_LINK;
38802ac6454SAndrew Thompson if ((mii->mii_media_status & (IFM_ACTIVE | IFM_AVALID)) ==
38902ac6454SAndrew Thompson (IFM_ACTIVE | IFM_AVALID)) {
39002ac6454SAndrew Thompson switch (IFM_SUBTYPE(mii->mii_media_active)) {
39102ac6454SAndrew Thompson case IFM_10_T:
39202ac6454SAndrew Thompson case IFM_100_TX:
39302ac6454SAndrew Thompson sc->sc_flags |= AXE_FLAG_LINK;
39402ac6454SAndrew Thompson break;
39502ac6454SAndrew Thompson case IFM_1000_T:
39602ac6454SAndrew Thompson if ((sc->sc_flags & AXE_FLAG_178) == 0)
39702ac6454SAndrew Thompson break;
39802ac6454SAndrew Thompson sc->sc_flags |= AXE_FLAG_LINK;
39902ac6454SAndrew Thompson break;
40002ac6454SAndrew Thompson default:
40102ac6454SAndrew Thompson break;
40202ac6454SAndrew Thompson }
40302ac6454SAndrew Thompson }
40402ac6454SAndrew Thompson
40502ac6454SAndrew Thompson /* Lost link, do nothing. */
40602ac6454SAndrew Thompson if ((sc->sc_flags & AXE_FLAG_LINK) == 0)
40702ac6454SAndrew Thompson goto done;
40802ac6454SAndrew Thompson
40902ac6454SAndrew Thompson val = 0;
410cdc2a5ecSPyun YongHyeon if ((IFM_OPTIONS(mii->mii_media_active) & IFM_FDX) != 0) {
41102ac6454SAndrew Thompson val |= AXE_MEDIA_FULL_DUPLEX;
4128c09fbe4SPyun YongHyeon if (AXE_IS_178_FAMILY(sc)) {
413cdc2a5ecSPyun YongHyeon if ((IFM_OPTIONS(mii->mii_media_active) &
414cdc2a5ecSPyun YongHyeon IFM_ETH_TXPAUSE) != 0)
415cdc2a5ecSPyun YongHyeon val |= AXE_178_MEDIA_TXFLOW_CONTROL_EN;
416cdc2a5ecSPyun YongHyeon if ((IFM_OPTIONS(mii->mii_media_active) &
417cdc2a5ecSPyun YongHyeon IFM_ETH_RXPAUSE) != 0)
418cdc2a5ecSPyun YongHyeon val |= AXE_178_MEDIA_RXFLOW_CONTROL_EN;
419cdc2a5ecSPyun YongHyeon }
420cdc2a5ecSPyun YongHyeon }
421cdc2a5ecSPyun YongHyeon if (AXE_IS_178_FAMILY(sc)) {
42202ac6454SAndrew Thompson val |= AXE_178_MEDIA_RX_EN | AXE_178_MEDIA_MAGIC;
42302ac6454SAndrew Thompson if ((sc->sc_flags & AXE_FLAG_178) != 0)
42402ac6454SAndrew Thompson val |= AXE_178_MEDIA_ENCK;
42502ac6454SAndrew Thompson switch (IFM_SUBTYPE(mii->mii_media_active)) {
42602ac6454SAndrew Thompson case IFM_1000_T:
42702ac6454SAndrew Thompson val |= AXE_178_MEDIA_GMII | AXE_178_MEDIA_ENCK;
42802ac6454SAndrew Thompson break;
42902ac6454SAndrew Thompson case IFM_100_TX:
43002ac6454SAndrew Thompson val |= AXE_178_MEDIA_100TX;
43102ac6454SAndrew Thompson break;
43202ac6454SAndrew Thompson case IFM_10_T:
43302ac6454SAndrew Thompson /* doesn't need to be handled */
43402ac6454SAndrew Thompson break;
43502ac6454SAndrew Thompson }
43602ac6454SAndrew Thompson }
43702ac6454SAndrew Thompson err = axe_cmd(sc, AXE_CMD_WRITE_MEDIA, 0, val, NULL);
43802ac6454SAndrew Thompson if (err)
43902ac6454SAndrew Thompson device_printf(dev, "media change failed, error %d\n", err);
44002ac6454SAndrew Thompson done:
44102ac6454SAndrew Thompson if (!locked)
44202ac6454SAndrew Thompson AXE_UNLOCK(sc);
44302ac6454SAndrew Thompson }
44402ac6454SAndrew Thompson
44502ac6454SAndrew Thompson /*
44602ac6454SAndrew Thompson * Set media options.
44702ac6454SAndrew Thompson */
44802ac6454SAndrew Thompson static int
axe_ifmedia_upd(if_t ifp)449*935b194dSJustin Hibbits axe_ifmedia_upd(if_t ifp)
45002ac6454SAndrew Thompson {
451*935b194dSJustin Hibbits struct axe_softc *sc = if_getsoftc(ifp);
45202ac6454SAndrew Thompson struct mii_data *mii = GET_MII(sc);
4533fcb7a53SMarius Strobl struct mii_softc *miisc;
45402ac6454SAndrew Thompson int error;
45502ac6454SAndrew Thompson
45602ac6454SAndrew Thompson AXE_LOCK_ASSERT(sc, MA_OWNED);
45702ac6454SAndrew Thompson
45802ac6454SAndrew Thompson LIST_FOREACH(miisc, &mii->mii_phys, mii_list)
4593fcb7a53SMarius Strobl PHY_RESET(miisc);
46002ac6454SAndrew Thompson error = mii_mediachg(mii);
46102ac6454SAndrew Thompson return (error);
46202ac6454SAndrew Thompson }
46302ac6454SAndrew Thompson
46402ac6454SAndrew Thompson /*
46502ac6454SAndrew Thompson * Report current media status.
46602ac6454SAndrew Thompson */
46702ac6454SAndrew Thompson static void
axe_ifmedia_sts(if_t ifp,struct ifmediareq * ifmr)468*935b194dSJustin Hibbits axe_ifmedia_sts(if_t ifp, struct ifmediareq *ifmr)
46902ac6454SAndrew Thompson {
470*935b194dSJustin Hibbits struct axe_softc *sc = if_getsoftc(ifp);
47102ac6454SAndrew Thompson struct mii_data *mii = GET_MII(sc);
47202ac6454SAndrew Thompson
47302ac6454SAndrew Thompson AXE_LOCK(sc);
47402ac6454SAndrew Thompson mii_pollstat(mii);
47502ac6454SAndrew Thompson ifmr->ifm_active = mii->mii_media_active;
47602ac6454SAndrew Thompson ifmr->ifm_status = mii->mii_media_status;
477e9e549efSPyun YongHyeon AXE_UNLOCK(sc);
47802ac6454SAndrew Thompson }
47902ac6454SAndrew Thompson
4808fd18ef9SGleb Smirnoff static u_int
axe_hash_maddr(void * arg,struct sockaddr_dl * sdl,u_int cnt)4818fd18ef9SGleb Smirnoff axe_hash_maddr(void *arg, struct sockaddr_dl *sdl, u_int cnt)
4828fd18ef9SGleb Smirnoff {
4838fd18ef9SGleb Smirnoff uint8_t *hashtbl = arg;
4848fd18ef9SGleb Smirnoff uint32_t h;
4858fd18ef9SGleb Smirnoff
4868fd18ef9SGleb Smirnoff h = ether_crc32_be(LLADDR(sdl), ETHER_ADDR_LEN) >> 26;
4878fd18ef9SGleb Smirnoff hashtbl[h / 8] |= 1 << (h % 8);
4888fd18ef9SGleb Smirnoff
4898fd18ef9SGleb Smirnoff return (1);
4908fd18ef9SGleb Smirnoff }
4918fd18ef9SGleb Smirnoff
49202ac6454SAndrew Thompson static void
axe_setmulti(struct usb_ether * ue)493760bc48eSAndrew Thompson axe_setmulti(struct usb_ether *ue)
49402ac6454SAndrew Thompson {
495a593f6b8SAndrew Thompson struct axe_softc *sc = uether_getsc(ue);
496*935b194dSJustin Hibbits if_t ifp = uether_getifp(ue);
49702ac6454SAndrew Thompson uint16_t rxmode;
49802ac6454SAndrew Thompson uint8_t hashtbl[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
49902ac6454SAndrew Thompson
50002ac6454SAndrew Thompson AXE_LOCK_ASSERT(sc, MA_OWNED);
50102ac6454SAndrew Thompson
50202ac6454SAndrew Thompson axe_cmd(sc, AXE_CMD_RXCTL_READ, 0, 0, &rxmode);
50302ac6454SAndrew Thompson rxmode = le16toh(rxmode);
50402ac6454SAndrew Thompson
505*935b194dSJustin Hibbits if (if_getflags(ifp) & (IFF_ALLMULTI | IFF_PROMISC)) {
50602ac6454SAndrew Thompson rxmode |= AXE_RXCMD_ALLMULTI;
50702ac6454SAndrew Thompson axe_cmd(sc, AXE_CMD_RXCTL_WRITE, 0, rxmode, NULL);
50802ac6454SAndrew Thompson return;
50902ac6454SAndrew Thompson }
51002ac6454SAndrew Thompson rxmode &= ~AXE_RXCMD_ALLMULTI;
51102ac6454SAndrew Thompson
5128fd18ef9SGleb Smirnoff if_foreach_llmaddr(ifp, axe_hash_maddr, &hashtbl);
51302ac6454SAndrew Thompson
51402ac6454SAndrew Thompson axe_cmd(sc, AXE_CMD_WRITE_MCAST, 0, 0, (void *)&hashtbl);
51502ac6454SAndrew Thompson axe_cmd(sc, AXE_CMD_RXCTL_WRITE, 0, rxmode, NULL);
51602ac6454SAndrew Thompson }
51702ac6454SAndrew Thompson
51802ac6454SAndrew Thompson static int
axe_get_phyno(struct axe_softc * sc,int sel)51902ac6454SAndrew Thompson axe_get_phyno(struct axe_softc *sc, int sel)
52002ac6454SAndrew Thompson {
52102ac6454SAndrew Thompson int phyno;
52202ac6454SAndrew Thompson
52302ac6454SAndrew Thompson switch (AXE_PHY_TYPE(sc->sc_phyaddrs[sel])) {
52402ac6454SAndrew Thompson case PHY_TYPE_100_HOME:
52502ac6454SAndrew Thompson case PHY_TYPE_GIG:
52602ac6454SAndrew Thompson phyno = AXE_PHY_NO(sc->sc_phyaddrs[sel]);
52702ac6454SAndrew Thompson break;
52802ac6454SAndrew Thompson case PHY_TYPE_SPECIAL:
52902ac6454SAndrew Thompson /* FALLTHROUGH */
53002ac6454SAndrew Thompson case PHY_TYPE_RSVD:
53102ac6454SAndrew Thompson /* FALLTHROUGH */
53202ac6454SAndrew Thompson case PHY_TYPE_NON_SUP:
53302ac6454SAndrew Thompson /* FALLTHROUGH */
53402ac6454SAndrew Thompson default:
53502ac6454SAndrew Thompson phyno = -1;
53602ac6454SAndrew Thompson break;
53702ac6454SAndrew Thompson }
53802ac6454SAndrew Thompson
53902ac6454SAndrew Thompson return (phyno);
54002ac6454SAndrew Thompson }
54102ac6454SAndrew Thompson
542edd913ebSAndrew Thompson #define AXE_GPIO_WRITE(x, y) do { \
543edd913ebSAndrew Thompson axe_cmd(sc, AXE_CMD_WRITE_GPIO, 0, (x), NULL); \
544edd913ebSAndrew Thompson uether_pause(ue, (y)); \
545edd913ebSAndrew Thompson } while (0)
546edd913ebSAndrew Thompson
54702ac6454SAndrew Thompson static void
axe_ax88178_init(struct axe_softc * sc)54802ac6454SAndrew Thompson axe_ax88178_init(struct axe_softc *sc)
54902ac6454SAndrew Thompson {
550edd913ebSAndrew Thompson struct usb_ether *ue;
551082b7543SPyun YongHyeon int gpio0, ledmode, phymode;
552edd913ebSAndrew Thompson uint16_t eeprom, val;
55302ac6454SAndrew Thompson
554edd913ebSAndrew Thompson ue = &sc->sc_ue;
55502ac6454SAndrew Thompson axe_cmd(sc, AXE_CMD_SROM_WR_ENABLE, 0, 0, NULL);
55602ac6454SAndrew Thompson /* XXX magic */
55702ac6454SAndrew Thompson axe_cmd(sc, AXE_CMD_SROM_READ, 0, 0x0017, &eeprom);
55802ac6454SAndrew Thompson eeprom = le16toh(eeprom);
55902ac6454SAndrew Thompson axe_cmd(sc, AXE_CMD_SROM_WR_DISABLE, 0, 0, NULL);
56002ac6454SAndrew Thompson
56102ac6454SAndrew Thompson /* if EEPROM is invalid we have to use to GPIO0 */
56202ac6454SAndrew Thompson if (eeprom == 0xffff) {
563edd913ebSAndrew Thompson phymode = AXE_PHY_MODE_MARVELL;
56402ac6454SAndrew Thompson gpio0 = 1;
565082b7543SPyun YongHyeon ledmode = 0;
56602ac6454SAndrew Thompson } else {
567edd913ebSAndrew Thompson phymode = eeprom & 0x7f;
56802ac6454SAndrew Thompson gpio0 = (eeprom & 0x80) ? 0 : 1;
569082b7543SPyun YongHyeon ledmode = eeprom >> 8;
57002ac6454SAndrew Thompson }
57102ac6454SAndrew Thompson
572edd913ebSAndrew Thompson if (bootverbose)
5736dd81ec7SPyun YongHyeon device_printf(sc->sc_ue.ue_dev,
5746dd81ec7SPyun YongHyeon "EEPROM data : 0x%04x, phymode : 0x%02x\n", eeprom,
5756dd81ec7SPyun YongHyeon phymode);
576edd913ebSAndrew Thompson /* Program GPIOs depending on PHY hardware. */
577edd913ebSAndrew Thompson switch (phymode) {
578edd913ebSAndrew Thompson case AXE_PHY_MODE_MARVELL:
579edd913ebSAndrew Thompson if (gpio0 == 1) {
580edd913ebSAndrew Thompson AXE_GPIO_WRITE(AXE_GPIO_RELOAD_EEPROM | AXE_GPIO0_EN,
581edd913ebSAndrew Thompson hz / 32);
582edd913ebSAndrew Thompson AXE_GPIO_WRITE(AXE_GPIO0_EN | AXE_GPIO2 | AXE_GPIO2_EN,
583edd913ebSAndrew Thompson hz / 32);
584edd913ebSAndrew Thompson AXE_GPIO_WRITE(AXE_GPIO0_EN | AXE_GPIO2_EN, hz / 4);
585edd913ebSAndrew Thompson AXE_GPIO_WRITE(AXE_GPIO0_EN | AXE_GPIO2 | AXE_GPIO2_EN,
586edd913ebSAndrew Thompson hz / 32);
587082b7543SPyun YongHyeon } else {
588edd913ebSAndrew Thompson AXE_GPIO_WRITE(AXE_GPIO_RELOAD_EEPROM | AXE_GPIO1 |
589082b7543SPyun YongHyeon AXE_GPIO1_EN, hz / 3);
590082b7543SPyun YongHyeon if (ledmode == 1) {
591082b7543SPyun YongHyeon AXE_GPIO_WRITE(AXE_GPIO1_EN, hz / 3);
592082b7543SPyun YongHyeon AXE_GPIO_WRITE(AXE_GPIO1 | AXE_GPIO1_EN,
593082b7543SPyun YongHyeon hz / 3);
594082b7543SPyun YongHyeon } else {
595082b7543SPyun YongHyeon AXE_GPIO_WRITE(AXE_GPIO1 | AXE_GPIO1_EN |
596082b7543SPyun YongHyeon AXE_GPIO2 | AXE_GPIO2_EN, hz / 32);
597082b7543SPyun YongHyeon AXE_GPIO_WRITE(AXE_GPIO1 | AXE_GPIO1_EN |
598082b7543SPyun YongHyeon AXE_GPIO2_EN, hz / 4);
599082b7543SPyun YongHyeon AXE_GPIO_WRITE(AXE_GPIO1 | AXE_GPIO1_EN |
600082b7543SPyun YongHyeon AXE_GPIO2 | AXE_GPIO2_EN, hz / 32);
601082b7543SPyun YongHyeon }
602082b7543SPyun YongHyeon }
603edd913ebSAndrew Thompson break;
604edd913ebSAndrew Thompson case AXE_PHY_MODE_CICADA:
6056dd81ec7SPyun YongHyeon case AXE_PHY_MODE_CICADA_V2:
6066dd81ec7SPyun YongHyeon case AXE_PHY_MODE_CICADA_V2_ASIX:
607edd913ebSAndrew Thompson if (gpio0 == 1)
608edd913ebSAndrew Thompson AXE_GPIO_WRITE(AXE_GPIO_RELOAD_EEPROM | AXE_GPIO0 |
609edd913ebSAndrew Thompson AXE_GPIO0_EN, hz / 32);
610edd913ebSAndrew Thompson else
611edd913ebSAndrew Thompson AXE_GPIO_WRITE(AXE_GPIO_RELOAD_EEPROM | AXE_GPIO1 |
612edd913ebSAndrew Thompson AXE_GPIO1_EN, hz / 32);
613edd913ebSAndrew Thompson break;
614edd913ebSAndrew Thompson case AXE_PHY_MODE_AGERE:
615edd913ebSAndrew Thompson AXE_GPIO_WRITE(AXE_GPIO_RELOAD_EEPROM | AXE_GPIO1 |
616edd913ebSAndrew Thompson AXE_GPIO1_EN, hz / 32);
617edd913ebSAndrew Thompson AXE_GPIO_WRITE(AXE_GPIO1 | AXE_GPIO1_EN | AXE_GPIO2 |
618edd913ebSAndrew Thompson AXE_GPIO2_EN, hz / 32);
619edd913ebSAndrew Thompson AXE_GPIO_WRITE(AXE_GPIO1 | AXE_GPIO1_EN | AXE_GPIO2_EN, hz / 4);
620edd913ebSAndrew Thompson AXE_GPIO_WRITE(AXE_GPIO1 | AXE_GPIO1_EN | AXE_GPIO2 |
621edd913ebSAndrew Thompson AXE_GPIO2_EN, hz / 32);
622edd913ebSAndrew Thompson break;
623edd913ebSAndrew Thompson case AXE_PHY_MODE_REALTEK_8211CL:
624edd913ebSAndrew Thompson case AXE_PHY_MODE_REALTEK_8211BN:
625edd913ebSAndrew Thompson case AXE_PHY_MODE_REALTEK_8251CL:
626edd913ebSAndrew Thompson val = gpio0 == 1 ? AXE_GPIO0 | AXE_GPIO0_EN :
627edd913ebSAndrew Thompson AXE_GPIO1 | AXE_GPIO1_EN;
628edd913ebSAndrew Thompson AXE_GPIO_WRITE(val, hz / 32);
629edd913ebSAndrew Thompson AXE_GPIO_WRITE(val | AXE_GPIO2 | AXE_GPIO2_EN, hz / 32);
630edd913ebSAndrew Thompson AXE_GPIO_WRITE(val | AXE_GPIO2_EN, hz / 4);
631edd913ebSAndrew Thompson AXE_GPIO_WRITE(val | AXE_GPIO2 | AXE_GPIO2_EN, hz / 32);
632edd913ebSAndrew Thompson if (phymode == AXE_PHY_MODE_REALTEK_8211CL) {
633edd913ebSAndrew Thompson axe_miibus_writereg(ue->ue_dev, sc->sc_phyno,
634edd913ebSAndrew Thompson 0x1F, 0x0005);
635edd913ebSAndrew Thompson axe_miibus_writereg(ue->ue_dev, sc->sc_phyno,
636edd913ebSAndrew Thompson 0x0C, 0x0000);
637edd913ebSAndrew Thompson val = axe_miibus_readreg(ue->ue_dev, sc->sc_phyno,
638edd913ebSAndrew Thompson 0x0001);
639edd913ebSAndrew Thompson axe_miibus_writereg(ue->ue_dev, sc->sc_phyno,
640edd913ebSAndrew Thompson 0x01, val | 0x0080);
641edd913ebSAndrew Thompson axe_miibus_writereg(ue->ue_dev, sc->sc_phyno,
642edd913ebSAndrew Thompson 0x1F, 0x0000);
643edd913ebSAndrew Thompson }
644edd913ebSAndrew Thompson break;
645edd913ebSAndrew Thompson default:
646edd913ebSAndrew Thompson /* Unknown PHY model or no need to program GPIOs. */
647edd913ebSAndrew Thompson break;
64802ac6454SAndrew Thompson }
64902ac6454SAndrew Thompson
65002ac6454SAndrew Thompson /* soft reset */
65102ac6454SAndrew Thompson axe_cmd(sc, AXE_CMD_SW_RESET_REG, 0, AXE_SW_RESET_CLEAR, NULL);
652edd913ebSAndrew Thompson uether_pause(ue, hz / 4);
65302ac6454SAndrew Thompson
65402ac6454SAndrew Thompson axe_cmd(sc, AXE_CMD_SW_RESET_REG, 0,
65502ac6454SAndrew Thompson AXE_SW_RESET_PRL | AXE_178_RESET_MAGIC, NULL);
656edd913ebSAndrew Thompson uether_pause(ue, hz / 4);
65702ac6454SAndrew Thompson /* Enable MII/GMII/RGMII interface to work with external PHY. */
65802ac6454SAndrew Thompson axe_cmd(sc, AXE_CMD_SW_PHY_SELECT, 0, 0, NULL);
659edd913ebSAndrew Thompson uether_pause(ue, hz / 4);
66002ac6454SAndrew Thompson
66102ac6454SAndrew Thompson axe_cmd(sc, AXE_CMD_RXCTL_WRITE, 0, 0, NULL);
66202ac6454SAndrew Thompson }
66302ac6454SAndrew Thompson
66402ac6454SAndrew Thompson static void
axe_ax88772_init(struct axe_softc * sc)66502ac6454SAndrew Thompson axe_ax88772_init(struct axe_softc *sc)
66602ac6454SAndrew Thompson {
66702ac6454SAndrew Thompson axe_cmd(sc, AXE_CMD_WRITE_GPIO, 0, 0x00b0, NULL);
668a593f6b8SAndrew Thompson uether_pause(&sc->sc_ue, hz / 16);
66902ac6454SAndrew Thompson
67002ac6454SAndrew Thompson if (sc->sc_phyno == AXE_772_PHY_NO_EPHY) {
67102ac6454SAndrew Thompson /* ask for the embedded PHY */
67202ac6454SAndrew Thompson axe_cmd(sc, AXE_CMD_SW_PHY_SELECT, 0, 0x01, NULL);
673a593f6b8SAndrew Thompson uether_pause(&sc->sc_ue, hz / 64);
67402ac6454SAndrew Thompson
67502ac6454SAndrew Thompson /* power down and reset state, pin reset state */
67602ac6454SAndrew Thompson axe_cmd(sc, AXE_CMD_SW_RESET_REG, 0,
67702ac6454SAndrew Thompson AXE_SW_RESET_CLEAR, NULL);
678a593f6b8SAndrew Thompson uether_pause(&sc->sc_ue, hz / 16);
67902ac6454SAndrew Thompson
68002ac6454SAndrew Thompson /* power down/reset state, pin operating state */
68102ac6454SAndrew Thompson axe_cmd(sc, AXE_CMD_SW_RESET_REG, 0,
68202ac6454SAndrew Thompson AXE_SW_RESET_IPPD | AXE_SW_RESET_PRL, NULL);
683a593f6b8SAndrew Thompson uether_pause(&sc->sc_ue, hz / 4);
68402ac6454SAndrew Thompson
68502ac6454SAndrew Thompson /* power up, reset */
68602ac6454SAndrew Thompson axe_cmd(sc, AXE_CMD_SW_RESET_REG, 0, AXE_SW_RESET_PRL, NULL);
68702ac6454SAndrew Thompson
68802ac6454SAndrew Thompson /* power up, operating */
68902ac6454SAndrew Thompson axe_cmd(sc, AXE_CMD_SW_RESET_REG, 0,
69002ac6454SAndrew Thompson AXE_SW_RESET_IPRL | AXE_SW_RESET_PRL, NULL);
69102ac6454SAndrew Thompson } else {
69202ac6454SAndrew Thompson /* ask for external PHY */
69302ac6454SAndrew Thompson axe_cmd(sc, AXE_CMD_SW_PHY_SELECT, 0, 0x00, NULL);
694a593f6b8SAndrew Thompson uether_pause(&sc->sc_ue, hz / 64);
69502ac6454SAndrew Thompson
69602ac6454SAndrew Thompson /* power down internal PHY */
69702ac6454SAndrew Thompson axe_cmd(sc, AXE_CMD_SW_RESET_REG, 0,
69802ac6454SAndrew Thompson AXE_SW_RESET_IPPD | AXE_SW_RESET_PRL, NULL);
69902ac6454SAndrew Thompson }
70002ac6454SAndrew Thompson
701a593f6b8SAndrew Thompson uether_pause(&sc->sc_ue, hz / 4);
70202ac6454SAndrew Thompson axe_cmd(sc, AXE_CMD_RXCTL_WRITE, 0, 0, NULL);
70302ac6454SAndrew Thompson }
70402ac6454SAndrew Thompson
70502ac6454SAndrew Thompson static void
axe_ax88772_phywake(struct axe_softc * sc)70614ae1fa4SPyun YongHyeon axe_ax88772_phywake(struct axe_softc *sc)
70745b0a349SPyun YongHyeon {
70845b0a349SPyun YongHyeon if (sc->sc_phyno == AXE_772_PHY_NO_EPHY) {
70945b0a349SPyun YongHyeon /* Manually select internal(embedded) PHY - MAC mode. */
71045b0a349SPyun YongHyeon axe_cmd(sc, AXE_CMD_SW_PHY_SELECT, 0, AXE_SW_PHY_SELECT_SS_ENB |
71145b0a349SPyun YongHyeon AXE_SW_PHY_SELECT_EMBEDDED | AXE_SW_PHY_SELECT_SS_MII,
71245b0a349SPyun YongHyeon NULL);
71345b0a349SPyun YongHyeon uether_pause(&sc->sc_ue, hz / 32);
71445b0a349SPyun YongHyeon } else {
71545b0a349SPyun YongHyeon /*
71645b0a349SPyun YongHyeon * Manually select external PHY - MAC mode.
71745b0a349SPyun YongHyeon * Reverse MII/RMII is for AX88772A PHY mode.
71845b0a349SPyun YongHyeon */
71945b0a349SPyun YongHyeon axe_cmd(sc, AXE_CMD_SW_PHY_SELECT, 0, AXE_SW_PHY_SELECT_SS_ENB |
72045b0a349SPyun YongHyeon AXE_SW_PHY_SELECT_EXT | AXE_SW_PHY_SELECT_SS_MII, NULL);
72145b0a349SPyun YongHyeon uether_pause(&sc->sc_ue, hz / 32);
72245b0a349SPyun YongHyeon }
72345b0a349SPyun YongHyeon /* Take PHY out of power down. */
72445b0a349SPyun YongHyeon axe_cmd(sc, AXE_CMD_SW_RESET_REG, 0, AXE_SW_RESET_IPPD |
72545b0a349SPyun YongHyeon AXE_SW_RESET_IPRL, NULL);
72645b0a349SPyun YongHyeon uether_pause(&sc->sc_ue, hz / 4);
72745b0a349SPyun YongHyeon axe_cmd(sc, AXE_CMD_SW_RESET_REG, 0, AXE_SW_RESET_IPRL, NULL);
72845b0a349SPyun YongHyeon uether_pause(&sc->sc_ue, hz);
72945b0a349SPyun YongHyeon axe_cmd(sc, AXE_CMD_SW_RESET_REG, 0, AXE_SW_RESET_CLEAR, NULL);
73045b0a349SPyun YongHyeon uether_pause(&sc->sc_ue, hz / 32);
73145b0a349SPyun YongHyeon axe_cmd(sc, AXE_CMD_SW_RESET_REG, 0, AXE_SW_RESET_IPRL, NULL);
73245b0a349SPyun YongHyeon uether_pause(&sc->sc_ue, hz / 32);
73314ae1fa4SPyun YongHyeon }
73414ae1fa4SPyun YongHyeon
73514ae1fa4SPyun YongHyeon static void
axe_ax88772a_init(struct axe_softc * sc)73614ae1fa4SPyun YongHyeon axe_ax88772a_init(struct axe_softc *sc)
73714ae1fa4SPyun YongHyeon {
73814ae1fa4SPyun YongHyeon struct usb_ether *ue;
73914ae1fa4SPyun YongHyeon
74014ae1fa4SPyun YongHyeon ue = &sc->sc_ue;
74114ae1fa4SPyun YongHyeon /* Reload EEPROM. */
74214ae1fa4SPyun YongHyeon AXE_GPIO_WRITE(AXE_GPIO_RELOAD_EEPROM, hz / 32);
74314ae1fa4SPyun YongHyeon axe_ax88772_phywake(sc);
74414ae1fa4SPyun YongHyeon /* Stop MAC. */
74514ae1fa4SPyun YongHyeon axe_cmd(sc, AXE_CMD_RXCTL_WRITE, 0, 0, NULL);
74614ae1fa4SPyun YongHyeon }
74714ae1fa4SPyun YongHyeon
74814ae1fa4SPyun YongHyeon static void
axe_ax88772b_init(struct axe_softc * sc)74914ae1fa4SPyun YongHyeon axe_ax88772b_init(struct axe_softc *sc)
75014ae1fa4SPyun YongHyeon {
75114ae1fa4SPyun YongHyeon struct usb_ether *ue;
75214ae1fa4SPyun YongHyeon uint16_t eeprom;
75314ae1fa4SPyun YongHyeon uint8_t *eaddr;
75414ae1fa4SPyun YongHyeon int i;
75514ae1fa4SPyun YongHyeon
75614ae1fa4SPyun YongHyeon ue = &sc->sc_ue;
75714ae1fa4SPyun YongHyeon /* Reload EEPROM. */
75814ae1fa4SPyun YongHyeon AXE_GPIO_WRITE(AXE_GPIO_RELOAD_EEPROM, hz / 32);
75914ae1fa4SPyun YongHyeon /*
76014ae1fa4SPyun YongHyeon * Save PHY power saving configuration(high byte) and
76114ae1fa4SPyun YongHyeon * clear EEPROM checksum value(low byte).
76214ae1fa4SPyun YongHyeon */
76314ae1fa4SPyun YongHyeon axe_cmd(sc, AXE_CMD_SROM_READ, 0, AXE_EEPROM_772B_PHY_PWRCFG, &eeprom);
76414ae1fa4SPyun YongHyeon sc->sc_pwrcfg = le16toh(eeprom) & 0xFF00;
76514ae1fa4SPyun YongHyeon
76614ae1fa4SPyun YongHyeon /*
76714ae1fa4SPyun YongHyeon * Auto-loaded default station address from internal ROM is
76814ae1fa4SPyun YongHyeon * 00:00:00:00:00:00 such that an explicit access to EEPROM
76914ae1fa4SPyun YongHyeon * is required to get real station address.
77014ae1fa4SPyun YongHyeon */
77114ae1fa4SPyun YongHyeon eaddr = ue->ue_eaddr;
77214ae1fa4SPyun YongHyeon for (i = 0; i < ETHER_ADDR_LEN / 2; i++) {
77314ae1fa4SPyun YongHyeon axe_cmd(sc, AXE_CMD_SROM_READ, 0, AXE_EEPROM_772B_NODE_ID + i,
77414ae1fa4SPyun YongHyeon &eeprom);
77514ae1fa4SPyun YongHyeon eeprom = le16toh(eeprom);
77614ae1fa4SPyun YongHyeon *eaddr++ = (uint8_t)(eeprom & 0xFF);
77714ae1fa4SPyun YongHyeon *eaddr++ = (uint8_t)((eeprom >> 8) & 0xFF);
77814ae1fa4SPyun YongHyeon }
77914ae1fa4SPyun YongHyeon /* Wakeup PHY. */
78014ae1fa4SPyun YongHyeon axe_ax88772_phywake(sc);
78114ae1fa4SPyun YongHyeon /* Stop MAC. */
78245b0a349SPyun YongHyeon axe_cmd(sc, AXE_CMD_RXCTL_WRITE, 0, 0, NULL);
78345b0a349SPyun YongHyeon }
78445b0a349SPyun YongHyeon
78545b0a349SPyun YongHyeon #undef AXE_GPIO_WRITE
78645b0a349SPyun YongHyeon
78745b0a349SPyun YongHyeon static void
axe_reset(struct axe_softc * sc)78802ac6454SAndrew Thompson axe_reset(struct axe_softc *sc)
78902ac6454SAndrew Thompson {
790760bc48eSAndrew Thompson struct usb_config_descriptor *cd;
791e0a69b51SAndrew Thompson usb_error_t err;
79202ac6454SAndrew Thompson
793a593f6b8SAndrew Thompson cd = usbd_get_config_descriptor(sc->sc_ue.ue_udev);
79402ac6454SAndrew Thompson
795a593f6b8SAndrew Thompson err = usbd_req_set_config(sc->sc_ue.ue_udev, &sc->sc_mtx,
79602ac6454SAndrew Thompson cd->bConfigurationValue);
79702ac6454SAndrew Thompson if (err)
79802ac6454SAndrew Thompson DPRINTF("reset failed (ignored)\n");
79902ac6454SAndrew Thompson
80002ac6454SAndrew Thompson /* Wait a little while for the chip to get its brains in order. */
801a593f6b8SAndrew Thompson uether_pause(&sc->sc_ue, hz / 100);
802ff5fbbc4SPyun YongHyeon
803ff5fbbc4SPyun YongHyeon /* Reinitialize controller to achieve full reset. */
804ff5fbbc4SPyun YongHyeon if (sc->sc_flags & AXE_FLAG_178)
805ff5fbbc4SPyun YongHyeon axe_ax88178_init(sc);
806ff5fbbc4SPyun YongHyeon else if (sc->sc_flags & AXE_FLAG_772)
807ff5fbbc4SPyun YongHyeon axe_ax88772_init(sc);
80845b0a349SPyun YongHyeon else if (sc->sc_flags & AXE_FLAG_772A)
80945b0a349SPyun YongHyeon axe_ax88772a_init(sc);
81014ae1fa4SPyun YongHyeon else if (sc->sc_flags & AXE_FLAG_772B)
81114ae1fa4SPyun YongHyeon axe_ax88772b_init(sc);
81202ac6454SAndrew Thompson }
81302ac6454SAndrew Thompson
81402ac6454SAndrew Thompson static void
axe_attach_post(struct usb_ether * ue)815760bc48eSAndrew Thompson axe_attach_post(struct usb_ether *ue)
81602ac6454SAndrew Thompson {
817a593f6b8SAndrew Thompson struct axe_softc *sc = uether_getsc(ue);
81802ac6454SAndrew Thompson
81902ac6454SAndrew Thompson /*
82002ac6454SAndrew Thompson * Load PHY indexes first. Needed by axe_xxx_init().
82102ac6454SAndrew Thompson */
82202ac6454SAndrew Thompson axe_cmd(sc, AXE_CMD_READ_PHYID, 0, 0, sc->sc_phyaddrs);
823edd913ebSAndrew Thompson if (bootverbose)
82402ac6454SAndrew Thompson device_printf(sc->sc_ue.ue_dev, "PHYADDR 0x%02x:0x%02x\n",
82502ac6454SAndrew Thompson sc->sc_phyaddrs[0], sc->sc_phyaddrs[1]);
82602ac6454SAndrew Thompson sc->sc_phyno = axe_get_phyno(sc, AXE_PHY_SEL_PRI);
82702ac6454SAndrew Thompson if (sc->sc_phyno == -1)
82802ac6454SAndrew Thompson sc->sc_phyno = axe_get_phyno(sc, AXE_PHY_SEL_SEC);
82902ac6454SAndrew Thompson if (sc->sc_phyno == -1) {
83002ac6454SAndrew Thompson device_printf(sc->sc_ue.ue_dev,
83102ac6454SAndrew Thompson "no valid PHY address found, assuming PHY address 0\n");
83202ac6454SAndrew Thompson sc->sc_phyno = 0;
83302ac6454SAndrew Thompson }
83402ac6454SAndrew Thompson
83514ae1fa4SPyun YongHyeon /* Initialize controller and get station address. */
8368c09fbe4SPyun YongHyeon if (sc->sc_flags & AXE_FLAG_178) {
83702ac6454SAndrew Thompson axe_ax88178_init(sc);
83814ae1fa4SPyun YongHyeon axe_cmd(sc, AXE_178_CMD_READ_NODEID, 0, 0, ue->ue_eaddr);
8398c09fbe4SPyun YongHyeon } else if (sc->sc_flags & AXE_FLAG_772) {
84002ac6454SAndrew Thompson axe_ax88772_init(sc);
84114ae1fa4SPyun YongHyeon axe_cmd(sc, AXE_178_CMD_READ_NODEID, 0, 0, ue->ue_eaddr);
84245b0a349SPyun YongHyeon } else if (sc->sc_flags & AXE_FLAG_772A) {
84345b0a349SPyun YongHyeon axe_ax88772a_init(sc);
84402ac6454SAndrew Thompson axe_cmd(sc, AXE_178_CMD_READ_NODEID, 0, 0, ue->ue_eaddr);
84514ae1fa4SPyun YongHyeon } else if (sc->sc_flags & AXE_FLAG_772B) {
84614ae1fa4SPyun YongHyeon axe_ax88772b_init(sc);
84714ae1fa4SPyun YongHyeon } else
84802ac6454SAndrew Thompson axe_cmd(sc, AXE_172_CMD_READ_NODEID, 0, 0, ue->ue_eaddr);
84902ac6454SAndrew Thompson
85002ac6454SAndrew Thompson /*
85102ac6454SAndrew Thompson * Fetch IPG values.
85202ac6454SAndrew Thompson */
85314ae1fa4SPyun YongHyeon if (sc->sc_flags & (AXE_FLAG_772A | AXE_FLAG_772B)) {
85445b0a349SPyun YongHyeon /* Set IPG values. */
85545b0a349SPyun YongHyeon sc->sc_ipgs[0] = 0x15;
85645b0a349SPyun YongHyeon sc->sc_ipgs[1] = 0x16;
85745b0a349SPyun YongHyeon sc->sc_ipgs[2] = 0x1A;
85845b0a349SPyun YongHyeon } else
85902ac6454SAndrew Thompson axe_cmd(sc, AXE_CMD_READ_IPG012, 0, 0, sc->sc_ipgs);
86002ac6454SAndrew Thompson }
86102ac6454SAndrew Thompson
862cdc2a5ecSPyun YongHyeon static int
axe_attach_post_sub(struct usb_ether * ue)863cdc2a5ecSPyun YongHyeon axe_attach_post_sub(struct usb_ether *ue)
864cdc2a5ecSPyun YongHyeon {
865cdc2a5ecSPyun YongHyeon struct axe_softc *sc;
866*935b194dSJustin Hibbits if_t ifp;
867cdc2a5ecSPyun YongHyeon u_int adv_pause;
868cdc2a5ecSPyun YongHyeon int error;
869cdc2a5ecSPyun YongHyeon
870cdc2a5ecSPyun YongHyeon sc = uether_getsc(ue);
871cdc2a5ecSPyun YongHyeon ifp = ue->ue_ifp;
872*935b194dSJustin Hibbits if_setflags(ifp, IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST);
873*935b194dSJustin Hibbits if_setstartfn(ifp, uether_start);
874*935b194dSJustin Hibbits if_setioctlfn(ifp, axe_ioctl);
875*935b194dSJustin Hibbits if_setinitfn(ifp, uether_init);
876*935b194dSJustin Hibbits if_setsendqlen(ifp, ifqmaxlen);
877*935b194dSJustin Hibbits if_setsendqready(ifp);
878cdc2a5ecSPyun YongHyeon
879cdc2a5ecSPyun YongHyeon if (AXE_IS_178_FAMILY(sc))
880*935b194dSJustin Hibbits if_setcapabilitiesbit(ifp, IFCAP_VLAN_MTU, 0);
881cdc2a5ecSPyun YongHyeon if (sc->sc_flags & AXE_FLAG_772B) {
882*935b194dSJustin Hibbits if_setcapabilitiesbit(ifp, IFCAP_TXCSUM | IFCAP_RXCSUM, 0);
883*935b194dSJustin Hibbits if_sethwassist(ifp, AXE_CSUM_FEATURES);
884cdc2a5ecSPyun YongHyeon /*
885cdc2a5ecSPyun YongHyeon * Checksum offloading of AX88772B also works with VLAN
886cdc2a5ecSPyun YongHyeon * tagged frames but there is no way to take advantage
887cdc2a5ecSPyun YongHyeon * of the feature because vlan(4) assumes
888cdc2a5ecSPyun YongHyeon * IFCAP_VLAN_HWTAGGING is prerequisite condition to
889cdc2a5ecSPyun YongHyeon * support checksum offloading with VLAN. VLAN hardware
890cdc2a5ecSPyun YongHyeon * tagging support of AX88772B is very limited so it's
891cdc2a5ecSPyun YongHyeon * not possible to announce IFCAP_VLAN_HWTAGGING.
892cdc2a5ecSPyun YongHyeon */
893cdc2a5ecSPyun YongHyeon }
894*935b194dSJustin Hibbits if_setcapenable(ifp, if_getcapabilities(ifp));
895cdc2a5ecSPyun YongHyeon if (sc->sc_flags & (AXE_FLAG_772A | AXE_FLAG_772B | AXE_FLAG_178))
896cdc2a5ecSPyun YongHyeon adv_pause = MIIF_DOPAUSE;
897cdc2a5ecSPyun YongHyeon else
898cdc2a5ecSPyun YongHyeon adv_pause = 0;
899c6df6f53SWarner Losh bus_topo_lock();
900cdc2a5ecSPyun YongHyeon error = mii_attach(ue->ue_dev, &ue->ue_miibus, ifp,
901cdc2a5ecSPyun YongHyeon uether_ifmedia_upd, ue->ue_methods->ue_mii_sts,
902cdc2a5ecSPyun YongHyeon BMSR_DEFCAPMASK, sc->sc_phyno, MII_OFFSET_ANY, adv_pause);
903c6df6f53SWarner Losh bus_topo_unlock();
904cdc2a5ecSPyun YongHyeon
905cdc2a5ecSPyun YongHyeon return (error);
906cdc2a5ecSPyun YongHyeon }
907cdc2a5ecSPyun YongHyeon
90802ac6454SAndrew Thompson /*
90902ac6454SAndrew Thompson * Probe for a AX88172 chip.
91002ac6454SAndrew Thompson */
91102ac6454SAndrew Thompson static int
axe_probe(device_t dev)91202ac6454SAndrew Thompson axe_probe(device_t dev)
91302ac6454SAndrew Thompson {
914760bc48eSAndrew Thompson struct usb_attach_arg *uaa = device_get_ivars(dev);
91502ac6454SAndrew Thompson
916f29a0724SAndrew Thompson if (uaa->usb_mode != USB_MODE_HOST)
91702ac6454SAndrew Thompson return (ENXIO);
91802ac6454SAndrew Thompson if (uaa->info.bConfigIndex != AXE_CONFIG_IDX)
91902ac6454SAndrew Thompson return (ENXIO);
92002ac6454SAndrew Thompson if (uaa->info.bIfaceIndex != AXE_IFACE_IDX)
92102ac6454SAndrew Thompson return (ENXIO);
92202ac6454SAndrew Thompson
923a593f6b8SAndrew Thompson return (usbd_lookup_id_by_uaa(axe_devs, sizeof(axe_devs), uaa));
92402ac6454SAndrew Thompson }
92502ac6454SAndrew Thompson
92602ac6454SAndrew Thompson /*
92702ac6454SAndrew Thompson * Attach the interface. Allocate softc structures, do ifmedia
92802ac6454SAndrew Thompson * setup and ethernet/BPF attach.
92902ac6454SAndrew Thompson */
93002ac6454SAndrew Thompson static int
axe_attach(device_t dev)93102ac6454SAndrew Thompson axe_attach(device_t dev)
93202ac6454SAndrew Thompson {
933760bc48eSAndrew Thompson struct usb_attach_arg *uaa = device_get_ivars(dev);
93402ac6454SAndrew Thompson struct axe_softc *sc = device_get_softc(dev);
935760bc48eSAndrew Thompson struct usb_ether *ue = &sc->sc_ue;
93602ac6454SAndrew Thompson uint8_t iface_index;
93702ac6454SAndrew Thompson int error;
93802ac6454SAndrew Thompson
93902ac6454SAndrew Thompson sc->sc_flags = USB_GET_DRIVER_INFO(uaa);
94002ac6454SAndrew Thompson
941a593f6b8SAndrew Thompson device_set_usb_desc(dev);
94202ac6454SAndrew Thompson
94302ac6454SAndrew Thompson mtx_init(&sc->sc_mtx, device_get_nameunit(dev), NULL, MTX_DEF);
94402ac6454SAndrew Thompson
94502ac6454SAndrew Thompson iface_index = AXE_IFACE_IDX;
946a593f6b8SAndrew Thompson error = usbd_transfer_setup(uaa->device, &iface_index, sc->sc_xfer,
94702ac6454SAndrew Thompson axe_config, AXE_N_TRANSFER, sc, &sc->sc_mtx);
94802ac6454SAndrew Thompson if (error) {
949767cb2e2SAndrew Thompson device_printf(dev, "allocating USB transfers failed\n");
95002ac6454SAndrew Thompson goto detach;
95102ac6454SAndrew Thompson }
95202ac6454SAndrew Thompson
95302ac6454SAndrew Thompson ue->ue_sc = sc;
95402ac6454SAndrew Thompson ue->ue_dev = dev;
95502ac6454SAndrew Thompson ue->ue_udev = uaa->device;
95602ac6454SAndrew Thompson ue->ue_mtx = &sc->sc_mtx;
95702ac6454SAndrew Thompson ue->ue_methods = &axe_ue_methods;
95802ac6454SAndrew Thompson
959a593f6b8SAndrew Thompson error = uether_ifattach(ue);
96002ac6454SAndrew Thompson if (error) {
96102ac6454SAndrew Thompson device_printf(dev, "could not attach interface\n");
96202ac6454SAndrew Thompson goto detach;
96302ac6454SAndrew Thompson }
96402ac6454SAndrew Thompson return (0); /* success */
96502ac6454SAndrew Thompson
96602ac6454SAndrew Thompson detach:
96702ac6454SAndrew Thompson axe_detach(dev);
96802ac6454SAndrew Thompson return (ENXIO); /* failure */
96902ac6454SAndrew Thompson }
97002ac6454SAndrew Thompson
97102ac6454SAndrew Thompson static int
axe_detach(device_t dev)97202ac6454SAndrew Thompson axe_detach(device_t dev)
97302ac6454SAndrew Thompson {
97402ac6454SAndrew Thompson struct axe_softc *sc = device_get_softc(dev);
975760bc48eSAndrew Thompson struct usb_ether *ue = &sc->sc_ue;
97602ac6454SAndrew Thompson
977a593f6b8SAndrew Thompson usbd_transfer_unsetup(sc->sc_xfer, AXE_N_TRANSFER);
978a593f6b8SAndrew Thompson uether_ifdetach(ue);
97902ac6454SAndrew Thompson mtx_destroy(&sc->sc_mtx);
98002ac6454SAndrew Thompson
98102ac6454SAndrew Thompson return (0);
98202ac6454SAndrew Thompson }
98302ac6454SAndrew Thompson
98402ac6454SAndrew Thompson #if (AXE_BULK_BUF_SIZE >= 0x10000)
98502ac6454SAndrew Thompson #error "Please update axe_bulk_read_callback()!"
98602ac6454SAndrew Thompson #endif
98702ac6454SAndrew Thompson
98802ac6454SAndrew Thompson static void
axe_bulk_read_callback(struct usb_xfer * xfer,usb_error_t error)989ed6d949aSAndrew Thompson axe_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error)
99002ac6454SAndrew Thompson {
991ed6d949aSAndrew Thompson struct axe_softc *sc = usbd_xfer_softc(xfer);
992760bc48eSAndrew Thompson struct usb_ether *ue = &sc->sc_ue;
993ed6d949aSAndrew Thompson struct usb_page_cache *pc;
994ed6d949aSAndrew Thompson int actlen;
995ed6d949aSAndrew Thompson
996ed6d949aSAndrew Thompson usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
99702ac6454SAndrew Thompson
99802ac6454SAndrew Thompson switch (USB_GET_STATE(xfer)) {
99902ac6454SAndrew Thompson case USB_ST_TRANSFERRED:
1000ed6d949aSAndrew Thompson pc = usbd_xfer_get_frame(xfer, 0);
1001cdc2a5ecSPyun YongHyeon axe_rx_frame(ue, pc, actlen);
100202ac6454SAndrew Thompson
100302ac6454SAndrew Thompson /* FALLTHROUGH */
100402ac6454SAndrew Thompson case USB_ST_SETUP:
100502ac6454SAndrew Thompson tr_setup:
1006ed6d949aSAndrew Thompson usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
1007a593f6b8SAndrew Thompson usbd_transfer_submit(xfer);
1008a593f6b8SAndrew Thompson uether_rxflush(ue);
100902ac6454SAndrew Thompson return;
101002ac6454SAndrew Thompson
101102ac6454SAndrew Thompson default: /* Error */
1012ed6d949aSAndrew Thompson DPRINTF("bulk read error, %s\n", usbd_errstr(error));
101302ac6454SAndrew Thompson
1014ed6d949aSAndrew Thompson if (error != USB_ERR_CANCELLED) {
101502ac6454SAndrew Thompson /* try to clear stall first */
1016ed6d949aSAndrew Thompson usbd_xfer_set_stall(xfer);
101702ac6454SAndrew Thompson goto tr_setup;
101802ac6454SAndrew Thompson }
101902ac6454SAndrew Thompson return;
102002ac6454SAndrew Thompson }
102102ac6454SAndrew Thompson }
102202ac6454SAndrew Thompson
1023cdc2a5ecSPyun YongHyeon static int
axe_rx_frame(struct usb_ether * ue,struct usb_page_cache * pc,int actlen)1024cdc2a5ecSPyun YongHyeon axe_rx_frame(struct usb_ether *ue, struct usb_page_cache *pc, int actlen)
1025cdc2a5ecSPyun YongHyeon {
1026cdc2a5ecSPyun YongHyeon struct axe_softc *sc;
1027cdc2a5ecSPyun YongHyeon struct axe_sframe_hdr hdr;
1028cdc2a5ecSPyun YongHyeon struct axe_csum_hdr csum_hdr;
1029cdc2a5ecSPyun YongHyeon int error, len, pos;
1030cdc2a5ecSPyun YongHyeon
1031cdc2a5ecSPyun YongHyeon sc = uether_getsc(ue);
1032cdc2a5ecSPyun YongHyeon pos = 0;
1033cdc2a5ecSPyun YongHyeon len = 0;
1034cdc2a5ecSPyun YongHyeon error = 0;
1035cdc2a5ecSPyun YongHyeon if ((sc->sc_flags & AXE_FLAG_STD_FRAME) != 0) {
1036cdc2a5ecSPyun YongHyeon while (pos < actlen) {
10376d917491SHans Petter Selasky if ((int)(pos + sizeof(hdr)) > actlen) {
1038cdc2a5ecSPyun YongHyeon /* too little data */
1039cdc2a5ecSPyun YongHyeon error = EINVAL;
1040cdc2a5ecSPyun YongHyeon break;
1041cdc2a5ecSPyun YongHyeon }
1042cdc2a5ecSPyun YongHyeon usbd_copy_out(pc, pos, &hdr, sizeof(hdr));
1043cdc2a5ecSPyun YongHyeon
1044cdc2a5ecSPyun YongHyeon if ((hdr.len ^ hdr.ilen) != sc->sc_lenmask) {
1045cdc2a5ecSPyun YongHyeon /* we lost sync */
1046cdc2a5ecSPyun YongHyeon error = EINVAL;
1047cdc2a5ecSPyun YongHyeon break;
1048cdc2a5ecSPyun YongHyeon }
1049cdc2a5ecSPyun YongHyeon pos += sizeof(hdr);
1050cdc2a5ecSPyun YongHyeon len = le16toh(hdr.len);
1051cdc2a5ecSPyun YongHyeon if (pos + len > actlen) {
1052cdc2a5ecSPyun YongHyeon /* invalid length */
1053cdc2a5ecSPyun YongHyeon error = EINVAL;
1054cdc2a5ecSPyun YongHyeon break;
1055cdc2a5ecSPyun YongHyeon }
1056cdc2a5ecSPyun YongHyeon axe_rxeof(ue, pc, pos, len, NULL);
1057cdc2a5ecSPyun YongHyeon pos += len + (len % 2);
1058cdc2a5ecSPyun YongHyeon }
1059cdc2a5ecSPyun YongHyeon } else if ((sc->sc_flags & AXE_FLAG_CSUM_FRAME) != 0) {
1060cdc2a5ecSPyun YongHyeon while (pos < actlen) {
10616d917491SHans Petter Selasky if ((int)(pos + sizeof(csum_hdr)) > actlen) {
1062cdc2a5ecSPyun YongHyeon /* too little data */
1063cdc2a5ecSPyun YongHyeon error = EINVAL;
1064cdc2a5ecSPyun YongHyeon break;
1065cdc2a5ecSPyun YongHyeon }
1066cdc2a5ecSPyun YongHyeon usbd_copy_out(pc, pos, &csum_hdr, sizeof(csum_hdr));
1067cdc2a5ecSPyun YongHyeon
1068cdc2a5ecSPyun YongHyeon csum_hdr.len = le16toh(csum_hdr.len);
1069cdc2a5ecSPyun YongHyeon csum_hdr.ilen = le16toh(csum_hdr.ilen);
1070cdc2a5ecSPyun YongHyeon csum_hdr.cstatus = le16toh(csum_hdr.cstatus);
1071cdc2a5ecSPyun YongHyeon if ((AXE_CSUM_RXBYTES(csum_hdr.len) ^
1072cdc2a5ecSPyun YongHyeon AXE_CSUM_RXBYTES(csum_hdr.ilen)) !=
1073cdc2a5ecSPyun YongHyeon sc->sc_lenmask) {
1074cdc2a5ecSPyun YongHyeon /* we lost sync */
1075cdc2a5ecSPyun YongHyeon error = EINVAL;
1076cdc2a5ecSPyun YongHyeon break;
1077cdc2a5ecSPyun YongHyeon }
1078cdc2a5ecSPyun YongHyeon /*
1079cdc2a5ecSPyun YongHyeon * Get total transferred frame length including
1080cdc2a5ecSPyun YongHyeon * checksum header. The length should be multiple
1081cdc2a5ecSPyun YongHyeon * of 4.
1082cdc2a5ecSPyun YongHyeon */
1083cdc2a5ecSPyun YongHyeon len = sizeof(csum_hdr) + AXE_CSUM_RXBYTES(csum_hdr.len);
1084cdc2a5ecSPyun YongHyeon len = (len + 3) & ~3;
1085cdc2a5ecSPyun YongHyeon if (pos + len > actlen) {
1086cdc2a5ecSPyun YongHyeon /* invalid length */
1087cdc2a5ecSPyun YongHyeon error = EINVAL;
1088cdc2a5ecSPyun YongHyeon break;
1089cdc2a5ecSPyun YongHyeon }
1090cdc2a5ecSPyun YongHyeon axe_rxeof(ue, pc, pos + sizeof(csum_hdr),
1091cdc2a5ecSPyun YongHyeon AXE_CSUM_RXBYTES(csum_hdr.len), &csum_hdr);
1092cdc2a5ecSPyun YongHyeon pos += len;
1093cdc2a5ecSPyun YongHyeon }
1094cdc2a5ecSPyun YongHyeon } else
1095cdc2a5ecSPyun YongHyeon axe_rxeof(ue, pc, 0, actlen, NULL);
1096cdc2a5ecSPyun YongHyeon
1097cdc2a5ecSPyun YongHyeon if (error != 0)
1098ecc70d3fSGleb Smirnoff if_inc_counter(ue->ue_ifp, IFCOUNTER_IERRORS, 1);
1099cdc2a5ecSPyun YongHyeon return (error);
1100cdc2a5ecSPyun YongHyeon }
1101cdc2a5ecSPyun YongHyeon
1102cdc2a5ecSPyun YongHyeon static int
axe_rxeof(struct usb_ether * ue,struct usb_page_cache * pc,unsigned offset,unsigned len,struct axe_csum_hdr * csum_hdr)110362d42655SHans Petter Selasky axe_rxeof(struct usb_ether *ue, struct usb_page_cache *pc, unsigned offset,
110462d42655SHans Petter Selasky unsigned len, struct axe_csum_hdr *csum_hdr)
1105cdc2a5ecSPyun YongHyeon {
1106*935b194dSJustin Hibbits if_t ifp = ue->ue_ifp;
1107cdc2a5ecSPyun YongHyeon struct mbuf *m;
1108cdc2a5ecSPyun YongHyeon
1109cdc2a5ecSPyun YongHyeon if (len < ETHER_HDR_LEN || len > MCLBYTES - ETHER_ALIGN) {
1110ecc70d3fSGleb Smirnoff if_inc_counter(ifp, IFCOUNTER_IERRORS, 1);
1111cdc2a5ecSPyun YongHyeon return (EINVAL);
1112cdc2a5ecSPyun YongHyeon }
1113cdc2a5ecSPyun YongHyeon
1114c6499eccSGleb Smirnoff m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
1115cdc2a5ecSPyun YongHyeon if (m == NULL) {
1116ecc70d3fSGleb Smirnoff if_inc_counter(ifp, IFCOUNTER_IQDROPS, 1);
1117cdc2a5ecSPyun YongHyeon return (ENOMEM);
1118cdc2a5ecSPyun YongHyeon }
1119cdc2a5ecSPyun YongHyeon m->m_len = m->m_pkthdr.len = MCLBYTES;
1120cdc2a5ecSPyun YongHyeon m_adj(m, ETHER_ALIGN);
1121cdc2a5ecSPyun YongHyeon
1122cdc2a5ecSPyun YongHyeon usbd_copy_out(pc, offset, mtod(m, uint8_t *), len);
1123cdc2a5ecSPyun YongHyeon
1124ecc70d3fSGleb Smirnoff if_inc_counter(ifp, IFCOUNTER_IPACKETS, 1);
1125cdc2a5ecSPyun YongHyeon m->m_pkthdr.rcvif = ifp;
1126cdc2a5ecSPyun YongHyeon m->m_pkthdr.len = m->m_len = len;
1127cdc2a5ecSPyun YongHyeon
1128cdc2a5ecSPyun YongHyeon if (csum_hdr != NULL && csum_hdr->cstatus & AXE_CSUM_HDR_L3_TYPE_IPV4) {
1129cdc2a5ecSPyun YongHyeon if ((csum_hdr->cstatus & (AXE_CSUM_HDR_L4_CSUM_ERR |
1130cdc2a5ecSPyun YongHyeon AXE_CSUM_HDR_L3_CSUM_ERR)) == 0) {
1131cdc2a5ecSPyun YongHyeon m->m_pkthdr.csum_flags |= CSUM_IP_CHECKED |
1132cdc2a5ecSPyun YongHyeon CSUM_IP_VALID;
1133cdc2a5ecSPyun YongHyeon if ((csum_hdr->cstatus & AXE_CSUM_HDR_L4_TYPE_MASK) ==
1134cdc2a5ecSPyun YongHyeon AXE_CSUM_HDR_L4_TYPE_TCP ||
1135cdc2a5ecSPyun YongHyeon (csum_hdr->cstatus & AXE_CSUM_HDR_L4_TYPE_MASK) ==
1136cdc2a5ecSPyun YongHyeon AXE_CSUM_HDR_L4_TYPE_UDP) {
1137cdc2a5ecSPyun YongHyeon m->m_pkthdr.csum_flags |=
1138cdc2a5ecSPyun YongHyeon CSUM_DATA_VALID | CSUM_PSEUDO_HDR;
1139cdc2a5ecSPyun YongHyeon m->m_pkthdr.csum_data = 0xffff;
1140cdc2a5ecSPyun YongHyeon }
1141cdc2a5ecSPyun YongHyeon }
1142cdc2a5ecSPyun YongHyeon }
1143cdc2a5ecSPyun YongHyeon
114435d3dd8bSGleb Smirnoff (void)mbufq_enqueue(&ue->ue_rxq, m);
1145cdc2a5ecSPyun YongHyeon return (0);
1146cdc2a5ecSPyun YongHyeon }
1147cdc2a5ecSPyun YongHyeon
114802ac6454SAndrew Thompson #if ((AXE_BULK_BUF_SIZE >= 0x10000) || (AXE_BULK_BUF_SIZE < (MCLBYTES+4)))
114902ac6454SAndrew Thompson #error "Please update axe_bulk_write_callback()!"
115002ac6454SAndrew Thompson #endif
115102ac6454SAndrew Thompson
115202ac6454SAndrew Thompson static void
axe_bulk_write_callback(struct usb_xfer * xfer,usb_error_t error)1153ed6d949aSAndrew Thompson axe_bulk_write_callback(struct usb_xfer *xfer, usb_error_t error)
115402ac6454SAndrew Thompson {
1155ed6d949aSAndrew Thompson struct axe_softc *sc = usbd_xfer_softc(xfer);
115602ac6454SAndrew Thompson struct axe_sframe_hdr hdr;
1157*935b194dSJustin Hibbits if_t ifp = uether_getifp(&sc->sc_ue);
1158ed6d949aSAndrew Thompson struct usb_page_cache *pc;
115902ac6454SAndrew Thompson struct mbuf *m;
116065c12bf5SPyun YongHyeon int nframes, pos;
116102ac6454SAndrew Thompson
116202ac6454SAndrew Thompson switch (USB_GET_STATE(xfer)) {
116302ac6454SAndrew Thompson case USB_ST_TRANSFERRED:
116402ac6454SAndrew Thompson DPRINTFN(11, "transfer complete\n");
1165*935b194dSJustin Hibbits if_setdrvflagbits(ifp, 0, IFF_DRV_OACTIVE);
116602ac6454SAndrew Thompson /* FALLTHROUGH */
116702ac6454SAndrew Thompson case USB_ST_SETUP:
116802ac6454SAndrew Thompson tr_setup:
1169465a52e0SPyun YongHyeon if ((sc->sc_flags & AXE_FLAG_LINK) == 0 ||
1170*935b194dSJustin Hibbits (if_getdrvflags(ifp) & IFF_DRV_OACTIVE) != 0) {
117102ac6454SAndrew Thompson /*
1172465a52e0SPyun YongHyeon * Don't send anything if there is no link or
1173465a52e0SPyun YongHyeon * controller is busy.
117402ac6454SAndrew Thompson */
117502ac6454SAndrew Thompson return;
117602ac6454SAndrew Thompson }
117702ac6454SAndrew Thompson
117865c12bf5SPyun YongHyeon for (nframes = 0; nframes < 16 &&
1179*935b194dSJustin Hibbits !if_sendq_empty(ifp); nframes++) {
1180*935b194dSJustin Hibbits m = if_dequeue(ifp);
118165c12bf5SPyun YongHyeon if (m == NULL)
118265c12bf5SPyun YongHyeon break;
118365c12bf5SPyun YongHyeon usbd_xfer_set_frame_offset(xfer, nframes * MCLBYTES,
118465c12bf5SPyun YongHyeon nframes);
118565c12bf5SPyun YongHyeon pos = 0;
118665c12bf5SPyun YongHyeon pc = usbd_xfer_get_frame(xfer, nframes);
11878c09fbe4SPyun YongHyeon if (AXE_IS_178_FAMILY(sc)) {
118802ac6454SAndrew Thompson hdr.len = htole16(m->m_pkthdr.len);
118902ac6454SAndrew Thompson hdr.ilen = ~hdr.len;
1190cdc2a5ecSPyun YongHyeon /*
1191cdc2a5ecSPyun YongHyeon * If upper stack computed checksum, driver
1192cdc2a5ecSPyun YongHyeon * should tell controller not to insert
1193cdc2a5ecSPyun YongHyeon * computed checksum for checksum offloading
1194cdc2a5ecSPyun YongHyeon * enabled controller.
1195cdc2a5ecSPyun YongHyeon */
1196*935b194dSJustin Hibbits if (if_getcapabilities(ifp) & IFCAP_TXCSUM) {
1197cdc2a5ecSPyun YongHyeon if ((m->m_pkthdr.csum_flags &
1198cdc2a5ecSPyun YongHyeon AXE_CSUM_FEATURES) != 0)
1199cdc2a5ecSPyun YongHyeon hdr.len |= htole16(
1200cdc2a5ecSPyun YongHyeon AXE_TX_CSUM_PSEUDO_HDR);
1201cdc2a5ecSPyun YongHyeon else
1202cdc2a5ecSPyun YongHyeon hdr.len |= htole16(
1203cdc2a5ecSPyun YongHyeon AXE_TX_CSUM_DIS);
1204cdc2a5ecSPyun YongHyeon }
1205ed6d949aSAndrew Thompson usbd_copy_in(pc, pos, &hdr, sizeof(hdr));
120602ac6454SAndrew Thompson pos += sizeof(hdr);
1207ed6d949aSAndrew Thompson usbd_m_copy_in(pc, pos, m, 0, m->m_pkthdr.len);
120802ac6454SAndrew Thompson pos += m->m_pkthdr.len;
120965c12bf5SPyun YongHyeon if ((pos % 512) == 0) {
121065c12bf5SPyun YongHyeon hdr.len = 0;
121165c12bf5SPyun YongHyeon hdr.ilen = 0xffff;
121265c12bf5SPyun YongHyeon usbd_copy_in(pc, pos, &hdr,
121365c12bf5SPyun YongHyeon sizeof(hdr));
121465c12bf5SPyun YongHyeon pos += sizeof(hdr);
121565c12bf5SPyun YongHyeon }
121665c12bf5SPyun YongHyeon } else {
121765c12bf5SPyun YongHyeon usbd_m_copy_in(pc, pos, m, 0, m->m_pkthdr.len);
121865c12bf5SPyun YongHyeon pos += m->m_pkthdr.len;
121965c12bf5SPyun YongHyeon }
122002ac6454SAndrew Thompson
122102ac6454SAndrew Thompson /*
1222b8e98004SPyun YongHyeon * XXX
1223b8e98004SPyun YongHyeon * Update TX packet counter here. This is not
1224b8e98004SPyun YongHyeon * correct way but it seems that there is no way
1225b8e98004SPyun YongHyeon * to know how many packets are sent at the end
1226b8e98004SPyun YongHyeon * of transfer because controller combines
1227b8e98004SPyun YongHyeon * multiple writes into single one if there is
1228b8e98004SPyun YongHyeon * room in TX buffer of controller.
1229b8e98004SPyun YongHyeon */
1230ecc70d3fSGleb Smirnoff if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1);
1231b8e98004SPyun YongHyeon
1232b8e98004SPyun YongHyeon /*
123302ac6454SAndrew Thompson * if there's a BPF listener, bounce a copy
123402ac6454SAndrew Thompson * of this frame to him:
123502ac6454SAndrew Thompson */
123602ac6454SAndrew Thompson BPF_MTAP(ifp, m);
123702ac6454SAndrew Thompson
123802ac6454SAndrew Thompson m_freem(m);
123902ac6454SAndrew Thompson
124065c12bf5SPyun YongHyeon /* Set frame length. */
124165c12bf5SPyun YongHyeon usbd_xfer_set_frame_len(xfer, nframes, pos);
124202ac6454SAndrew Thompson }
124365c12bf5SPyun YongHyeon if (nframes != 0) {
124465c12bf5SPyun YongHyeon usbd_xfer_set_frames(xfer, nframes);
1245a593f6b8SAndrew Thompson usbd_transfer_submit(xfer);
1246*935b194dSJustin Hibbits if_setdrvflagbits(ifp, IFF_DRV_OACTIVE, 0);
124765c12bf5SPyun YongHyeon }
124802ac6454SAndrew Thompson return;
124965c12bf5SPyun YongHyeon /* NOTREACHED */
125002ac6454SAndrew Thompson default: /* Error */
125102ac6454SAndrew Thompson DPRINTFN(11, "transfer error, %s\n",
1252ed6d949aSAndrew Thompson usbd_errstr(error));
125302ac6454SAndrew Thompson
1254ecc70d3fSGleb Smirnoff if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
1255*935b194dSJustin Hibbits if_setdrvflagbits(ifp, 0, IFF_DRV_OACTIVE);
125602ac6454SAndrew Thompson
1257ed6d949aSAndrew Thompson if (error != USB_ERR_CANCELLED) {
125802ac6454SAndrew Thompson /* try to clear stall first */
1259ed6d949aSAndrew Thompson usbd_xfer_set_stall(xfer);
126002ac6454SAndrew Thompson goto tr_setup;
126102ac6454SAndrew Thompson }
126202ac6454SAndrew Thompson return;
126302ac6454SAndrew Thompson }
126402ac6454SAndrew Thompson }
126502ac6454SAndrew Thompson
126602ac6454SAndrew Thompson static void
axe_tick(struct usb_ether * ue)1267760bc48eSAndrew Thompson axe_tick(struct usb_ether *ue)
126802ac6454SAndrew Thompson {
1269a593f6b8SAndrew Thompson struct axe_softc *sc = uether_getsc(ue);
127002ac6454SAndrew Thompson struct mii_data *mii = GET_MII(sc);
127102ac6454SAndrew Thompson
127202ac6454SAndrew Thompson AXE_LOCK_ASSERT(sc, MA_OWNED);
127302ac6454SAndrew Thompson
127402ac6454SAndrew Thompson mii_tick(mii);
127502ac6454SAndrew Thompson if ((sc->sc_flags & AXE_FLAG_LINK) == 0) {
127602ac6454SAndrew Thompson axe_miibus_statchg(ue->ue_dev);
127702ac6454SAndrew Thompson if ((sc->sc_flags & AXE_FLAG_LINK) != 0)
127802ac6454SAndrew Thompson axe_start(ue);
127902ac6454SAndrew Thompson }
128002ac6454SAndrew Thompson }
128102ac6454SAndrew Thompson
128202ac6454SAndrew Thompson static void
axe_start(struct usb_ether * ue)1283760bc48eSAndrew Thompson axe_start(struct usb_ether *ue)
128402ac6454SAndrew Thompson {
1285a593f6b8SAndrew Thompson struct axe_softc *sc = uether_getsc(ue);
128602ac6454SAndrew Thompson
128702ac6454SAndrew Thompson /*
128802ac6454SAndrew Thompson * start the USB transfers, if not already started:
128902ac6454SAndrew Thompson */
1290a593f6b8SAndrew Thompson usbd_transfer_start(sc->sc_xfer[AXE_BULK_DT_RD]);
1291a593f6b8SAndrew Thompson usbd_transfer_start(sc->sc_xfer[AXE_BULK_DT_WR]);
129202ac6454SAndrew Thompson }
129302ac6454SAndrew Thompson
129402ac6454SAndrew Thompson static void
axe_csum_cfg(struct usb_ether * ue)1295cdc2a5ecSPyun YongHyeon axe_csum_cfg(struct usb_ether *ue)
1296cdc2a5ecSPyun YongHyeon {
1297cdc2a5ecSPyun YongHyeon struct axe_softc *sc;
1298*935b194dSJustin Hibbits if_t ifp;
1299cdc2a5ecSPyun YongHyeon uint16_t csum1, csum2;
1300cdc2a5ecSPyun YongHyeon
1301cdc2a5ecSPyun YongHyeon sc = uether_getsc(ue);
1302cdc2a5ecSPyun YongHyeon AXE_LOCK_ASSERT(sc, MA_OWNED);
1303cdc2a5ecSPyun YongHyeon
1304cdc2a5ecSPyun YongHyeon if ((sc->sc_flags & AXE_FLAG_772B) != 0) {
1305cdc2a5ecSPyun YongHyeon ifp = uether_getifp(ue);
1306cdc2a5ecSPyun YongHyeon csum1 = 0;
1307cdc2a5ecSPyun YongHyeon csum2 = 0;
1308*935b194dSJustin Hibbits if ((if_getcapenable(ifp) & IFCAP_TXCSUM) != 0)
1309cdc2a5ecSPyun YongHyeon csum1 |= AXE_TXCSUM_IP | AXE_TXCSUM_TCP |
1310cdc2a5ecSPyun YongHyeon AXE_TXCSUM_UDP;
1311cdc2a5ecSPyun YongHyeon axe_cmd(sc, AXE_772B_CMD_WRITE_TXCSUM, csum2, csum1, NULL);
1312cdc2a5ecSPyun YongHyeon csum1 = 0;
1313cdc2a5ecSPyun YongHyeon csum2 = 0;
1314*935b194dSJustin Hibbits if ((if_getcapenable(ifp) & IFCAP_RXCSUM) != 0)
1315cdc2a5ecSPyun YongHyeon csum1 |= AXE_RXCSUM_IP | AXE_RXCSUM_IPVE |
1316cdc2a5ecSPyun YongHyeon AXE_RXCSUM_TCP | AXE_RXCSUM_UDP | AXE_RXCSUM_ICMP |
1317cdc2a5ecSPyun YongHyeon AXE_RXCSUM_IGMP;
1318cdc2a5ecSPyun YongHyeon axe_cmd(sc, AXE_772B_CMD_WRITE_RXCSUM, csum2, csum1, NULL);
1319cdc2a5ecSPyun YongHyeon }
1320cdc2a5ecSPyun YongHyeon }
1321cdc2a5ecSPyun YongHyeon
1322cdc2a5ecSPyun YongHyeon static void
axe_init(struct usb_ether * ue)1323760bc48eSAndrew Thompson axe_init(struct usb_ether *ue)
132402ac6454SAndrew Thompson {
1325a593f6b8SAndrew Thompson struct axe_softc *sc = uether_getsc(ue);
1326*935b194dSJustin Hibbits if_t ifp = uether_getifp(ue);
132702ac6454SAndrew Thompson uint16_t rxmode;
132802ac6454SAndrew Thompson
132902ac6454SAndrew Thompson AXE_LOCK_ASSERT(sc, MA_OWNED);
133002ac6454SAndrew Thompson
1331*935b194dSJustin Hibbits if ((if_getdrvflags(ifp) & IFF_DRV_RUNNING) != 0)
13320369b604SPyun YongHyeon return;
13330369b604SPyun YongHyeon
133402ac6454SAndrew Thompson /* Cancel pending I/O */
133502ac6454SAndrew Thompson axe_stop(ue);
133602ac6454SAndrew Thompson
1337675c1ae8SPyun YongHyeon axe_reset(sc);
1338675c1ae8SPyun YongHyeon
1339cdc2a5ecSPyun YongHyeon /* Set MAC address and transmitter IPG values. */
1340cdc2a5ecSPyun YongHyeon if (AXE_IS_178_FAMILY(sc)) {
1341*935b194dSJustin Hibbits axe_cmd(sc, AXE_178_CMD_WRITE_NODEID, 0, 0, if_getlladdr(ifp));
134202ac6454SAndrew Thompson axe_cmd(sc, AXE_178_CMD_WRITE_IPG012, sc->sc_ipgs[2],
134302ac6454SAndrew Thompson (sc->sc_ipgs[1] << 8) | (sc->sc_ipgs[0]), NULL);
1344cdc2a5ecSPyun YongHyeon } else {
1345*935b194dSJustin Hibbits axe_cmd(sc, AXE_172_CMD_WRITE_NODEID, 0, 0, if_getlladdr(ifp));
134602ac6454SAndrew Thompson axe_cmd(sc, AXE_172_CMD_WRITE_IPG0, 0, sc->sc_ipgs[0], NULL);
134702ac6454SAndrew Thompson axe_cmd(sc, AXE_172_CMD_WRITE_IPG1, 0, sc->sc_ipgs[1], NULL);
134802ac6454SAndrew Thompson axe_cmd(sc, AXE_172_CMD_WRITE_IPG2, 0, sc->sc_ipgs[2], NULL);
134902ac6454SAndrew Thompson }
135002ac6454SAndrew Thompson
1351cdc2a5ecSPyun YongHyeon if (AXE_IS_178_FAMILY(sc)) {
1352cdc2a5ecSPyun YongHyeon sc->sc_flags &= ~(AXE_FLAG_STD_FRAME | AXE_FLAG_CSUM_FRAME);
1353cdc2a5ecSPyun YongHyeon if ((sc->sc_flags & AXE_FLAG_772B) != 0 &&
1354*935b194dSJustin Hibbits (if_getcapenable(ifp) & IFCAP_RXCSUM) != 0) {
1355fec40c2dSPyun YongHyeon sc->sc_lenmask = AXE_CSUM_HDR_LEN_MASK;
1356cdc2a5ecSPyun YongHyeon sc->sc_flags |= AXE_FLAG_CSUM_FRAME;
1357fec40c2dSPyun YongHyeon } else {
1358fec40c2dSPyun YongHyeon sc->sc_lenmask = AXE_HDR_LEN_MASK;
1359cdc2a5ecSPyun YongHyeon sc->sc_flags |= AXE_FLAG_STD_FRAME;
1360cdc2a5ecSPyun YongHyeon }
1361fec40c2dSPyun YongHyeon }
1362cdc2a5ecSPyun YongHyeon
1363cdc2a5ecSPyun YongHyeon /* Configure TX/RX checksum offloading. */
1364cdc2a5ecSPyun YongHyeon axe_csum_cfg(ue);
1365cdc2a5ecSPyun YongHyeon
1366cdc2a5ecSPyun YongHyeon if (sc->sc_flags & AXE_FLAG_772B) {
136714ae1fa4SPyun YongHyeon /* AX88772B uses different maximum frame burst configuration. */
136814ae1fa4SPyun YongHyeon axe_cmd(sc, AXE_772B_CMD_RXCTL_WRITE_CFG,
136914ae1fa4SPyun YongHyeon ax88772b_mfb_table[AX88772B_MFB_16K].threshold,
137014ae1fa4SPyun YongHyeon ax88772b_mfb_table[AX88772B_MFB_16K].byte_cnt, NULL);
1371cdc2a5ecSPyun YongHyeon }
137214ae1fa4SPyun YongHyeon
137314ae1fa4SPyun YongHyeon /* Enable receiver, set RX mode. */
137402ac6454SAndrew Thompson rxmode = (AXE_RXCMD_MULTICAST | AXE_RXCMD_ENABLE);
13758c09fbe4SPyun YongHyeon if (AXE_IS_178_FAMILY(sc)) {
137614ae1fa4SPyun YongHyeon if (sc->sc_flags & AXE_FLAG_772B) {
137714ae1fa4SPyun YongHyeon /*
137814ae1fa4SPyun YongHyeon * Select RX header format type 1. Aligning IP
1379cdc2a5ecSPyun YongHyeon * header on 4 byte boundary is not needed when
1380cdc2a5ecSPyun YongHyeon * checksum offloading feature is not used
138114ae1fa4SPyun YongHyeon * because we always copy the received frame in
1382cdc2a5ecSPyun YongHyeon * RX handler. When RX checksum offloading is
1383cdc2a5ecSPyun YongHyeon * active, aligning IP header is required to
1384cdc2a5ecSPyun YongHyeon * reflect actual frame length including RX
1385cdc2a5ecSPyun YongHyeon * header size.
138614ae1fa4SPyun YongHyeon */
138714ae1fa4SPyun YongHyeon rxmode |= AXE_772B_RXCMD_HDR_TYPE_1;
1388*935b194dSJustin Hibbits if ((if_getcapenable(ifp) & IFCAP_RXCSUM) != 0)
1389cdc2a5ecSPyun YongHyeon rxmode |= AXE_772B_RXCMD_IPHDR_ALIGN;
139014ae1fa4SPyun YongHyeon } else {
13913ac526e0SAndrew Thompson /*
13923ac526e0SAndrew Thompson * Default Rx buffer size is too small to get
13933ac526e0SAndrew Thompson * maximum performance.
13943ac526e0SAndrew Thompson */
13953ac526e0SAndrew Thompson rxmode |= AXE_178_RXCMD_MFB_16384;
139614ae1fa4SPyun YongHyeon }
139702ac6454SAndrew Thompson } else {
139802ac6454SAndrew Thompson rxmode |= AXE_172_RXCMD_UNICAST;
139902ac6454SAndrew Thompson }
140002ac6454SAndrew Thompson
140102ac6454SAndrew Thompson /* If we want promiscuous mode, set the allframes bit. */
1402*935b194dSJustin Hibbits if (if_getflags(ifp) & IFF_PROMISC)
140302ac6454SAndrew Thompson rxmode |= AXE_RXCMD_PROMISC;
140402ac6454SAndrew Thompson
1405*935b194dSJustin Hibbits if (if_getflags(ifp) & IFF_BROADCAST)
140602ac6454SAndrew Thompson rxmode |= AXE_RXCMD_BROADCAST;
140702ac6454SAndrew Thompson
140802ac6454SAndrew Thompson axe_cmd(sc, AXE_CMD_RXCTL_WRITE, 0, rxmode, NULL);
140902ac6454SAndrew Thompson
141002ac6454SAndrew Thompson /* Load the multicast filter. */
141102ac6454SAndrew Thompson axe_setmulti(ue);
141202ac6454SAndrew Thompson
1413ed6d949aSAndrew Thompson usbd_xfer_set_stall(sc->sc_xfer[AXE_BULK_DT_WR]);
141402ac6454SAndrew Thompson
1415*935b194dSJustin Hibbits if_setdrvflagbits(ifp, IFF_DRV_RUNNING, 0);
1416d743bdd2SPyun YongHyeon /* Switch to selected media. */
1417d743bdd2SPyun YongHyeon axe_ifmedia_upd(ifp);
141802ac6454SAndrew Thompson }
141902ac6454SAndrew Thompson
142002ac6454SAndrew Thompson static void
axe_setpromisc(struct usb_ether * ue)1421760bc48eSAndrew Thompson axe_setpromisc(struct usb_ether *ue)
142202ac6454SAndrew Thompson {
1423a593f6b8SAndrew Thompson struct axe_softc *sc = uether_getsc(ue);
1424*935b194dSJustin Hibbits if_t ifp = uether_getifp(ue);
142502ac6454SAndrew Thompson uint16_t rxmode;
142602ac6454SAndrew Thompson
142702ac6454SAndrew Thompson axe_cmd(sc, AXE_CMD_RXCTL_READ, 0, 0, &rxmode);
142802ac6454SAndrew Thompson
142902ac6454SAndrew Thompson rxmode = le16toh(rxmode);
143002ac6454SAndrew Thompson
1431*935b194dSJustin Hibbits if (if_getflags(ifp) & IFF_PROMISC) {
143202ac6454SAndrew Thompson rxmode |= AXE_RXCMD_PROMISC;
143302ac6454SAndrew Thompson } else {
143402ac6454SAndrew Thompson rxmode &= ~AXE_RXCMD_PROMISC;
143502ac6454SAndrew Thompson }
143602ac6454SAndrew Thompson
143702ac6454SAndrew Thompson axe_cmd(sc, AXE_CMD_RXCTL_WRITE, 0, rxmode, NULL);
143802ac6454SAndrew Thompson
143902ac6454SAndrew Thompson axe_setmulti(ue);
144002ac6454SAndrew Thompson }
144102ac6454SAndrew Thompson
144202ac6454SAndrew Thompson static void
axe_stop(struct usb_ether * ue)1443760bc48eSAndrew Thompson axe_stop(struct usb_ether *ue)
144402ac6454SAndrew Thompson {
1445a593f6b8SAndrew Thompson struct axe_softc *sc = uether_getsc(ue);
1446*935b194dSJustin Hibbits if_t ifp = uether_getifp(ue);
144702ac6454SAndrew Thompson
144802ac6454SAndrew Thompson AXE_LOCK_ASSERT(sc, MA_OWNED);
144902ac6454SAndrew Thompson
1450*935b194dSJustin Hibbits if_setdrvflagbits(ifp, 0, (IFF_DRV_RUNNING | IFF_DRV_OACTIVE));
145102ac6454SAndrew Thompson sc->sc_flags &= ~AXE_FLAG_LINK;
145202ac6454SAndrew Thompson
145302ac6454SAndrew Thompson /*
145402ac6454SAndrew Thompson * stop all the transfers, if not already stopped:
145502ac6454SAndrew Thompson */
1456a593f6b8SAndrew Thompson usbd_transfer_stop(sc->sc_xfer[AXE_BULK_DT_WR]);
1457a593f6b8SAndrew Thompson usbd_transfer_stop(sc->sc_xfer[AXE_BULK_DT_RD]);
145802ac6454SAndrew Thompson }
1459cdc2a5ecSPyun YongHyeon
1460cdc2a5ecSPyun YongHyeon static int
axe_ioctl(if_t ifp,u_long cmd,caddr_t data)1461*935b194dSJustin Hibbits axe_ioctl(if_t ifp, u_long cmd, caddr_t data)
1462cdc2a5ecSPyun YongHyeon {
1463*935b194dSJustin Hibbits struct usb_ether *ue = if_getsoftc(ifp);
1464cdc2a5ecSPyun YongHyeon struct axe_softc *sc;
1465cdc2a5ecSPyun YongHyeon struct ifreq *ifr;
1466cdc2a5ecSPyun YongHyeon int error, mask, reinit;
1467cdc2a5ecSPyun YongHyeon
1468cdc2a5ecSPyun YongHyeon sc = uether_getsc(ue);
1469cdc2a5ecSPyun YongHyeon ifr = (struct ifreq *)data;
1470cdc2a5ecSPyun YongHyeon error = 0;
1471cdc2a5ecSPyun YongHyeon reinit = 0;
1472cdc2a5ecSPyun YongHyeon if (cmd == SIOCSIFCAP) {
1473cdc2a5ecSPyun YongHyeon AXE_LOCK(sc);
1474*935b194dSJustin Hibbits mask = ifr->ifr_reqcap ^ if_getcapenable(ifp);
1475cdc2a5ecSPyun YongHyeon if ((mask & IFCAP_TXCSUM) != 0 &&
1476*935b194dSJustin Hibbits (if_getcapabilities(ifp) & IFCAP_TXCSUM) != 0) {
1477*935b194dSJustin Hibbits if_togglecapenable(ifp, IFCAP_TXCSUM);
1478*935b194dSJustin Hibbits if ((if_getcapenable(ifp) & IFCAP_TXCSUM) != 0)
1479*935b194dSJustin Hibbits if_sethwassistbits(ifp, AXE_CSUM_FEATURES, 0);
1480cdc2a5ecSPyun YongHyeon else
1481*935b194dSJustin Hibbits if_sethwassistbits(ifp, 0, AXE_CSUM_FEATURES);
1482cdc2a5ecSPyun YongHyeon reinit++;
1483cdc2a5ecSPyun YongHyeon }
1484cdc2a5ecSPyun YongHyeon if ((mask & IFCAP_RXCSUM) != 0 &&
1485*935b194dSJustin Hibbits (if_getcapabilities(ifp) & IFCAP_RXCSUM) != 0) {
1486*935b194dSJustin Hibbits if_togglecapenable(ifp, IFCAP_RXCSUM);
1487cdc2a5ecSPyun YongHyeon reinit++;
1488cdc2a5ecSPyun YongHyeon }
1489*935b194dSJustin Hibbits if (reinit > 0 && if_getdrvflags(ifp) & IFF_DRV_RUNNING)
1490*935b194dSJustin Hibbits if_setdrvflagbits(ifp, 0, IFF_DRV_RUNNING);
1491cdc2a5ecSPyun YongHyeon else
1492cdc2a5ecSPyun YongHyeon reinit = 0;
1493cdc2a5ecSPyun YongHyeon AXE_UNLOCK(sc);
1494cdc2a5ecSPyun YongHyeon if (reinit > 0)
1495cdc2a5ecSPyun YongHyeon uether_init(ue);
1496cdc2a5ecSPyun YongHyeon } else
1497cdc2a5ecSPyun YongHyeon error = uether_ioctl(ifp, cmd, data);
1498cdc2a5ecSPyun YongHyeon
1499cdc2a5ecSPyun YongHyeon return (error);
1500cdc2a5ecSPyun YongHyeon }
1501