102ac6454SAndrew Thompson /*- 202ac6454SAndrew Thompson * Copyright (c) 2001-2003, Shunsuke Akiyama <akiyama@FreeBSD.org>. 302ac6454SAndrew Thompson * Copyright (c) 1997, 1998, 1999, 2000 Bill Paul <wpaul@ee.columbia.edu>. 402ac6454SAndrew Thompson * All rights reserved. 502ac6454SAndrew Thompson * 602ac6454SAndrew Thompson * Redistribution and use in source and binary forms, with or without 702ac6454SAndrew Thompson * modification, are permitted provided that the following conditions 802ac6454SAndrew Thompson * are met: 902ac6454SAndrew Thompson * 1. Redistributions of source code must retain the above copyright 1002ac6454SAndrew Thompson * notice, this list of conditions and the following disclaimer. 1102ac6454SAndrew Thompson * 2. Redistributions in binary form must reproduce the above copyright 1202ac6454SAndrew Thompson * notice, this list of conditions and the following disclaimer in the 1302ac6454SAndrew Thompson * documentation and/or other materials provided with the distribution. 1402ac6454SAndrew Thompson * 1502ac6454SAndrew Thompson * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 1602ac6454SAndrew Thompson * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 1702ac6454SAndrew Thompson * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 1802ac6454SAndrew Thompson * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 1902ac6454SAndrew Thompson * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 2002ac6454SAndrew Thompson * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 2102ac6454SAndrew Thompson * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 2202ac6454SAndrew Thompson * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 2302ac6454SAndrew Thompson * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 2402ac6454SAndrew Thompson * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 2502ac6454SAndrew Thompson * SUCH DAMAGE. 2602ac6454SAndrew Thompson */ 2702ac6454SAndrew Thompson /*- 28df57947fSPedro F. Giffuni * SPDX-License-Identifier: BSD-4-Clause AND BSD-2-Clause-FreeBSD 29df57947fSPedro F. Giffuni * 3002ac6454SAndrew Thompson * Copyright (c) 1997, 1998, 1999, 2000 3102ac6454SAndrew Thompson * Bill Paul <wpaul@ee.columbia.edu>. All rights reserved. 3202ac6454SAndrew Thompson * 3302ac6454SAndrew Thompson * Redistribution and use in source and binary forms, with or without 3402ac6454SAndrew Thompson * modification, are permitted provided that the following conditions 3502ac6454SAndrew Thompson * are met: 3602ac6454SAndrew Thompson * 1. Redistributions of source code must retain the above copyright 3702ac6454SAndrew Thompson * notice, this list of conditions and the following disclaimer. 3802ac6454SAndrew Thompson * 2. Redistributions in binary form must reproduce the above copyright 3902ac6454SAndrew Thompson * notice, this list of conditions and the following disclaimer in the 4002ac6454SAndrew Thompson * documentation and/or other materials provided with the distribution. 4102ac6454SAndrew Thompson * 3. All advertising materials mentioning features or use of this software 4202ac6454SAndrew Thompson * must display the following acknowledgement: 4302ac6454SAndrew Thompson * This product includes software developed by Bill Paul. 4402ac6454SAndrew Thompson * 4. Neither the name of the author nor the names of any co-contributors 4502ac6454SAndrew Thompson * may be used to endorse or promote products derived from this software 4602ac6454SAndrew Thompson * without specific prior written permission. 4702ac6454SAndrew Thompson * 4802ac6454SAndrew Thompson * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND 4902ac6454SAndrew Thompson * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 5002ac6454SAndrew Thompson * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 5102ac6454SAndrew Thompson * ARE DISCLAIMED. IN NO EVENT SHALL Bill Paul OR THE VOICES IN HIS HEAD 5202ac6454SAndrew Thompson * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 5302ac6454SAndrew Thompson * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 5402ac6454SAndrew Thompson * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 5502ac6454SAndrew Thompson * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 5602ac6454SAndrew Thompson * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 5702ac6454SAndrew Thompson * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 5802ac6454SAndrew Thompson * THE POSSIBILITY OF SUCH DAMAGE. 5902ac6454SAndrew Thompson */ 6002ac6454SAndrew Thompson 6102ac6454SAndrew Thompson #include <sys/cdefs.h> 6202ac6454SAndrew Thompson __FBSDID("$FreeBSD$"); 6302ac6454SAndrew Thompson 6402ac6454SAndrew Thompson /* 6502ac6454SAndrew Thompson * RealTek RTL8150 USB to fast ethernet controller driver. 6602ac6454SAndrew Thompson * Datasheet is available from 6702ac6454SAndrew Thompson * ftp://ftp.realtek.com.tw/lancard/data_sheet/8150/. 6802ac6454SAndrew Thompson */ 6902ac6454SAndrew Thompson 70ed6d949aSAndrew Thompson #include <sys/stdint.h> 71ed6d949aSAndrew Thompson #include <sys/stddef.h> 72ed6d949aSAndrew Thompson #include <sys/param.h> 73ed6d949aSAndrew Thompson #include <sys/queue.h> 74ed6d949aSAndrew Thompson #include <sys/types.h> 75ed6d949aSAndrew Thompson #include <sys/systm.h> 7676039bc8SGleb Smirnoff #include <sys/socket.h> 77ed6d949aSAndrew Thompson #include <sys/kernel.h> 78ed6d949aSAndrew Thompson #include <sys/bus.h> 79ed6d949aSAndrew Thompson #include <sys/module.h> 80ed6d949aSAndrew Thompson #include <sys/lock.h> 81ed6d949aSAndrew Thompson #include <sys/mutex.h> 82ed6d949aSAndrew Thompson #include <sys/condvar.h> 83ed6d949aSAndrew Thompson #include <sys/sysctl.h> 84ed6d949aSAndrew Thompson #include <sys/sx.h> 85ed6d949aSAndrew Thompson #include <sys/unistd.h> 86ed6d949aSAndrew Thompson #include <sys/callout.h> 87ed6d949aSAndrew Thompson #include <sys/malloc.h> 88ed6d949aSAndrew Thompson #include <sys/priv.h> 89ed6d949aSAndrew Thompson 9076039bc8SGleb Smirnoff #include <net/if.h> 9176039bc8SGleb Smirnoff #include <net/if_var.h> 9231c484adSJustin Hibbits #include <net/if_media.h> 9331c484adSJustin Hibbits 9431c484adSJustin Hibbits #include <dev/mii/mii.h> 9531c484adSJustin Hibbits #include <dev/mii/miivar.h> 9676039bc8SGleb Smirnoff 9702ac6454SAndrew Thompson #include <dev/usb/usb.h> 98ed6d949aSAndrew Thompson #include <dev/usb/usbdi.h> 99ed6d949aSAndrew Thompson #include <dev/usb/usbdi_util.h> 100ed6d949aSAndrew Thompson #include "usbdevs.h" 10102ac6454SAndrew Thompson 10202ac6454SAndrew Thompson #define USB_DEBUG_VAR rue_debug 10302ac6454SAndrew Thompson #include <dev/usb/usb_debug.h> 104ed6d949aSAndrew Thompson #include <dev/usb/usb_process.h> 10502ac6454SAndrew Thompson 10602ac6454SAndrew Thompson #include <dev/usb/net/usb_ethernet.h> 10702ac6454SAndrew Thompson #include <dev/usb/net/if_ruereg.h> 10802ac6454SAndrew Thompson 10931c484adSJustin Hibbits #include "miibus_if.h" 11031c484adSJustin Hibbits 111b850ecc1SAndrew Thompson #ifdef USB_DEBUG 11202ac6454SAndrew Thompson static int rue_debug = 0; 11302ac6454SAndrew Thompson 114f8d2b1f3SPawel Biernacki static SYSCTL_NODE(_hw_usb, OID_AUTO, rue, CTLFLAG_RW | CTLFLAG_MPSAFE, 0, 115f8d2b1f3SPawel Biernacki "USB rue"); 116ece4b0bdSHans Petter Selasky SYSCTL_INT(_hw_usb_rue, OID_AUTO, debug, CTLFLAG_RWTUN, 11702ac6454SAndrew Thompson &rue_debug, 0, "Debug level"); 11802ac6454SAndrew Thompson #endif 11902ac6454SAndrew Thompson 12002ac6454SAndrew Thompson /* 12102ac6454SAndrew Thompson * Various supported device vendors/products. 12202ac6454SAndrew Thompson */ 12302ac6454SAndrew Thompson 124f1a16106SHans Petter Selasky static const STRUCT_USB_HOST_ID rue_devs[] = { 12502ac6454SAndrew Thompson {USB_VPI(USB_VENDOR_MELCO, USB_PRODUCT_MELCO_LUAKTX, 0)}, 12602ac6454SAndrew Thompson {USB_VPI(USB_VENDOR_REALTEK, USB_PRODUCT_REALTEK_USBKR100, 0)}, 1278f55d259SAndrew Thompson {USB_VPI(USB_VENDOR_OQO, USB_PRODUCT_OQO_ETHER01, 0)}, 12802ac6454SAndrew Thompson }; 12902ac6454SAndrew Thompson 13002ac6454SAndrew Thompson /* prototypes */ 13102ac6454SAndrew Thompson 13202ac6454SAndrew Thompson static device_probe_t rue_probe; 13302ac6454SAndrew Thompson static device_attach_t rue_attach; 13402ac6454SAndrew Thompson static device_detach_t rue_detach; 13502ac6454SAndrew Thompson 13602ac6454SAndrew Thompson static miibus_readreg_t rue_miibus_readreg; 13702ac6454SAndrew Thompson static miibus_writereg_t rue_miibus_writereg; 13802ac6454SAndrew Thompson static miibus_statchg_t rue_miibus_statchg; 13902ac6454SAndrew Thompson 140e0a69b51SAndrew Thompson static usb_callback_t rue_intr_callback; 141e0a69b51SAndrew Thompson static usb_callback_t rue_bulk_read_callback; 142e0a69b51SAndrew Thompson static usb_callback_t rue_bulk_write_callback; 14302ac6454SAndrew Thompson 144e0a69b51SAndrew Thompson static uether_fn_t rue_attach_post; 145e0a69b51SAndrew Thompson static uether_fn_t rue_init; 146e0a69b51SAndrew Thompson static uether_fn_t rue_stop; 147e0a69b51SAndrew Thompson static uether_fn_t rue_start; 148e0a69b51SAndrew Thompson static uether_fn_t rue_tick; 149e0a69b51SAndrew Thompson static uether_fn_t rue_setmulti; 150e0a69b51SAndrew Thompson static uether_fn_t rue_setpromisc; 15102ac6454SAndrew Thompson 15202ac6454SAndrew Thompson static int rue_read_mem(struct rue_softc *, uint16_t, void *, int); 15302ac6454SAndrew Thompson static int rue_write_mem(struct rue_softc *, uint16_t, void *, int); 15402ac6454SAndrew Thompson static uint8_t rue_csr_read_1(struct rue_softc *, uint16_t); 15502ac6454SAndrew Thompson static uint16_t rue_csr_read_2(struct rue_softc *, uint16_t); 15602ac6454SAndrew Thompson static int rue_csr_write_1(struct rue_softc *, uint16_t, uint8_t); 15702ac6454SAndrew Thompson static int rue_csr_write_2(struct rue_softc *, uint16_t, uint16_t); 15802ac6454SAndrew Thompson static int rue_csr_write_4(struct rue_softc *, int, uint32_t); 15902ac6454SAndrew Thompson 16002ac6454SAndrew Thompson static void rue_reset(struct rue_softc *); 16102ac6454SAndrew Thompson static int rue_ifmedia_upd(struct ifnet *); 16202ac6454SAndrew Thompson static void rue_ifmedia_sts(struct ifnet *, struct ifmediareq *); 16302ac6454SAndrew Thompson 164760bc48eSAndrew Thompson static const struct usb_config rue_config[RUE_N_TRANSFER] = { 16502ac6454SAndrew Thompson 16602ac6454SAndrew Thompson [RUE_BULK_DT_WR] = { 16702ac6454SAndrew Thompson .type = UE_BULK, 16802ac6454SAndrew Thompson .endpoint = UE_ADDR_ANY, 16902ac6454SAndrew Thompson .direction = UE_DIR_OUT, 1704eae601eSAndrew Thompson .bufsize = MCLBYTES, 1714eae601eSAndrew Thompson .flags = {.pipe_bof = 1,.force_short_xfer = 1,}, 1724eae601eSAndrew Thompson .callback = rue_bulk_write_callback, 1734eae601eSAndrew Thompson .timeout = 10000, /* 10 seconds */ 17402ac6454SAndrew Thompson }, 17502ac6454SAndrew Thompson 17602ac6454SAndrew Thompson [RUE_BULK_DT_RD] = { 17702ac6454SAndrew Thompson .type = UE_BULK, 17802ac6454SAndrew Thompson .endpoint = UE_ADDR_ANY, 17902ac6454SAndrew Thompson .direction = UE_DIR_IN, 1804eae601eSAndrew Thompson .bufsize = (MCLBYTES + 4), 1814eae601eSAndrew Thompson .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, 1824eae601eSAndrew Thompson .callback = rue_bulk_read_callback, 1834eae601eSAndrew Thompson .timeout = 0, /* no timeout */ 18402ac6454SAndrew Thompson }, 18502ac6454SAndrew Thompson 18602ac6454SAndrew Thompson [RUE_INTR_DT_RD] = { 18702ac6454SAndrew Thompson .type = UE_INTERRUPT, 18802ac6454SAndrew Thompson .endpoint = UE_ADDR_ANY, 18902ac6454SAndrew Thompson .direction = UE_DIR_IN, 1904eae601eSAndrew Thompson .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, 1914eae601eSAndrew Thompson .bufsize = 0, /* use wMaxPacketSize */ 1924eae601eSAndrew Thompson .callback = rue_intr_callback, 19302ac6454SAndrew Thompson }, 19402ac6454SAndrew Thompson }; 19502ac6454SAndrew Thompson 19602ac6454SAndrew Thompson static device_method_t rue_methods[] = { 19702ac6454SAndrew Thompson /* Device interface */ 19802ac6454SAndrew Thompson DEVMETHOD(device_probe, rue_probe), 19902ac6454SAndrew Thompson DEVMETHOD(device_attach, rue_attach), 20002ac6454SAndrew Thompson DEVMETHOD(device_detach, rue_detach), 20102ac6454SAndrew Thompson 20202ac6454SAndrew Thompson /* MII interface */ 20302ac6454SAndrew Thompson DEVMETHOD(miibus_readreg, rue_miibus_readreg), 20402ac6454SAndrew Thompson DEVMETHOD(miibus_writereg, rue_miibus_writereg), 20502ac6454SAndrew Thompson DEVMETHOD(miibus_statchg, rue_miibus_statchg), 20602ac6454SAndrew Thompson 2074b7ec270SMarius Strobl DEVMETHOD_END 20802ac6454SAndrew Thompson }; 20902ac6454SAndrew Thompson 21002ac6454SAndrew Thompson static driver_t rue_driver = { 21102ac6454SAndrew Thompson .name = "rue", 21202ac6454SAndrew Thompson .methods = rue_methods, 21302ac6454SAndrew Thompson .size = sizeof(struct rue_softc), 21402ac6454SAndrew Thompson }; 21502ac6454SAndrew Thompson 21602ac6454SAndrew Thompson static devclass_t rue_devclass; 21702ac6454SAndrew Thompson 218e4029d4cSMarius Strobl DRIVER_MODULE_ORDERED(rue, uhub, rue_driver, rue_devclass, NULL, NULL, 219e4029d4cSMarius Strobl SI_ORDER_ANY); 220e4029d4cSMarius Strobl DRIVER_MODULE(miibus, rue, miibus_driver, miibus_devclass, NULL, NULL); 22102ac6454SAndrew Thompson MODULE_DEPEND(rue, uether, 1, 1, 1); 22202ac6454SAndrew Thompson MODULE_DEPEND(rue, usb, 1, 1, 1); 22302ac6454SAndrew Thompson MODULE_DEPEND(rue, ether, 1, 1, 1); 22402ac6454SAndrew Thompson MODULE_DEPEND(rue, miibus, 1, 1, 1); 225910cb8feSAndrew Thompson MODULE_VERSION(rue, 1); 226f809f280SWarner Losh USB_PNP_HOST_INFO(rue_devs); 22702ac6454SAndrew Thompson 228760bc48eSAndrew Thompson static const struct usb_ether_methods rue_ue_methods = { 22902ac6454SAndrew Thompson .ue_attach_post = rue_attach_post, 23002ac6454SAndrew Thompson .ue_start = rue_start, 23102ac6454SAndrew Thompson .ue_init = rue_init, 23202ac6454SAndrew Thompson .ue_stop = rue_stop, 23302ac6454SAndrew Thompson .ue_tick = rue_tick, 23402ac6454SAndrew Thompson .ue_setmulti = rue_setmulti, 23502ac6454SAndrew Thompson .ue_setpromisc = rue_setpromisc, 23602ac6454SAndrew Thompson .ue_mii_upd = rue_ifmedia_upd, 23702ac6454SAndrew Thompson .ue_mii_sts = rue_ifmedia_sts, 23802ac6454SAndrew Thompson }; 23902ac6454SAndrew Thompson 24002ac6454SAndrew Thompson #define RUE_SETBIT(sc, reg, x) \ 24102ac6454SAndrew Thompson rue_csr_write_1(sc, reg, rue_csr_read_1(sc, reg) | (x)) 24202ac6454SAndrew Thompson 24302ac6454SAndrew Thompson #define RUE_CLRBIT(sc, reg, x) \ 24402ac6454SAndrew Thompson rue_csr_write_1(sc, reg, rue_csr_read_1(sc, reg) & ~(x)) 24502ac6454SAndrew Thompson 24602ac6454SAndrew Thompson static int 24702ac6454SAndrew Thompson rue_read_mem(struct rue_softc *sc, uint16_t addr, void *buf, int len) 24802ac6454SAndrew Thompson { 249760bc48eSAndrew Thompson struct usb_device_request req; 25002ac6454SAndrew Thompson 25102ac6454SAndrew Thompson req.bmRequestType = UT_READ_VENDOR_DEVICE; 25202ac6454SAndrew Thompson req.bRequest = UR_SET_ADDRESS; 25302ac6454SAndrew Thompson USETW(req.wValue, addr); 25402ac6454SAndrew Thompson USETW(req.wIndex, 0); 25502ac6454SAndrew Thompson USETW(req.wLength, len); 25602ac6454SAndrew Thompson 257a593f6b8SAndrew Thompson return (uether_do_request(&sc->sc_ue, &req, buf, 1000)); 25802ac6454SAndrew Thompson } 25902ac6454SAndrew Thompson 26002ac6454SAndrew Thompson static int 26102ac6454SAndrew Thompson rue_write_mem(struct rue_softc *sc, uint16_t addr, void *buf, int len) 26202ac6454SAndrew Thompson { 263760bc48eSAndrew Thompson struct usb_device_request req; 26402ac6454SAndrew Thompson 26502ac6454SAndrew Thompson req.bmRequestType = UT_WRITE_VENDOR_DEVICE; 26602ac6454SAndrew Thompson req.bRequest = UR_SET_ADDRESS; 26702ac6454SAndrew Thompson USETW(req.wValue, addr); 26802ac6454SAndrew Thompson USETW(req.wIndex, 0); 26902ac6454SAndrew Thompson USETW(req.wLength, len); 27002ac6454SAndrew Thompson 271a593f6b8SAndrew Thompson return (uether_do_request(&sc->sc_ue, &req, buf, 1000)); 27202ac6454SAndrew Thompson } 27302ac6454SAndrew Thompson 27402ac6454SAndrew Thompson static uint8_t 27502ac6454SAndrew Thompson rue_csr_read_1(struct rue_softc *sc, uint16_t reg) 27602ac6454SAndrew Thompson { 27702ac6454SAndrew Thompson uint8_t val; 27802ac6454SAndrew Thompson 27902ac6454SAndrew Thompson rue_read_mem(sc, reg, &val, 1); 28002ac6454SAndrew Thompson return (val); 28102ac6454SAndrew Thompson } 28202ac6454SAndrew Thompson 28302ac6454SAndrew Thompson static uint16_t 28402ac6454SAndrew Thompson rue_csr_read_2(struct rue_softc *sc, uint16_t reg) 28502ac6454SAndrew Thompson { 28602ac6454SAndrew Thompson uint8_t val[2]; 28702ac6454SAndrew Thompson 28802ac6454SAndrew Thompson rue_read_mem(sc, reg, &val, 2); 28902ac6454SAndrew Thompson return (UGETW(val)); 29002ac6454SAndrew Thompson } 29102ac6454SAndrew Thompson 29202ac6454SAndrew Thompson static int 29302ac6454SAndrew Thompson rue_csr_write_1(struct rue_softc *sc, uint16_t reg, uint8_t val) 29402ac6454SAndrew Thompson { 29502ac6454SAndrew Thompson return (rue_write_mem(sc, reg, &val, 1)); 29602ac6454SAndrew Thompson } 29702ac6454SAndrew Thompson 29802ac6454SAndrew Thompson static int 29902ac6454SAndrew Thompson rue_csr_write_2(struct rue_softc *sc, uint16_t reg, uint16_t val) 30002ac6454SAndrew Thompson { 30102ac6454SAndrew Thompson uint8_t temp[2]; 30202ac6454SAndrew Thompson 30302ac6454SAndrew Thompson USETW(temp, val); 30402ac6454SAndrew Thompson return (rue_write_mem(sc, reg, &temp, 2)); 30502ac6454SAndrew Thompson } 30602ac6454SAndrew Thompson 30702ac6454SAndrew Thompson static int 30802ac6454SAndrew Thompson rue_csr_write_4(struct rue_softc *sc, int reg, uint32_t val) 30902ac6454SAndrew Thompson { 31002ac6454SAndrew Thompson uint8_t temp[4]; 31102ac6454SAndrew Thompson 31202ac6454SAndrew Thompson USETDW(temp, val); 31302ac6454SAndrew Thompson return (rue_write_mem(sc, reg, &temp, 4)); 31402ac6454SAndrew Thompson } 31502ac6454SAndrew Thompson 31602ac6454SAndrew Thompson static int 31702ac6454SAndrew Thompson rue_miibus_readreg(device_t dev, int phy, int reg) 31802ac6454SAndrew Thompson { 31902ac6454SAndrew Thompson struct rue_softc *sc = device_get_softc(dev); 32002ac6454SAndrew Thompson uint16_t rval; 32102ac6454SAndrew Thompson uint16_t ruereg; 32202ac6454SAndrew Thompson int locked; 32302ac6454SAndrew Thompson 32402ac6454SAndrew Thompson if (phy != 0) /* RTL8150 supports PHY == 0, only */ 32502ac6454SAndrew Thompson return (0); 32602ac6454SAndrew Thompson 32702ac6454SAndrew Thompson locked = mtx_owned(&sc->sc_mtx); 32802ac6454SAndrew Thompson if (!locked) 32902ac6454SAndrew Thompson RUE_LOCK(sc); 33002ac6454SAndrew Thompson 33102ac6454SAndrew Thompson switch (reg) { 33202ac6454SAndrew Thompson case MII_BMCR: 33302ac6454SAndrew Thompson ruereg = RUE_BMCR; 33402ac6454SAndrew Thompson break; 33502ac6454SAndrew Thompson case MII_BMSR: 33602ac6454SAndrew Thompson ruereg = RUE_BMSR; 33702ac6454SAndrew Thompson break; 33802ac6454SAndrew Thompson case MII_ANAR: 33902ac6454SAndrew Thompson ruereg = RUE_ANAR; 34002ac6454SAndrew Thompson break; 34102ac6454SAndrew Thompson case MII_ANER: 34202ac6454SAndrew Thompson ruereg = RUE_AER; 34302ac6454SAndrew Thompson break; 34402ac6454SAndrew Thompson case MII_ANLPAR: 34502ac6454SAndrew Thompson ruereg = RUE_ANLP; 34602ac6454SAndrew Thompson break; 34702ac6454SAndrew Thompson case MII_PHYIDR1: 34802ac6454SAndrew Thompson case MII_PHYIDR2: 34902ac6454SAndrew Thompson rval = 0; 35002ac6454SAndrew Thompson goto done; 35102ac6454SAndrew Thompson default: 35202ac6454SAndrew Thompson if (RUE_REG_MIN <= reg && reg <= RUE_REG_MAX) { 35302ac6454SAndrew Thompson rval = rue_csr_read_1(sc, reg); 35402ac6454SAndrew Thompson goto done; 35502ac6454SAndrew Thompson } 35602ac6454SAndrew Thompson device_printf(sc->sc_ue.ue_dev, "bad phy register\n"); 35702ac6454SAndrew Thompson rval = 0; 35802ac6454SAndrew Thompson goto done; 35902ac6454SAndrew Thompson } 36002ac6454SAndrew Thompson 36102ac6454SAndrew Thompson rval = rue_csr_read_2(sc, ruereg); 36202ac6454SAndrew Thompson done: 36302ac6454SAndrew Thompson if (!locked) 36402ac6454SAndrew Thompson RUE_UNLOCK(sc); 36502ac6454SAndrew Thompson return (rval); 36602ac6454SAndrew Thompson } 36702ac6454SAndrew Thompson 36802ac6454SAndrew Thompson static int 36902ac6454SAndrew Thompson rue_miibus_writereg(device_t dev, int phy, int reg, int data) 37002ac6454SAndrew Thompson { 37102ac6454SAndrew Thompson struct rue_softc *sc = device_get_softc(dev); 37202ac6454SAndrew Thompson uint16_t ruereg; 37302ac6454SAndrew Thompson int locked; 37402ac6454SAndrew Thompson 37502ac6454SAndrew Thompson if (phy != 0) /* RTL8150 supports PHY == 0, only */ 37602ac6454SAndrew Thompson return (0); 37702ac6454SAndrew Thompson 37802ac6454SAndrew Thompson locked = mtx_owned(&sc->sc_mtx); 37902ac6454SAndrew Thompson if (!locked) 38002ac6454SAndrew Thompson RUE_LOCK(sc); 38102ac6454SAndrew Thompson 38202ac6454SAndrew Thompson switch (reg) { 38302ac6454SAndrew Thompson case MII_BMCR: 38402ac6454SAndrew Thompson ruereg = RUE_BMCR; 38502ac6454SAndrew Thompson break; 38602ac6454SAndrew Thompson case MII_BMSR: 38702ac6454SAndrew Thompson ruereg = RUE_BMSR; 38802ac6454SAndrew Thompson break; 38902ac6454SAndrew Thompson case MII_ANAR: 39002ac6454SAndrew Thompson ruereg = RUE_ANAR; 39102ac6454SAndrew Thompson break; 39202ac6454SAndrew Thompson case MII_ANER: 39302ac6454SAndrew Thompson ruereg = RUE_AER; 39402ac6454SAndrew Thompson break; 39502ac6454SAndrew Thompson case MII_ANLPAR: 39602ac6454SAndrew Thompson ruereg = RUE_ANLP; 39702ac6454SAndrew Thompson break; 39802ac6454SAndrew Thompson case MII_PHYIDR1: 39902ac6454SAndrew Thompson case MII_PHYIDR2: 40002ac6454SAndrew Thompson goto done; 40102ac6454SAndrew Thompson default: 40202ac6454SAndrew Thompson if (RUE_REG_MIN <= reg && reg <= RUE_REG_MAX) { 40302ac6454SAndrew Thompson rue_csr_write_1(sc, reg, data); 40402ac6454SAndrew Thompson goto done; 40502ac6454SAndrew Thompson } 40602ac6454SAndrew Thompson device_printf(sc->sc_ue.ue_dev, " bad phy register\n"); 40702ac6454SAndrew Thompson goto done; 40802ac6454SAndrew Thompson } 40902ac6454SAndrew Thompson rue_csr_write_2(sc, ruereg, data); 41002ac6454SAndrew Thompson done: 41102ac6454SAndrew Thompson if (!locked) 41202ac6454SAndrew Thompson RUE_UNLOCK(sc); 41302ac6454SAndrew Thompson return (0); 41402ac6454SAndrew Thompson } 41502ac6454SAndrew Thompson 41602ac6454SAndrew Thompson static void 41702ac6454SAndrew Thompson rue_miibus_statchg(device_t dev) 41802ac6454SAndrew Thompson { 41902ac6454SAndrew Thompson /* 42002ac6454SAndrew Thompson * When the code below is enabled the card starts doing weird 42102ac6454SAndrew Thompson * things after link going from UP to DOWN and back UP. 42202ac6454SAndrew Thompson * 42302ac6454SAndrew Thompson * Looks like some of register writes below messes up PHY 42402ac6454SAndrew Thompson * interface. 42502ac6454SAndrew Thompson * 42602ac6454SAndrew Thompson * No visible regressions were found after commenting this code 42702ac6454SAndrew Thompson * out, so that disable it for good. 42802ac6454SAndrew Thompson */ 42902ac6454SAndrew Thompson #if 0 43002ac6454SAndrew Thompson struct rue_softc *sc = device_get_softc(dev); 43102ac6454SAndrew Thompson struct mii_data *mii = GET_MII(sc); 43202ac6454SAndrew Thompson uint16_t bmcr; 43302ac6454SAndrew Thompson int locked; 43402ac6454SAndrew Thompson 43502ac6454SAndrew Thompson locked = mtx_owned(&sc->sc_mtx); 43602ac6454SAndrew Thompson if (!locked) 43702ac6454SAndrew Thompson RUE_LOCK(sc); 43802ac6454SAndrew Thompson 43902ac6454SAndrew Thompson RUE_CLRBIT(sc, RUE_CR, (RUE_CR_RE | RUE_CR_TE)); 44002ac6454SAndrew Thompson 44102ac6454SAndrew Thompson bmcr = rue_csr_read_2(sc, RUE_BMCR); 44202ac6454SAndrew Thompson 44302ac6454SAndrew Thompson if (IFM_SUBTYPE(mii->mii_media_active) == IFM_100_TX) 44402ac6454SAndrew Thompson bmcr |= RUE_BMCR_SPD_SET; 44502ac6454SAndrew Thompson else 44602ac6454SAndrew Thompson bmcr &= ~RUE_BMCR_SPD_SET; 44702ac6454SAndrew Thompson 44802ac6454SAndrew Thompson if ((mii->mii_media_active & IFM_GMASK) == IFM_FDX) 44902ac6454SAndrew Thompson bmcr |= RUE_BMCR_DUPLEX; 45002ac6454SAndrew Thompson else 45102ac6454SAndrew Thompson bmcr &= ~RUE_BMCR_DUPLEX; 45202ac6454SAndrew Thompson 45302ac6454SAndrew Thompson rue_csr_write_2(sc, RUE_BMCR, bmcr); 45402ac6454SAndrew Thompson 45502ac6454SAndrew Thompson RUE_SETBIT(sc, RUE_CR, (RUE_CR_RE | RUE_CR_TE)); 45602ac6454SAndrew Thompson 45702ac6454SAndrew Thompson if (!locked) 45802ac6454SAndrew Thompson RUE_UNLOCK(sc); 45902ac6454SAndrew Thompson #endif 46002ac6454SAndrew Thompson } 46102ac6454SAndrew Thompson 46202ac6454SAndrew Thompson static void 463760bc48eSAndrew Thompson rue_setpromisc(struct usb_ether *ue) 46402ac6454SAndrew Thompson { 465a593f6b8SAndrew Thompson struct rue_softc *sc = uether_getsc(ue); 466a593f6b8SAndrew Thompson struct ifnet *ifp = uether_getifp(ue); 46702ac6454SAndrew Thompson 46802ac6454SAndrew Thompson RUE_LOCK_ASSERT(sc, MA_OWNED); 46902ac6454SAndrew Thompson 47002ac6454SAndrew Thompson /* If we want promiscuous mode, set the allframes bit. */ 47102ac6454SAndrew Thompson if (ifp->if_flags & IFF_PROMISC) 47202ac6454SAndrew Thompson RUE_SETBIT(sc, RUE_RCR, RUE_RCR_AAP); 47302ac6454SAndrew Thompson else 47402ac6454SAndrew Thompson RUE_CLRBIT(sc, RUE_RCR, RUE_RCR_AAP); 47502ac6454SAndrew Thompson } 47602ac6454SAndrew Thompson 477100ad729SGleb Smirnoff static u_int 478100ad729SGleb Smirnoff rue_hash_maddr(void *arg, struct sockaddr_dl *sdl, u_int cnt) 479100ad729SGleb Smirnoff { 480100ad729SGleb Smirnoff uint32_t *hashes = arg; 481100ad729SGleb Smirnoff int h; 482100ad729SGleb Smirnoff 483100ad729SGleb Smirnoff h = ether_crc32_be(LLADDR(sdl), ETHER_ADDR_LEN) >> 26; 484100ad729SGleb Smirnoff if (h < 32) 485100ad729SGleb Smirnoff hashes[0] |= (1 << h); 486100ad729SGleb Smirnoff else 487100ad729SGleb Smirnoff hashes[1] |= (1 << (h - 32)); 488100ad729SGleb Smirnoff 489100ad729SGleb Smirnoff return (1); 490100ad729SGleb Smirnoff } 491100ad729SGleb Smirnoff 49202ac6454SAndrew Thompson /* 49302ac6454SAndrew Thompson * Program the 64-bit multicast hash filter. 49402ac6454SAndrew Thompson */ 49502ac6454SAndrew Thompson static void 496760bc48eSAndrew Thompson rue_setmulti(struct usb_ether *ue) 49702ac6454SAndrew Thompson { 498a593f6b8SAndrew Thompson struct rue_softc *sc = uether_getsc(ue); 499a593f6b8SAndrew Thompson struct ifnet *ifp = uether_getifp(ue); 50002ac6454SAndrew Thompson uint16_t rxcfg; 50102ac6454SAndrew Thompson uint32_t hashes[2] = { 0, 0 }; 502100ad729SGleb Smirnoff int mcnt; 50302ac6454SAndrew Thompson 50402ac6454SAndrew Thompson RUE_LOCK_ASSERT(sc, MA_OWNED); 50502ac6454SAndrew Thompson 50602ac6454SAndrew Thompson rxcfg = rue_csr_read_2(sc, RUE_RCR); 50702ac6454SAndrew Thompson 50802ac6454SAndrew Thompson if (ifp->if_flags & IFF_ALLMULTI || ifp->if_flags & IFF_PROMISC) { 50902ac6454SAndrew Thompson rxcfg |= (RUE_RCR_AAM | RUE_RCR_AAP); 51002ac6454SAndrew Thompson rxcfg &= ~RUE_RCR_AM; 51102ac6454SAndrew Thompson rue_csr_write_2(sc, RUE_RCR, rxcfg); 51202ac6454SAndrew Thompson rue_csr_write_4(sc, RUE_MAR0, 0xFFFFFFFF); 51302ac6454SAndrew Thompson rue_csr_write_4(sc, RUE_MAR4, 0xFFFFFFFF); 51402ac6454SAndrew Thompson return; 51502ac6454SAndrew Thompson } 51602ac6454SAndrew Thompson 51702ac6454SAndrew Thompson /* first, zot all the existing hash bits */ 51802ac6454SAndrew Thompson rue_csr_write_4(sc, RUE_MAR0, 0); 51902ac6454SAndrew Thompson rue_csr_write_4(sc, RUE_MAR4, 0); 52002ac6454SAndrew Thompson 52102ac6454SAndrew Thompson /* now program new ones */ 522100ad729SGleb Smirnoff mcnt = if_foreach_llmaddr(ifp, rue_hash_maddr, &hashes); 52302ac6454SAndrew Thompson 52402ac6454SAndrew Thompson if (mcnt) 52502ac6454SAndrew Thompson rxcfg |= RUE_RCR_AM; 52602ac6454SAndrew Thompson else 52702ac6454SAndrew Thompson rxcfg &= ~RUE_RCR_AM; 52802ac6454SAndrew Thompson 52902ac6454SAndrew Thompson rxcfg &= ~(RUE_RCR_AAM | RUE_RCR_AAP); 53002ac6454SAndrew Thompson 53102ac6454SAndrew Thompson rue_csr_write_2(sc, RUE_RCR, rxcfg); 53202ac6454SAndrew Thompson rue_csr_write_4(sc, RUE_MAR0, hashes[0]); 53302ac6454SAndrew Thompson rue_csr_write_4(sc, RUE_MAR4, hashes[1]); 53402ac6454SAndrew Thompson } 53502ac6454SAndrew Thompson 53602ac6454SAndrew Thompson static void 53702ac6454SAndrew Thompson rue_reset(struct rue_softc *sc) 53802ac6454SAndrew Thompson { 53902ac6454SAndrew Thompson int i; 54002ac6454SAndrew Thompson 54102ac6454SAndrew Thompson rue_csr_write_1(sc, RUE_CR, RUE_CR_SOFT_RST); 54202ac6454SAndrew Thompson 54302ac6454SAndrew Thompson for (i = 0; i != RUE_TIMEOUT; i++) { 544a593f6b8SAndrew Thompson if (uether_pause(&sc->sc_ue, hz / 1000)) 54502ac6454SAndrew Thompson break; 54602ac6454SAndrew Thompson if (!(rue_csr_read_1(sc, RUE_CR) & RUE_CR_SOFT_RST)) 54702ac6454SAndrew Thompson break; 54802ac6454SAndrew Thompson } 54902ac6454SAndrew Thompson if (i == RUE_TIMEOUT) 550767cb2e2SAndrew Thompson device_printf(sc->sc_ue.ue_dev, "reset never completed\n"); 55102ac6454SAndrew Thompson 552a593f6b8SAndrew Thompson uether_pause(&sc->sc_ue, hz / 100); 55302ac6454SAndrew Thompson } 55402ac6454SAndrew Thompson 55502ac6454SAndrew Thompson static void 556760bc48eSAndrew Thompson rue_attach_post(struct usb_ether *ue) 55702ac6454SAndrew Thompson { 558a593f6b8SAndrew Thompson struct rue_softc *sc = uether_getsc(ue); 55902ac6454SAndrew Thompson 56002ac6454SAndrew Thompson /* reset the adapter */ 56102ac6454SAndrew Thompson rue_reset(sc); 56202ac6454SAndrew Thompson 56302ac6454SAndrew Thompson /* get station address from the EEPROM */ 56402ac6454SAndrew Thompson rue_read_mem(sc, RUE_EEPROM_IDR0, ue->ue_eaddr, ETHER_ADDR_LEN); 56502ac6454SAndrew Thompson } 56602ac6454SAndrew Thompson 56702ac6454SAndrew Thompson /* 56802ac6454SAndrew Thompson * Probe for a RTL8150 chip. 56902ac6454SAndrew Thompson */ 57002ac6454SAndrew Thompson static int 57102ac6454SAndrew Thompson rue_probe(device_t dev) 57202ac6454SAndrew Thompson { 573760bc48eSAndrew Thompson struct usb_attach_arg *uaa = device_get_ivars(dev); 57402ac6454SAndrew Thompson 575f29a0724SAndrew Thompson if (uaa->usb_mode != USB_MODE_HOST) 57602ac6454SAndrew Thompson return (ENXIO); 57702ac6454SAndrew Thompson if (uaa->info.bConfigIndex != RUE_CONFIG_IDX) 57802ac6454SAndrew Thompson return (ENXIO); 57902ac6454SAndrew Thompson if (uaa->info.bIfaceIndex != RUE_IFACE_IDX) 58002ac6454SAndrew Thompson return (ENXIO); 58102ac6454SAndrew Thompson 582a593f6b8SAndrew Thompson return (usbd_lookup_id_by_uaa(rue_devs, sizeof(rue_devs), uaa)); 58302ac6454SAndrew Thompson } 58402ac6454SAndrew Thompson 58502ac6454SAndrew Thompson /* 58602ac6454SAndrew Thompson * Attach the interface. Allocate softc structures, do ifmedia 58702ac6454SAndrew Thompson * setup and ethernet/BPF attach. 58802ac6454SAndrew Thompson */ 58902ac6454SAndrew Thompson static int 59002ac6454SAndrew Thompson rue_attach(device_t dev) 59102ac6454SAndrew Thompson { 592760bc48eSAndrew Thompson struct usb_attach_arg *uaa = device_get_ivars(dev); 59302ac6454SAndrew Thompson struct rue_softc *sc = device_get_softc(dev); 594760bc48eSAndrew Thompson struct usb_ether *ue = &sc->sc_ue; 59502ac6454SAndrew Thompson uint8_t iface_index; 59602ac6454SAndrew Thompson int error; 59702ac6454SAndrew Thompson 598a593f6b8SAndrew Thompson device_set_usb_desc(dev); 59902ac6454SAndrew Thompson mtx_init(&sc->sc_mtx, device_get_nameunit(dev), NULL, MTX_DEF); 60002ac6454SAndrew Thompson 60102ac6454SAndrew Thompson iface_index = RUE_IFACE_IDX; 602a593f6b8SAndrew Thompson error = usbd_transfer_setup(uaa->device, &iface_index, 60302ac6454SAndrew Thompson sc->sc_xfer, rue_config, RUE_N_TRANSFER, 60402ac6454SAndrew Thompson sc, &sc->sc_mtx); 60502ac6454SAndrew Thompson if (error) { 606767cb2e2SAndrew Thompson device_printf(dev, "allocating USB transfers failed\n"); 60702ac6454SAndrew Thompson goto detach; 60802ac6454SAndrew Thompson } 60902ac6454SAndrew Thompson 61002ac6454SAndrew Thompson ue->ue_sc = sc; 61102ac6454SAndrew Thompson ue->ue_dev = dev; 61202ac6454SAndrew Thompson ue->ue_udev = uaa->device; 61302ac6454SAndrew Thompson ue->ue_mtx = &sc->sc_mtx; 61402ac6454SAndrew Thompson ue->ue_methods = &rue_ue_methods; 61502ac6454SAndrew Thompson 616a593f6b8SAndrew Thompson error = uether_ifattach(ue); 61702ac6454SAndrew Thompson if (error) { 61802ac6454SAndrew Thompson device_printf(dev, "could not attach interface\n"); 61902ac6454SAndrew Thompson goto detach; 62002ac6454SAndrew Thompson } 62102ac6454SAndrew Thompson return (0); /* success */ 62202ac6454SAndrew Thompson 62302ac6454SAndrew Thompson detach: 62402ac6454SAndrew Thompson rue_detach(dev); 62502ac6454SAndrew Thompson return (ENXIO); /* failure */ 62602ac6454SAndrew Thompson } 62702ac6454SAndrew Thompson 62802ac6454SAndrew Thompson static int 62902ac6454SAndrew Thompson rue_detach(device_t dev) 63002ac6454SAndrew Thompson { 63102ac6454SAndrew Thompson struct rue_softc *sc = device_get_softc(dev); 632760bc48eSAndrew Thompson struct usb_ether *ue = &sc->sc_ue; 63302ac6454SAndrew Thompson 634a593f6b8SAndrew Thompson usbd_transfer_unsetup(sc->sc_xfer, RUE_N_TRANSFER); 635a593f6b8SAndrew Thompson uether_ifdetach(ue); 63602ac6454SAndrew Thompson mtx_destroy(&sc->sc_mtx); 63702ac6454SAndrew Thompson 63802ac6454SAndrew Thompson return (0); 63902ac6454SAndrew Thompson } 64002ac6454SAndrew Thompson 64102ac6454SAndrew Thompson static void 642ed6d949aSAndrew Thompson rue_intr_callback(struct usb_xfer *xfer, usb_error_t error) 64302ac6454SAndrew Thompson { 644ed6d949aSAndrew Thompson struct rue_softc *sc = usbd_xfer_softc(xfer); 645a593f6b8SAndrew Thompson struct ifnet *ifp = uether_getifp(&sc->sc_ue); 64602ac6454SAndrew Thompson struct rue_intrpkt pkt; 647ed6d949aSAndrew Thompson struct usb_page_cache *pc; 648ed6d949aSAndrew Thompson int actlen; 649ed6d949aSAndrew Thompson 650ed6d949aSAndrew Thompson usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL); 65102ac6454SAndrew Thompson 65202ac6454SAndrew Thompson switch (USB_GET_STATE(xfer)) { 65302ac6454SAndrew Thompson case USB_ST_TRANSFERRED: 65402ac6454SAndrew Thompson 65502ac6454SAndrew Thompson if (ifp && (ifp->if_drv_flags & IFF_DRV_RUNNING) && 6566d917491SHans Petter Selasky actlen >= (int)sizeof(pkt)) { 65702ac6454SAndrew Thompson 658ed6d949aSAndrew Thompson pc = usbd_xfer_get_frame(xfer, 0); 659ed6d949aSAndrew Thompson usbd_copy_out(pc, 0, &pkt, sizeof(pkt)); 66002ac6454SAndrew Thompson 661ecc70d3fSGleb Smirnoff if_inc_counter(ifp, IFCOUNTER_IERRORS, pkt.rue_rxlost_cnt); 662ecc70d3fSGleb Smirnoff if_inc_counter(ifp, IFCOUNTER_IERRORS, pkt.rue_crcerr_cnt); 663ecc70d3fSGleb Smirnoff if_inc_counter(ifp, IFCOUNTER_COLLISIONS, pkt.rue_col_cnt); 66402ac6454SAndrew Thompson } 66502ac6454SAndrew Thompson /* FALLTHROUGH */ 66602ac6454SAndrew Thompson case USB_ST_SETUP: 66702ac6454SAndrew Thompson tr_setup: 668ed6d949aSAndrew Thompson usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer)); 669a593f6b8SAndrew Thompson usbd_transfer_submit(xfer); 67002ac6454SAndrew Thompson return; 67102ac6454SAndrew Thompson 67202ac6454SAndrew Thompson default: /* Error */ 673ed6d949aSAndrew Thompson if (error != USB_ERR_CANCELLED) { 67402ac6454SAndrew Thompson /* try to clear stall first */ 675ed6d949aSAndrew Thompson usbd_xfer_set_stall(xfer); 67602ac6454SAndrew Thompson goto tr_setup; 67702ac6454SAndrew Thompson } 67802ac6454SAndrew Thompson return; 67902ac6454SAndrew Thompson } 68002ac6454SAndrew Thompson } 68102ac6454SAndrew Thompson 68202ac6454SAndrew Thompson static void 683ed6d949aSAndrew Thompson rue_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error) 68402ac6454SAndrew Thompson { 685ed6d949aSAndrew Thompson struct rue_softc *sc = usbd_xfer_softc(xfer); 686760bc48eSAndrew Thompson struct usb_ether *ue = &sc->sc_ue; 687a593f6b8SAndrew Thompson struct ifnet *ifp = uether_getifp(ue); 688ed6d949aSAndrew Thompson struct usb_page_cache *pc; 68902ac6454SAndrew Thompson uint16_t status; 690ed6d949aSAndrew Thompson int actlen; 691ed6d949aSAndrew Thompson 692ed6d949aSAndrew Thompson usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL); 69302ac6454SAndrew Thompson 69402ac6454SAndrew Thompson switch (USB_GET_STATE(xfer)) { 69502ac6454SAndrew Thompson case USB_ST_TRANSFERRED: 69602ac6454SAndrew Thompson 697ed6d949aSAndrew Thompson if (actlen < 4) { 698ecc70d3fSGleb Smirnoff if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); 69902ac6454SAndrew Thompson goto tr_setup; 70002ac6454SAndrew Thompson } 701ed6d949aSAndrew Thompson pc = usbd_xfer_get_frame(xfer, 0); 702ed6d949aSAndrew Thompson usbd_copy_out(pc, actlen - 4, &status, sizeof(status)); 703ed6d949aSAndrew Thompson actlen -= 4; 70402ac6454SAndrew Thompson 70520733245SPedro F. Giffuni /* check receive packet was valid or not */ 70602ac6454SAndrew Thompson status = le16toh(status); 70702ac6454SAndrew Thompson if ((status & RUE_RXSTAT_VALID) == 0) { 708ecc70d3fSGleb Smirnoff if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); 70902ac6454SAndrew Thompson goto tr_setup; 71002ac6454SAndrew Thompson } 711ed6d949aSAndrew Thompson uether_rxbuf(ue, pc, 0, actlen); 71202ac6454SAndrew Thompson /* FALLTHROUGH */ 71302ac6454SAndrew Thompson case USB_ST_SETUP: 71402ac6454SAndrew Thompson tr_setup: 715ed6d949aSAndrew Thompson usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer)); 716a593f6b8SAndrew Thompson usbd_transfer_submit(xfer); 717a593f6b8SAndrew Thompson uether_rxflush(ue); 71802ac6454SAndrew Thompson return; 71902ac6454SAndrew Thompson 72002ac6454SAndrew Thompson default: /* Error */ 72102ac6454SAndrew Thompson DPRINTF("bulk read error, %s\n", 722ed6d949aSAndrew Thompson usbd_errstr(error)); 72302ac6454SAndrew Thompson 724ed6d949aSAndrew Thompson if (error != USB_ERR_CANCELLED) { 72502ac6454SAndrew Thompson /* try to clear stall first */ 726ed6d949aSAndrew Thompson usbd_xfer_set_stall(xfer); 72702ac6454SAndrew Thompson goto tr_setup; 72802ac6454SAndrew Thompson } 72902ac6454SAndrew Thompson return; 73002ac6454SAndrew Thompson } 73102ac6454SAndrew Thompson } 73202ac6454SAndrew Thompson 73302ac6454SAndrew Thompson static void 734ed6d949aSAndrew Thompson rue_bulk_write_callback(struct usb_xfer *xfer, usb_error_t error) 73502ac6454SAndrew Thompson { 736ed6d949aSAndrew Thompson struct rue_softc *sc = usbd_xfer_softc(xfer); 737a593f6b8SAndrew Thompson struct ifnet *ifp = uether_getifp(&sc->sc_ue); 738ed6d949aSAndrew Thompson struct usb_page_cache *pc; 73902ac6454SAndrew Thompson struct mbuf *m; 74002ac6454SAndrew Thompson int temp_len; 74102ac6454SAndrew Thompson 74202ac6454SAndrew Thompson switch (USB_GET_STATE(xfer)) { 74302ac6454SAndrew Thompson case USB_ST_TRANSFERRED: 74402ac6454SAndrew Thompson DPRINTFN(11, "transfer complete\n"); 745ecc70d3fSGleb Smirnoff if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1); 74602ac6454SAndrew Thompson 74702ac6454SAndrew Thompson /* FALLTHROUGH */ 74802ac6454SAndrew Thompson case USB_ST_SETUP: 74902ac6454SAndrew Thompson tr_setup: 75002ac6454SAndrew Thompson if ((sc->sc_flags & RUE_FLAG_LINK) == 0) { 75102ac6454SAndrew Thompson /* 75202ac6454SAndrew Thompson * don't send anything if there is no link ! 75302ac6454SAndrew Thompson */ 75402ac6454SAndrew Thompson return; 75502ac6454SAndrew Thompson } 75602ac6454SAndrew Thompson IFQ_DRV_DEQUEUE(&ifp->if_snd, m); 75702ac6454SAndrew Thompson 75802ac6454SAndrew Thompson if (m == NULL) 75902ac6454SAndrew Thompson return; 76002ac6454SAndrew Thompson if (m->m_pkthdr.len > MCLBYTES) 76102ac6454SAndrew Thompson m->m_pkthdr.len = MCLBYTES; 76202ac6454SAndrew Thompson temp_len = m->m_pkthdr.len; 76302ac6454SAndrew Thompson 764ed6d949aSAndrew Thompson pc = usbd_xfer_get_frame(xfer, 0); 765ed6d949aSAndrew Thompson usbd_m_copy_in(pc, 0, m, 0, m->m_pkthdr.len); 76602ac6454SAndrew Thompson 76702ac6454SAndrew Thompson /* 76802ac6454SAndrew Thompson * This is an undocumented behavior. 76902ac6454SAndrew Thompson * RTL8150 chip doesn't send frame length smaller than 77002ac6454SAndrew Thompson * RUE_MIN_FRAMELEN (60) byte packet. 77102ac6454SAndrew Thompson */ 77202ac6454SAndrew Thompson if (temp_len < RUE_MIN_FRAMELEN) { 773ed6d949aSAndrew Thompson usbd_frame_zero(pc, temp_len, 77402ac6454SAndrew Thompson RUE_MIN_FRAMELEN - temp_len); 77502ac6454SAndrew Thompson temp_len = RUE_MIN_FRAMELEN; 77602ac6454SAndrew Thompson } 777ed6d949aSAndrew Thompson usbd_xfer_set_frame_len(xfer, 0, temp_len); 77802ac6454SAndrew Thompson 77902ac6454SAndrew Thompson /* 78002ac6454SAndrew Thompson * if there's a BPF listener, bounce a copy 78102ac6454SAndrew Thompson * of this frame to him: 78202ac6454SAndrew Thompson */ 78302ac6454SAndrew Thompson BPF_MTAP(ifp, m); 78402ac6454SAndrew Thompson 78502ac6454SAndrew Thompson m_freem(m); 78602ac6454SAndrew Thompson 787a593f6b8SAndrew Thompson usbd_transfer_submit(xfer); 78802ac6454SAndrew Thompson 78902ac6454SAndrew Thompson return; 79002ac6454SAndrew Thompson 79102ac6454SAndrew Thompson default: /* Error */ 79202ac6454SAndrew Thompson DPRINTFN(11, "transfer error, %s\n", 793ed6d949aSAndrew Thompson usbd_errstr(error)); 79402ac6454SAndrew Thompson 795ecc70d3fSGleb Smirnoff if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); 79602ac6454SAndrew Thompson 797ed6d949aSAndrew Thompson if (error != USB_ERR_CANCELLED) { 79802ac6454SAndrew Thompson /* try to clear stall first */ 799ed6d949aSAndrew Thompson usbd_xfer_set_stall(xfer); 80002ac6454SAndrew Thompson goto tr_setup; 80102ac6454SAndrew Thompson } 80202ac6454SAndrew Thompson return; 80302ac6454SAndrew Thompson } 80402ac6454SAndrew Thompson } 80502ac6454SAndrew Thompson 80602ac6454SAndrew Thompson static void 807760bc48eSAndrew Thompson rue_tick(struct usb_ether *ue) 80802ac6454SAndrew Thompson { 809a593f6b8SAndrew Thompson struct rue_softc *sc = uether_getsc(ue); 81002ac6454SAndrew Thompson struct mii_data *mii = GET_MII(sc); 81102ac6454SAndrew Thompson 81202ac6454SAndrew Thompson RUE_LOCK_ASSERT(sc, MA_OWNED); 81302ac6454SAndrew Thompson 81402ac6454SAndrew Thompson mii_tick(mii); 81502ac6454SAndrew Thompson if ((sc->sc_flags & RUE_FLAG_LINK) == 0 81602ac6454SAndrew Thompson && mii->mii_media_status & IFM_ACTIVE && 81702ac6454SAndrew Thompson IFM_SUBTYPE(mii->mii_media_active) != IFM_NONE) { 81802ac6454SAndrew Thompson sc->sc_flags |= RUE_FLAG_LINK; 81902ac6454SAndrew Thompson rue_start(ue); 82002ac6454SAndrew Thompson } 82102ac6454SAndrew Thompson } 82202ac6454SAndrew Thompson 82302ac6454SAndrew Thompson static void 824760bc48eSAndrew Thompson rue_start(struct usb_ether *ue) 82502ac6454SAndrew Thompson { 826a593f6b8SAndrew Thompson struct rue_softc *sc = uether_getsc(ue); 82702ac6454SAndrew Thompson 82802ac6454SAndrew Thompson /* 82902ac6454SAndrew Thompson * start the USB transfers, if not already started: 83002ac6454SAndrew Thompson */ 831a593f6b8SAndrew Thompson usbd_transfer_start(sc->sc_xfer[RUE_INTR_DT_RD]); 832a593f6b8SAndrew Thompson usbd_transfer_start(sc->sc_xfer[RUE_BULK_DT_RD]); 833a593f6b8SAndrew Thompson usbd_transfer_start(sc->sc_xfer[RUE_BULK_DT_WR]); 83402ac6454SAndrew Thompson } 83502ac6454SAndrew Thompson 83602ac6454SAndrew Thompson static void 837760bc48eSAndrew Thompson rue_init(struct usb_ether *ue) 83802ac6454SAndrew Thompson { 839a593f6b8SAndrew Thompson struct rue_softc *sc = uether_getsc(ue); 840a593f6b8SAndrew Thompson struct ifnet *ifp = uether_getifp(ue); 84102ac6454SAndrew Thompson 84202ac6454SAndrew Thompson RUE_LOCK_ASSERT(sc, MA_OWNED); 84302ac6454SAndrew Thompson 84402ac6454SAndrew Thompson /* 84502ac6454SAndrew Thompson * Cancel pending I/O 84602ac6454SAndrew Thompson */ 84702ac6454SAndrew Thompson rue_reset(sc); 84802ac6454SAndrew Thompson 84902ac6454SAndrew Thompson /* Set MAC address */ 85002ac6454SAndrew Thompson rue_write_mem(sc, RUE_IDR0, IF_LLADDR(ifp), ETHER_ADDR_LEN); 85102ac6454SAndrew Thompson 85202ac6454SAndrew Thompson rue_stop(ue); 85302ac6454SAndrew Thompson 85402ac6454SAndrew Thompson /* 85502ac6454SAndrew Thompson * Set the initial TX and RX configuration. 85602ac6454SAndrew Thompson */ 85702ac6454SAndrew Thompson rue_csr_write_1(sc, RUE_TCR, RUE_TCR_CONFIG); 85802ac6454SAndrew Thompson rue_csr_write_2(sc, RUE_RCR, RUE_RCR_CONFIG|RUE_RCR_AB); 85902ac6454SAndrew Thompson 86002ac6454SAndrew Thompson /* Load the multicast filter */ 86102ac6454SAndrew Thompson rue_setpromisc(ue); 86202ac6454SAndrew Thompson /* Load the multicast filter. */ 86302ac6454SAndrew Thompson rue_setmulti(ue); 86402ac6454SAndrew Thompson 86502ac6454SAndrew Thompson /* Enable RX and TX */ 86602ac6454SAndrew Thompson rue_csr_write_1(sc, RUE_CR, (RUE_CR_TE | RUE_CR_RE | RUE_CR_EP3CLREN)); 86702ac6454SAndrew Thompson 868ed6d949aSAndrew Thompson usbd_xfer_set_stall(sc->sc_xfer[RUE_BULK_DT_WR]); 86902ac6454SAndrew Thompson 87002ac6454SAndrew Thompson ifp->if_drv_flags |= IFF_DRV_RUNNING; 87102ac6454SAndrew Thompson rue_start(ue); 87202ac6454SAndrew Thompson } 87302ac6454SAndrew Thompson 87402ac6454SAndrew Thompson /* 87502ac6454SAndrew Thompson * Set media options. 87602ac6454SAndrew Thompson */ 87702ac6454SAndrew Thompson static int 87802ac6454SAndrew Thompson rue_ifmedia_upd(struct ifnet *ifp) 87902ac6454SAndrew Thompson { 88002ac6454SAndrew Thompson struct rue_softc *sc = ifp->if_softc; 88102ac6454SAndrew Thompson struct mii_data *mii = GET_MII(sc); 8823fcb7a53SMarius Strobl struct mii_softc *miisc; 883ebe01023SKevin Lo int error; 88402ac6454SAndrew Thompson 88502ac6454SAndrew Thompson RUE_LOCK_ASSERT(sc, MA_OWNED); 88602ac6454SAndrew Thompson 88702ac6454SAndrew Thompson sc->sc_flags &= ~RUE_FLAG_LINK; 88802ac6454SAndrew Thompson LIST_FOREACH(miisc, &mii->mii_phys, mii_list) 8893fcb7a53SMarius Strobl PHY_RESET(miisc); 890ebe01023SKevin Lo error = mii_mediachg(mii); 891ebe01023SKevin Lo return (error); 89202ac6454SAndrew Thompson } 89302ac6454SAndrew Thompson 89402ac6454SAndrew Thompson /* 89502ac6454SAndrew Thompson * Report current media status. 89602ac6454SAndrew Thompson */ 89702ac6454SAndrew Thompson static void 89802ac6454SAndrew Thompson rue_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr) 89902ac6454SAndrew Thompson { 90002ac6454SAndrew Thompson struct rue_softc *sc = ifp->if_softc; 90102ac6454SAndrew Thompson struct mii_data *mii = GET_MII(sc); 90202ac6454SAndrew Thompson 90302ac6454SAndrew Thompson RUE_LOCK(sc); 90402ac6454SAndrew Thompson mii_pollstat(mii); 90502ac6454SAndrew Thompson ifmr->ifm_active = mii->mii_media_active; 90602ac6454SAndrew Thompson ifmr->ifm_status = mii->mii_media_status; 907e9e549efSPyun YongHyeon RUE_UNLOCK(sc); 90802ac6454SAndrew Thompson } 90902ac6454SAndrew Thompson 91002ac6454SAndrew Thompson static void 911760bc48eSAndrew Thompson rue_stop(struct usb_ether *ue) 91202ac6454SAndrew Thompson { 913a593f6b8SAndrew Thompson struct rue_softc *sc = uether_getsc(ue); 914a593f6b8SAndrew Thompson struct ifnet *ifp = uether_getifp(ue); 91502ac6454SAndrew Thompson 91602ac6454SAndrew Thompson RUE_LOCK_ASSERT(sc, MA_OWNED); 91702ac6454SAndrew Thompson 91802ac6454SAndrew Thompson ifp->if_drv_flags &= ~IFF_DRV_RUNNING; 91902ac6454SAndrew Thompson sc->sc_flags &= ~RUE_FLAG_LINK; 92002ac6454SAndrew Thompson 92102ac6454SAndrew Thompson /* 92202ac6454SAndrew Thompson * stop all the transfers, if not already stopped: 92302ac6454SAndrew Thompson */ 924a593f6b8SAndrew Thompson usbd_transfer_stop(sc->sc_xfer[RUE_BULK_DT_WR]); 925a593f6b8SAndrew Thompson usbd_transfer_stop(sc->sc_xfer[RUE_BULK_DT_RD]); 926a593f6b8SAndrew Thompson usbd_transfer_stop(sc->sc_xfer[RUE_INTR_DT_RD]); 92702ac6454SAndrew Thompson 92802ac6454SAndrew Thompson rue_csr_write_1(sc, RUE_CR, 0x00); 92902ac6454SAndrew Thompson 93002ac6454SAndrew Thompson rue_reset(sc); 93102ac6454SAndrew Thompson } 932