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 [RUE_BULK_DT_WR] = { 16602ac6454SAndrew Thompson .type = UE_BULK, 16702ac6454SAndrew Thompson .endpoint = UE_ADDR_ANY, 16802ac6454SAndrew Thompson .direction = UE_DIR_OUT, 1694eae601eSAndrew Thompson .bufsize = MCLBYTES, 1704eae601eSAndrew Thompson .flags = {.pipe_bof = 1,.force_short_xfer = 1,}, 1714eae601eSAndrew Thompson .callback = rue_bulk_write_callback, 1724eae601eSAndrew Thompson .timeout = 10000, /* 10 seconds */ 17302ac6454SAndrew Thompson }, 17402ac6454SAndrew Thompson 17502ac6454SAndrew Thompson [RUE_BULK_DT_RD] = { 17602ac6454SAndrew Thompson .type = UE_BULK, 17702ac6454SAndrew Thompson .endpoint = UE_ADDR_ANY, 17802ac6454SAndrew Thompson .direction = UE_DIR_IN, 1794eae601eSAndrew Thompson .bufsize = (MCLBYTES + 4), 1804eae601eSAndrew Thompson .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, 1814eae601eSAndrew Thompson .callback = rue_bulk_read_callback, 1824eae601eSAndrew Thompson .timeout = 0, /* no timeout */ 18302ac6454SAndrew Thompson }, 18402ac6454SAndrew Thompson 18502ac6454SAndrew Thompson [RUE_INTR_DT_RD] = { 18602ac6454SAndrew Thompson .type = UE_INTERRUPT, 18702ac6454SAndrew Thompson .endpoint = UE_ADDR_ANY, 18802ac6454SAndrew Thompson .direction = UE_DIR_IN, 1894eae601eSAndrew Thompson .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, 1904eae601eSAndrew Thompson .bufsize = 0, /* use wMaxPacketSize */ 1914eae601eSAndrew Thompson .callback = rue_intr_callback, 19202ac6454SAndrew Thompson }, 19302ac6454SAndrew Thompson }; 19402ac6454SAndrew Thompson 19502ac6454SAndrew Thompson static device_method_t rue_methods[] = { 19602ac6454SAndrew Thompson /* Device interface */ 19702ac6454SAndrew Thompson DEVMETHOD(device_probe, rue_probe), 19802ac6454SAndrew Thompson DEVMETHOD(device_attach, rue_attach), 19902ac6454SAndrew Thompson DEVMETHOD(device_detach, rue_detach), 20002ac6454SAndrew Thompson 20102ac6454SAndrew Thompson /* MII interface */ 20202ac6454SAndrew Thompson DEVMETHOD(miibus_readreg, rue_miibus_readreg), 20302ac6454SAndrew Thompson DEVMETHOD(miibus_writereg, rue_miibus_writereg), 20402ac6454SAndrew Thompson DEVMETHOD(miibus_statchg, rue_miibus_statchg), 20502ac6454SAndrew Thompson 2064b7ec270SMarius Strobl DEVMETHOD_END 20702ac6454SAndrew Thompson }; 20802ac6454SAndrew Thompson 20902ac6454SAndrew Thompson static driver_t rue_driver = { 21002ac6454SAndrew Thompson .name = "rue", 21102ac6454SAndrew Thompson .methods = rue_methods, 21202ac6454SAndrew Thompson .size = sizeof(struct rue_softc), 21302ac6454SAndrew Thompson }; 21402ac6454SAndrew Thompson 215bc9372d7SJohn Baldwin DRIVER_MODULE_ORDERED(rue, uhub, rue_driver, NULL, NULL, SI_ORDER_ANY); 2163e38757dSJohn Baldwin DRIVER_MODULE(miibus, rue, miibus_driver, NULL, NULL); 21702ac6454SAndrew Thompson MODULE_DEPEND(rue, uether, 1, 1, 1); 21802ac6454SAndrew Thompson MODULE_DEPEND(rue, usb, 1, 1, 1); 21902ac6454SAndrew Thompson MODULE_DEPEND(rue, ether, 1, 1, 1); 22002ac6454SAndrew Thompson MODULE_DEPEND(rue, miibus, 1, 1, 1); 221910cb8feSAndrew Thompson MODULE_VERSION(rue, 1); 222f809f280SWarner Losh USB_PNP_HOST_INFO(rue_devs); 22302ac6454SAndrew Thompson 224760bc48eSAndrew Thompson static const struct usb_ether_methods rue_ue_methods = { 22502ac6454SAndrew Thompson .ue_attach_post = rue_attach_post, 22602ac6454SAndrew Thompson .ue_start = rue_start, 22702ac6454SAndrew Thompson .ue_init = rue_init, 22802ac6454SAndrew Thompson .ue_stop = rue_stop, 22902ac6454SAndrew Thompson .ue_tick = rue_tick, 23002ac6454SAndrew Thompson .ue_setmulti = rue_setmulti, 23102ac6454SAndrew Thompson .ue_setpromisc = rue_setpromisc, 23202ac6454SAndrew Thompson .ue_mii_upd = rue_ifmedia_upd, 23302ac6454SAndrew Thompson .ue_mii_sts = rue_ifmedia_sts, 23402ac6454SAndrew Thompson }; 23502ac6454SAndrew Thompson 23602ac6454SAndrew Thompson #define RUE_SETBIT(sc, reg, x) \ 23702ac6454SAndrew Thompson rue_csr_write_1(sc, reg, rue_csr_read_1(sc, reg) | (x)) 23802ac6454SAndrew Thompson 23902ac6454SAndrew Thompson #define RUE_CLRBIT(sc, reg, x) \ 24002ac6454SAndrew Thompson rue_csr_write_1(sc, reg, rue_csr_read_1(sc, reg) & ~(x)) 24102ac6454SAndrew Thompson 24202ac6454SAndrew Thompson static int 24302ac6454SAndrew Thompson rue_read_mem(struct rue_softc *sc, uint16_t addr, void *buf, int len) 24402ac6454SAndrew Thompson { 245760bc48eSAndrew Thompson struct usb_device_request req; 24602ac6454SAndrew Thompson 24702ac6454SAndrew Thompson req.bmRequestType = UT_READ_VENDOR_DEVICE; 24802ac6454SAndrew Thompson req.bRequest = UR_SET_ADDRESS; 24902ac6454SAndrew Thompson USETW(req.wValue, addr); 25002ac6454SAndrew Thompson USETW(req.wIndex, 0); 25102ac6454SAndrew Thompson USETW(req.wLength, len); 25202ac6454SAndrew Thompson 253a593f6b8SAndrew Thompson return (uether_do_request(&sc->sc_ue, &req, buf, 1000)); 25402ac6454SAndrew Thompson } 25502ac6454SAndrew Thompson 25602ac6454SAndrew Thompson static int 25702ac6454SAndrew Thompson rue_write_mem(struct rue_softc *sc, uint16_t addr, void *buf, int len) 25802ac6454SAndrew Thompson { 259760bc48eSAndrew Thompson struct usb_device_request req; 26002ac6454SAndrew Thompson 26102ac6454SAndrew Thompson req.bmRequestType = UT_WRITE_VENDOR_DEVICE; 26202ac6454SAndrew Thompson req.bRequest = UR_SET_ADDRESS; 26302ac6454SAndrew Thompson USETW(req.wValue, addr); 26402ac6454SAndrew Thompson USETW(req.wIndex, 0); 26502ac6454SAndrew Thompson USETW(req.wLength, len); 26602ac6454SAndrew Thompson 267a593f6b8SAndrew Thompson return (uether_do_request(&sc->sc_ue, &req, buf, 1000)); 26802ac6454SAndrew Thompson } 26902ac6454SAndrew Thompson 27002ac6454SAndrew Thompson static uint8_t 27102ac6454SAndrew Thompson rue_csr_read_1(struct rue_softc *sc, uint16_t reg) 27202ac6454SAndrew Thompson { 27302ac6454SAndrew Thompson uint8_t val; 27402ac6454SAndrew Thompson 27502ac6454SAndrew Thompson rue_read_mem(sc, reg, &val, 1); 27602ac6454SAndrew Thompson return (val); 27702ac6454SAndrew Thompson } 27802ac6454SAndrew Thompson 27902ac6454SAndrew Thompson static uint16_t 28002ac6454SAndrew Thompson rue_csr_read_2(struct rue_softc *sc, uint16_t reg) 28102ac6454SAndrew Thompson { 28202ac6454SAndrew Thompson uint8_t val[2]; 28302ac6454SAndrew Thompson 28402ac6454SAndrew Thompson rue_read_mem(sc, reg, &val, 2); 28502ac6454SAndrew Thompson return (UGETW(val)); 28602ac6454SAndrew Thompson } 28702ac6454SAndrew Thompson 28802ac6454SAndrew Thompson static int 28902ac6454SAndrew Thompson rue_csr_write_1(struct rue_softc *sc, uint16_t reg, uint8_t val) 29002ac6454SAndrew Thompson { 29102ac6454SAndrew Thompson return (rue_write_mem(sc, reg, &val, 1)); 29202ac6454SAndrew Thompson } 29302ac6454SAndrew Thompson 29402ac6454SAndrew Thompson static int 29502ac6454SAndrew Thompson rue_csr_write_2(struct rue_softc *sc, uint16_t reg, uint16_t val) 29602ac6454SAndrew Thompson { 29702ac6454SAndrew Thompson uint8_t temp[2]; 29802ac6454SAndrew Thompson 29902ac6454SAndrew Thompson USETW(temp, val); 30002ac6454SAndrew Thompson return (rue_write_mem(sc, reg, &temp, 2)); 30102ac6454SAndrew Thompson } 30202ac6454SAndrew Thompson 30302ac6454SAndrew Thompson static int 30402ac6454SAndrew Thompson rue_csr_write_4(struct rue_softc *sc, int reg, uint32_t val) 30502ac6454SAndrew Thompson { 30602ac6454SAndrew Thompson uint8_t temp[4]; 30702ac6454SAndrew Thompson 30802ac6454SAndrew Thompson USETDW(temp, val); 30902ac6454SAndrew Thompson return (rue_write_mem(sc, reg, &temp, 4)); 31002ac6454SAndrew Thompson } 31102ac6454SAndrew Thompson 31202ac6454SAndrew Thompson static int 31302ac6454SAndrew Thompson rue_miibus_readreg(device_t dev, int phy, int reg) 31402ac6454SAndrew Thompson { 31502ac6454SAndrew Thompson struct rue_softc *sc = device_get_softc(dev); 31602ac6454SAndrew Thompson uint16_t rval; 31702ac6454SAndrew Thompson uint16_t ruereg; 31802ac6454SAndrew Thompson int locked; 31902ac6454SAndrew Thompson 32002ac6454SAndrew Thompson if (phy != 0) /* RTL8150 supports PHY == 0, only */ 32102ac6454SAndrew Thompson return (0); 32202ac6454SAndrew Thompson 32302ac6454SAndrew Thompson locked = mtx_owned(&sc->sc_mtx); 32402ac6454SAndrew Thompson if (!locked) 32502ac6454SAndrew Thompson RUE_LOCK(sc); 32602ac6454SAndrew Thompson 32702ac6454SAndrew Thompson switch (reg) { 32802ac6454SAndrew Thompson case MII_BMCR: 32902ac6454SAndrew Thompson ruereg = RUE_BMCR; 33002ac6454SAndrew Thompson break; 33102ac6454SAndrew Thompson case MII_BMSR: 33202ac6454SAndrew Thompson ruereg = RUE_BMSR; 33302ac6454SAndrew Thompson break; 33402ac6454SAndrew Thompson case MII_ANAR: 33502ac6454SAndrew Thompson ruereg = RUE_ANAR; 33602ac6454SAndrew Thompson break; 33702ac6454SAndrew Thompson case MII_ANER: 33802ac6454SAndrew Thompson ruereg = RUE_AER; 33902ac6454SAndrew Thompson break; 34002ac6454SAndrew Thompson case MII_ANLPAR: 34102ac6454SAndrew Thompson ruereg = RUE_ANLP; 34202ac6454SAndrew Thompson break; 34302ac6454SAndrew Thompson case MII_PHYIDR1: 34402ac6454SAndrew Thompson case MII_PHYIDR2: 34502ac6454SAndrew Thompson rval = 0; 34602ac6454SAndrew Thompson goto done; 34702ac6454SAndrew Thompson default: 34802ac6454SAndrew Thompson if (RUE_REG_MIN <= reg && reg <= RUE_REG_MAX) { 34902ac6454SAndrew Thompson rval = rue_csr_read_1(sc, reg); 35002ac6454SAndrew Thompson goto done; 35102ac6454SAndrew Thompson } 35202ac6454SAndrew Thompson device_printf(sc->sc_ue.ue_dev, "bad phy register\n"); 35302ac6454SAndrew Thompson rval = 0; 35402ac6454SAndrew Thompson goto done; 35502ac6454SAndrew Thompson } 35602ac6454SAndrew Thompson 35702ac6454SAndrew Thompson rval = rue_csr_read_2(sc, ruereg); 35802ac6454SAndrew Thompson done: 35902ac6454SAndrew Thompson if (!locked) 36002ac6454SAndrew Thompson RUE_UNLOCK(sc); 36102ac6454SAndrew Thompson return (rval); 36202ac6454SAndrew Thompson } 36302ac6454SAndrew Thompson 36402ac6454SAndrew Thompson static int 36502ac6454SAndrew Thompson rue_miibus_writereg(device_t dev, int phy, int reg, int data) 36602ac6454SAndrew Thompson { 36702ac6454SAndrew Thompson struct rue_softc *sc = device_get_softc(dev); 36802ac6454SAndrew Thompson uint16_t ruereg; 36902ac6454SAndrew Thompson int locked; 37002ac6454SAndrew Thompson 37102ac6454SAndrew Thompson if (phy != 0) /* RTL8150 supports PHY == 0, only */ 37202ac6454SAndrew Thompson return (0); 37302ac6454SAndrew Thompson 37402ac6454SAndrew Thompson locked = mtx_owned(&sc->sc_mtx); 37502ac6454SAndrew Thompson if (!locked) 37602ac6454SAndrew Thompson RUE_LOCK(sc); 37702ac6454SAndrew Thompson 37802ac6454SAndrew Thompson switch (reg) { 37902ac6454SAndrew Thompson case MII_BMCR: 38002ac6454SAndrew Thompson ruereg = RUE_BMCR; 38102ac6454SAndrew Thompson break; 38202ac6454SAndrew Thompson case MII_BMSR: 38302ac6454SAndrew Thompson ruereg = RUE_BMSR; 38402ac6454SAndrew Thompson break; 38502ac6454SAndrew Thompson case MII_ANAR: 38602ac6454SAndrew Thompson ruereg = RUE_ANAR; 38702ac6454SAndrew Thompson break; 38802ac6454SAndrew Thompson case MII_ANER: 38902ac6454SAndrew Thompson ruereg = RUE_AER; 39002ac6454SAndrew Thompson break; 39102ac6454SAndrew Thompson case MII_ANLPAR: 39202ac6454SAndrew Thompson ruereg = RUE_ANLP; 39302ac6454SAndrew Thompson break; 39402ac6454SAndrew Thompson case MII_PHYIDR1: 39502ac6454SAndrew Thompson case MII_PHYIDR2: 39602ac6454SAndrew Thompson goto done; 39702ac6454SAndrew Thompson default: 39802ac6454SAndrew Thompson if (RUE_REG_MIN <= reg && reg <= RUE_REG_MAX) { 39902ac6454SAndrew Thompson rue_csr_write_1(sc, reg, data); 40002ac6454SAndrew Thompson goto done; 40102ac6454SAndrew Thompson } 40202ac6454SAndrew Thompson device_printf(sc->sc_ue.ue_dev, " bad phy register\n"); 40302ac6454SAndrew Thompson goto done; 40402ac6454SAndrew Thompson } 40502ac6454SAndrew Thompson rue_csr_write_2(sc, ruereg, data); 40602ac6454SAndrew Thompson done: 40702ac6454SAndrew Thompson if (!locked) 40802ac6454SAndrew Thompson RUE_UNLOCK(sc); 40902ac6454SAndrew Thompson return (0); 41002ac6454SAndrew Thompson } 41102ac6454SAndrew Thompson 41202ac6454SAndrew Thompson static void 41302ac6454SAndrew Thompson rue_miibus_statchg(device_t dev) 41402ac6454SAndrew Thompson { 41502ac6454SAndrew Thompson /* 41602ac6454SAndrew Thompson * When the code below is enabled the card starts doing weird 41702ac6454SAndrew Thompson * things after link going from UP to DOWN and back UP. 41802ac6454SAndrew Thompson * 41902ac6454SAndrew Thompson * Looks like some of register writes below messes up PHY 42002ac6454SAndrew Thompson * interface. 42102ac6454SAndrew Thompson * 42202ac6454SAndrew Thompson * No visible regressions were found after commenting this code 42302ac6454SAndrew Thompson * out, so that disable it for good. 42402ac6454SAndrew Thompson */ 42502ac6454SAndrew Thompson #if 0 42602ac6454SAndrew Thompson struct rue_softc *sc = device_get_softc(dev); 42702ac6454SAndrew Thompson struct mii_data *mii = GET_MII(sc); 42802ac6454SAndrew Thompson uint16_t bmcr; 42902ac6454SAndrew Thompson int locked; 43002ac6454SAndrew Thompson 43102ac6454SAndrew Thompson locked = mtx_owned(&sc->sc_mtx); 43202ac6454SAndrew Thompson if (!locked) 43302ac6454SAndrew Thompson RUE_LOCK(sc); 43402ac6454SAndrew Thompson 43502ac6454SAndrew Thompson RUE_CLRBIT(sc, RUE_CR, (RUE_CR_RE | RUE_CR_TE)); 43602ac6454SAndrew Thompson 43702ac6454SAndrew Thompson bmcr = rue_csr_read_2(sc, RUE_BMCR); 43802ac6454SAndrew Thompson 43902ac6454SAndrew Thompson if (IFM_SUBTYPE(mii->mii_media_active) == IFM_100_TX) 44002ac6454SAndrew Thompson bmcr |= RUE_BMCR_SPD_SET; 44102ac6454SAndrew Thompson else 44202ac6454SAndrew Thompson bmcr &= ~RUE_BMCR_SPD_SET; 44302ac6454SAndrew Thompson 44402ac6454SAndrew Thompson if ((mii->mii_media_active & IFM_GMASK) == IFM_FDX) 44502ac6454SAndrew Thompson bmcr |= RUE_BMCR_DUPLEX; 44602ac6454SAndrew Thompson else 44702ac6454SAndrew Thompson bmcr &= ~RUE_BMCR_DUPLEX; 44802ac6454SAndrew Thompson 44902ac6454SAndrew Thompson rue_csr_write_2(sc, RUE_BMCR, bmcr); 45002ac6454SAndrew Thompson 45102ac6454SAndrew Thompson RUE_SETBIT(sc, RUE_CR, (RUE_CR_RE | RUE_CR_TE)); 45202ac6454SAndrew Thompson 45302ac6454SAndrew Thompson if (!locked) 45402ac6454SAndrew Thompson RUE_UNLOCK(sc); 45502ac6454SAndrew Thompson #endif 45602ac6454SAndrew Thompson } 45702ac6454SAndrew Thompson 45802ac6454SAndrew Thompson static void 459760bc48eSAndrew Thompson rue_setpromisc(struct usb_ether *ue) 46002ac6454SAndrew Thompson { 461a593f6b8SAndrew Thompson struct rue_softc *sc = uether_getsc(ue); 462a593f6b8SAndrew Thompson struct ifnet *ifp = uether_getifp(ue); 46302ac6454SAndrew Thompson 46402ac6454SAndrew Thompson RUE_LOCK_ASSERT(sc, MA_OWNED); 46502ac6454SAndrew Thompson 46602ac6454SAndrew Thompson /* If we want promiscuous mode, set the allframes bit. */ 46702ac6454SAndrew Thompson if (ifp->if_flags & IFF_PROMISC) 46802ac6454SAndrew Thompson RUE_SETBIT(sc, RUE_RCR, RUE_RCR_AAP); 46902ac6454SAndrew Thompson else 47002ac6454SAndrew Thompson RUE_CLRBIT(sc, RUE_RCR, RUE_RCR_AAP); 47102ac6454SAndrew Thompson } 47202ac6454SAndrew Thompson 473100ad729SGleb Smirnoff static u_int 474100ad729SGleb Smirnoff rue_hash_maddr(void *arg, struct sockaddr_dl *sdl, u_int cnt) 475100ad729SGleb Smirnoff { 476100ad729SGleb Smirnoff uint32_t *hashes = arg; 477100ad729SGleb Smirnoff int h; 478100ad729SGleb Smirnoff 479100ad729SGleb Smirnoff h = ether_crc32_be(LLADDR(sdl), ETHER_ADDR_LEN) >> 26; 480100ad729SGleb Smirnoff if (h < 32) 481100ad729SGleb Smirnoff hashes[0] |= (1 << h); 482100ad729SGleb Smirnoff else 483100ad729SGleb Smirnoff hashes[1] |= (1 << (h - 32)); 484100ad729SGleb Smirnoff 485100ad729SGleb Smirnoff return (1); 486100ad729SGleb Smirnoff } 487100ad729SGleb Smirnoff 48802ac6454SAndrew Thompson /* 48902ac6454SAndrew Thompson * Program the 64-bit multicast hash filter. 49002ac6454SAndrew Thompson */ 49102ac6454SAndrew Thompson static void 492760bc48eSAndrew Thompson rue_setmulti(struct usb_ether *ue) 49302ac6454SAndrew Thompson { 494a593f6b8SAndrew Thompson struct rue_softc *sc = uether_getsc(ue); 495a593f6b8SAndrew Thompson struct ifnet *ifp = uether_getifp(ue); 49602ac6454SAndrew Thompson uint16_t rxcfg; 49702ac6454SAndrew Thompson uint32_t hashes[2] = { 0, 0 }; 498100ad729SGleb Smirnoff int mcnt; 49902ac6454SAndrew Thompson 50002ac6454SAndrew Thompson RUE_LOCK_ASSERT(sc, MA_OWNED); 50102ac6454SAndrew Thompson 50202ac6454SAndrew Thompson rxcfg = rue_csr_read_2(sc, RUE_RCR); 50302ac6454SAndrew Thompson 50402ac6454SAndrew Thompson if (ifp->if_flags & IFF_ALLMULTI || ifp->if_flags & IFF_PROMISC) { 50502ac6454SAndrew Thompson rxcfg |= (RUE_RCR_AAM | RUE_RCR_AAP); 50602ac6454SAndrew Thompson rxcfg &= ~RUE_RCR_AM; 50702ac6454SAndrew Thompson rue_csr_write_2(sc, RUE_RCR, rxcfg); 50802ac6454SAndrew Thompson rue_csr_write_4(sc, RUE_MAR0, 0xFFFFFFFF); 50902ac6454SAndrew Thompson rue_csr_write_4(sc, RUE_MAR4, 0xFFFFFFFF); 51002ac6454SAndrew Thompson return; 51102ac6454SAndrew Thompson } 51202ac6454SAndrew Thompson 51302ac6454SAndrew Thompson /* first, zot all the existing hash bits */ 51402ac6454SAndrew Thompson rue_csr_write_4(sc, RUE_MAR0, 0); 51502ac6454SAndrew Thompson rue_csr_write_4(sc, RUE_MAR4, 0); 51602ac6454SAndrew Thompson 51702ac6454SAndrew Thompson /* now program new ones */ 518100ad729SGleb Smirnoff mcnt = if_foreach_llmaddr(ifp, rue_hash_maddr, &hashes); 51902ac6454SAndrew Thompson 52002ac6454SAndrew Thompson if (mcnt) 52102ac6454SAndrew Thompson rxcfg |= RUE_RCR_AM; 52202ac6454SAndrew Thompson else 52302ac6454SAndrew Thompson rxcfg &= ~RUE_RCR_AM; 52402ac6454SAndrew Thompson 52502ac6454SAndrew Thompson rxcfg &= ~(RUE_RCR_AAM | RUE_RCR_AAP); 52602ac6454SAndrew Thompson 52702ac6454SAndrew Thompson rue_csr_write_2(sc, RUE_RCR, rxcfg); 52802ac6454SAndrew Thompson rue_csr_write_4(sc, RUE_MAR0, hashes[0]); 52902ac6454SAndrew Thompson rue_csr_write_4(sc, RUE_MAR4, hashes[1]); 53002ac6454SAndrew Thompson } 53102ac6454SAndrew Thompson 53202ac6454SAndrew Thompson static void 53302ac6454SAndrew Thompson rue_reset(struct rue_softc *sc) 53402ac6454SAndrew Thompson { 53502ac6454SAndrew Thompson int i; 53602ac6454SAndrew Thompson 53702ac6454SAndrew Thompson rue_csr_write_1(sc, RUE_CR, RUE_CR_SOFT_RST); 53802ac6454SAndrew Thompson 53902ac6454SAndrew Thompson for (i = 0; i != RUE_TIMEOUT; i++) { 540a593f6b8SAndrew Thompson if (uether_pause(&sc->sc_ue, hz / 1000)) 54102ac6454SAndrew Thompson break; 54202ac6454SAndrew Thompson if (!(rue_csr_read_1(sc, RUE_CR) & RUE_CR_SOFT_RST)) 54302ac6454SAndrew Thompson break; 54402ac6454SAndrew Thompson } 54502ac6454SAndrew Thompson if (i == RUE_TIMEOUT) 546767cb2e2SAndrew Thompson device_printf(sc->sc_ue.ue_dev, "reset never completed\n"); 54702ac6454SAndrew Thompson 548a593f6b8SAndrew Thompson uether_pause(&sc->sc_ue, hz / 100); 54902ac6454SAndrew Thompson } 55002ac6454SAndrew Thompson 55102ac6454SAndrew Thompson static void 552760bc48eSAndrew Thompson rue_attach_post(struct usb_ether *ue) 55302ac6454SAndrew Thompson { 554a593f6b8SAndrew Thompson struct rue_softc *sc = uether_getsc(ue); 55502ac6454SAndrew Thompson 55602ac6454SAndrew Thompson /* reset the adapter */ 55702ac6454SAndrew Thompson rue_reset(sc); 55802ac6454SAndrew Thompson 55902ac6454SAndrew Thompson /* get station address from the EEPROM */ 56002ac6454SAndrew Thompson rue_read_mem(sc, RUE_EEPROM_IDR0, ue->ue_eaddr, ETHER_ADDR_LEN); 56102ac6454SAndrew Thompson } 56202ac6454SAndrew Thompson 56302ac6454SAndrew Thompson /* 56402ac6454SAndrew Thompson * Probe for a RTL8150 chip. 56502ac6454SAndrew Thompson */ 56602ac6454SAndrew Thompson static int 56702ac6454SAndrew Thompson rue_probe(device_t dev) 56802ac6454SAndrew Thompson { 569760bc48eSAndrew Thompson struct usb_attach_arg *uaa = device_get_ivars(dev); 57002ac6454SAndrew Thompson 571f29a0724SAndrew Thompson if (uaa->usb_mode != USB_MODE_HOST) 57202ac6454SAndrew Thompson return (ENXIO); 57302ac6454SAndrew Thompson if (uaa->info.bConfigIndex != RUE_CONFIG_IDX) 57402ac6454SAndrew Thompson return (ENXIO); 57502ac6454SAndrew Thompson if (uaa->info.bIfaceIndex != RUE_IFACE_IDX) 57602ac6454SAndrew Thompson return (ENXIO); 57702ac6454SAndrew Thompson 578a593f6b8SAndrew Thompson return (usbd_lookup_id_by_uaa(rue_devs, sizeof(rue_devs), uaa)); 57902ac6454SAndrew Thompson } 58002ac6454SAndrew Thompson 58102ac6454SAndrew Thompson /* 58202ac6454SAndrew Thompson * Attach the interface. Allocate softc structures, do ifmedia 58302ac6454SAndrew Thompson * setup and ethernet/BPF attach. 58402ac6454SAndrew Thompson */ 58502ac6454SAndrew Thompson static int 58602ac6454SAndrew Thompson rue_attach(device_t dev) 58702ac6454SAndrew Thompson { 588760bc48eSAndrew Thompson struct usb_attach_arg *uaa = device_get_ivars(dev); 58902ac6454SAndrew Thompson struct rue_softc *sc = device_get_softc(dev); 590760bc48eSAndrew Thompson struct usb_ether *ue = &sc->sc_ue; 59102ac6454SAndrew Thompson uint8_t iface_index; 59202ac6454SAndrew Thompson int error; 59302ac6454SAndrew Thompson 594a593f6b8SAndrew Thompson device_set_usb_desc(dev); 59502ac6454SAndrew Thompson mtx_init(&sc->sc_mtx, device_get_nameunit(dev), NULL, MTX_DEF); 59602ac6454SAndrew Thompson 59702ac6454SAndrew Thompson iface_index = RUE_IFACE_IDX; 598a593f6b8SAndrew Thompson error = usbd_transfer_setup(uaa->device, &iface_index, 59902ac6454SAndrew Thompson sc->sc_xfer, rue_config, RUE_N_TRANSFER, 60002ac6454SAndrew Thompson sc, &sc->sc_mtx); 60102ac6454SAndrew Thompson if (error) { 602767cb2e2SAndrew Thompson device_printf(dev, "allocating USB transfers failed\n"); 60302ac6454SAndrew Thompson goto detach; 60402ac6454SAndrew Thompson } 60502ac6454SAndrew Thompson 60602ac6454SAndrew Thompson ue->ue_sc = sc; 60702ac6454SAndrew Thompson ue->ue_dev = dev; 60802ac6454SAndrew Thompson ue->ue_udev = uaa->device; 60902ac6454SAndrew Thompson ue->ue_mtx = &sc->sc_mtx; 61002ac6454SAndrew Thompson ue->ue_methods = &rue_ue_methods; 61102ac6454SAndrew Thompson 612a593f6b8SAndrew Thompson error = uether_ifattach(ue); 61302ac6454SAndrew Thompson if (error) { 61402ac6454SAndrew Thompson device_printf(dev, "could not attach interface\n"); 61502ac6454SAndrew Thompson goto detach; 61602ac6454SAndrew Thompson } 61702ac6454SAndrew Thompson return (0); /* success */ 61802ac6454SAndrew Thompson 61902ac6454SAndrew Thompson detach: 62002ac6454SAndrew Thompson rue_detach(dev); 62102ac6454SAndrew Thompson return (ENXIO); /* failure */ 62202ac6454SAndrew Thompson } 62302ac6454SAndrew Thompson 62402ac6454SAndrew Thompson static int 62502ac6454SAndrew Thompson rue_detach(device_t dev) 62602ac6454SAndrew Thompson { 62702ac6454SAndrew Thompson struct rue_softc *sc = device_get_softc(dev); 628760bc48eSAndrew Thompson struct usb_ether *ue = &sc->sc_ue; 62902ac6454SAndrew Thompson 630a593f6b8SAndrew Thompson usbd_transfer_unsetup(sc->sc_xfer, RUE_N_TRANSFER); 631a593f6b8SAndrew Thompson uether_ifdetach(ue); 63202ac6454SAndrew Thompson mtx_destroy(&sc->sc_mtx); 63302ac6454SAndrew Thompson 63402ac6454SAndrew Thompson return (0); 63502ac6454SAndrew Thompson } 63602ac6454SAndrew Thompson 63702ac6454SAndrew Thompson static void 638ed6d949aSAndrew Thompson rue_intr_callback(struct usb_xfer *xfer, usb_error_t error) 63902ac6454SAndrew Thompson { 640ed6d949aSAndrew Thompson struct rue_softc *sc = usbd_xfer_softc(xfer); 641a593f6b8SAndrew Thompson struct ifnet *ifp = uether_getifp(&sc->sc_ue); 64202ac6454SAndrew Thompson struct rue_intrpkt pkt; 643ed6d949aSAndrew Thompson struct usb_page_cache *pc; 644ed6d949aSAndrew Thompson int actlen; 645ed6d949aSAndrew Thompson 646ed6d949aSAndrew Thompson usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL); 64702ac6454SAndrew Thompson 64802ac6454SAndrew Thompson switch (USB_GET_STATE(xfer)) { 64902ac6454SAndrew Thompson case USB_ST_TRANSFERRED: 65002ac6454SAndrew Thompson 65102ac6454SAndrew Thompson if (ifp && (ifp->if_drv_flags & IFF_DRV_RUNNING) && 6526d917491SHans Petter Selasky actlen >= (int)sizeof(pkt)) { 653ed6d949aSAndrew Thompson pc = usbd_xfer_get_frame(xfer, 0); 654ed6d949aSAndrew Thompson usbd_copy_out(pc, 0, &pkt, sizeof(pkt)); 65502ac6454SAndrew Thompson 656ecc70d3fSGleb Smirnoff if_inc_counter(ifp, IFCOUNTER_IERRORS, pkt.rue_rxlost_cnt); 657ecc70d3fSGleb Smirnoff if_inc_counter(ifp, IFCOUNTER_IERRORS, pkt.rue_crcerr_cnt); 658ecc70d3fSGleb Smirnoff if_inc_counter(ifp, IFCOUNTER_COLLISIONS, pkt.rue_col_cnt); 65902ac6454SAndrew Thompson } 66002ac6454SAndrew Thompson /* FALLTHROUGH */ 66102ac6454SAndrew Thompson case USB_ST_SETUP: 66202ac6454SAndrew Thompson tr_setup: 663ed6d949aSAndrew Thompson usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer)); 664a593f6b8SAndrew Thompson usbd_transfer_submit(xfer); 66502ac6454SAndrew Thompson return; 66602ac6454SAndrew Thompson 66702ac6454SAndrew Thompson default: /* Error */ 668ed6d949aSAndrew Thompson if (error != USB_ERR_CANCELLED) { 66902ac6454SAndrew Thompson /* try to clear stall first */ 670ed6d949aSAndrew Thompson usbd_xfer_set_stall(xfer); 67102ac6454SAndrew Thompson goto tr_setup; 67202ac6454SAndrew Thompson } 67302ac6454SAndrew Thompson return; 67402ac6454SAndrew Thompson } 67502ac6454SAndrew Thompson } 67602ac6454SAndrew Thompson 67702ac6454SAndrew Thompson static void 678ed6d949aSAndrew Thompson rue_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error) 67902ac6454SAndrew Thompson { 680ed6d949aSAndrew Thompson struct rue_softc *sc = usbd_xfer_softc(xfer); 681760bc48eSAndrew Thompson struct usb_ether *ue = &sc->sc_ue; 682a593f6b8SAndrew Thompson struct ifnet *ifp = uether_getifp(ue); 683ed6d949aSAndrew Thompson struct usb_page_cache *pc; 68402ac6454SAndrew Thompson uint16_t status; 685ed6d949aSAndrew Thompson int actlen; 686ed6d949aSAndrew Thompson 687ed6d949aSAndrew Thompson usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL); 68802ac6454SAndrew Thompson 68902ac6454SAndrew Thompson switch (USB_GET_STATE(xfer)) { 69002ac6454SAndrew Thompson case USB_ST_TRANSFERRED: 69102ac6454SAndrew Thompson 692ed6d949aSAndrew Thompson if (actlen < 4) { 693ecc70d3fSGleb Smirnoff if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); 69402ac6454SAndrew Thompson goto tr_setup; 69502ac6454SAndrew Thompson } 696ed6d949aSAndrew Thompson pc = usbd_xfer_get_frame(xfer, 0); 697ed6d949aSAndrew Thompson usbd_copy_out(pc, actlen - 4, &status, sizeof(status)); 698ed6d949aSAndrew Thompson actlen -= 4; 69902ac6454SAndrew Thompson 70020733245SPedro F. Giffuni /* check receive packet was valid or not */ 70102ac6454SAndrew Thompson status = le16toh(status); 70202ac6454SAndrew Thompson if ((status & RUE_RXSTAT_VALID) == 0) { 703ecc70d3fSGleb Smirnoff if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); 70402ac6454SAndrew Thompson goto tr_setup; 70502ac6454SAndrew Thompson } 706ed6d949aSAndrew Thompson uether_rxbuf(ue, pc, 0, actlen); 70702ac6454SAndrew Thompson /* FALLTHROUGH */ 70802ac6454SAndrew Thompson case USB_ST_SETUP: 70902ac6454SAndrew Thompson tr_setup: 710ed6d949aSAndrew Thompson usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer)); 711a593f6b8SAndrew Thompson usbd_transfer_submit(xfer); 712a593f6b8SAndrew Thompson uether_rxflush(ue); 71302ac6454SAndrew Thompson return; 71402ac6454SAndrew Thompson 71502ac6454SAndrew Thompson default: /* Error */ 71602ac6454SAndrew Thompson DPRINTF("bulk read error, %s\n", 717ed6d949aSAndrew Thompson usbd_errstr(error)); 71802ac6454SAndrew Thompson 719ed6d949aSAndrew Thompson if (error != USB_ERR_CANCELLED) { 72002ac6454SAndrew Thompson /* try to clear stall first */ 721ed6d949aSAndrew Thompson usbd_xfer_set_stall(xfer); 72202ac6454SAndrew Thompson goto tr_setup; 72302ac6454SAndrew Thompson } 72402ac6454SAndrew Thompson return; 72502ac6454SAndrew Thompson } 72602ac6454SAndrew Thompson } 72702ac6454SAndrew Thompson 72802ac6454SAndrew Thompson static void 729ed6d949aSAndrew Thompson rue_bulk_write_callback(struct usb_xfer *xfer, usb_error_t error) 73002ac6454SAndrew Thompson { 731ed6d949aSAndrew Thompson struct rue_softc *sc = usbd_xfer_softc(xfer); 732a593f6b8SAndrew Thompson struct ifnet *ifp = uether_getifp(&sc->sc_ue); 733ed6d949aSAndrew Thompson struct usb_page_cache *pc; 73402ac6454SAndrew Thompson struct mbuf *m; 73502ac6454SAndrew Thompson int temp_len; 73602ac6454SAndrew Thompson 73702ac6454SAndrew Thompson switch (USB_GET_STATE(xfer)) { 73802ac6454SAndrew Thompson case USB_ST_TRANSFERRED: 73902ac6454SAndrew Thompson DPRINTFN(11, "transfer complete\n"); 740ecc70d3fSGleb Smirnoff if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1); 74102ac6454SAndrew Thompson 74202ac6454SAndrew Thompson /* FALLTHROUGH */ 74302ac6454SAndrew Thompson case USB_ST_SETUP: 74402ac6454SAndrew Thompson tr_setup: 74502ac6454SAndrew Thompson if ((sc->sc_flags & RUE_FLAG_LINK) == 0) { 74602ac6454SAndrew Thompson /* 74702ac6454SAndrew Thompson * don't send anything if there is no link ! 74802ac6454SAndrew Thompson */ 74902ac6454SAndrew Thompson return; 75002ac6454SAndrew Thompson } 75102ac6454SAndrew Thompson IFQ_DRV_DEQUEUE(&ifp->if_snd, m); 75202ac6454SAndrew Thompson 75302ac6454SAndrew Thompson if (m == NULL) 75402ac6454SAndrew Thompson return; 75502ac6454SAndrew Thompson if (m->m_pkthdr.len > MCLBYTES) 75602ac6454SAndrew Thompson m->m_pkthdr.len = MCLBYTES; 75702ac6454SAndrew Thompson temp_len = m->m_pkthdr.len; 75802ac6454SAndrew Thompson 759ed6d949aSAndrew Thompson pc = usbd_xfer_get_frame(xfer, 0); 760ed6d949aSAndrew Thompson usbd_m_copy_in(pc, 0, m, 0, m->m_pkthdr.len); 76102ac6454SAndrew Thompson 76202ac6454SAndrew Thompson /* 76302ac6454SAndrew Thompson * This is an undocumented behavior. 76402ac6454SAndrew Thompson * RTL8150 chip doesn't send frame length smaller than 76502ac6454SAndrew Thompson * RUE_MIN_FRAMELEN (60) byte packet. 76602ac6454SAndrew Thompson */ 76702ac6454SAndrew Thompson if (temp_len < RUE_MIN_FRAMELEN) { 768ed6d949aSAndrew Thompson usbd_frame_zero(pc, temp_len, 76902ac6454SAndrew Thompson RUE_MIN_FRAMELEN - temp_len); 77002ac6454SAndrew Thompson temp_len = RUE_MIN_FRAMELEN; 77102ac6454SAndrew Thompson } 772ed6d949aSAndrew Thompson usbd_xfer_set_frame_len(xfer, 0, temp_len); 77302ac6454SAndrew Thompson 77402ac6454SAndrew Thompson /* 77502ac6454SAndrew Thompson * if there's a BPF listener, bounce a copy 77602ac6454SAndrew Thompson * of this frame to him: 77702ac6454SAndrew Thompson */ 77802ac6454SAndrew Thompson BPF_MTAP(ifp, m); 77902ac6454SAndrew Thompson 78002ac6454SAndrew Thompson m_freem(m); 78102ac6454SAndrew Thompson 782a593f6b8SAndrew Thompson usbd_transfer_submit(xfer); 78302ac6454SAndrew Thompson 78402ac6454SAndrew Thompson return; 78502ac6454SAndrew Thompson 78602ac6454SAndrew Thompson default: /* Error */ 78702ac6454SAndrew Thompson DPRINTFN(11, "transfer error, %s\n", 788ed6d949aSAndrew Thompson usbd_errstr(error)); 78902ac6454SAndrew Thompson 790ecc70d3fSGleb Smirnoff if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); 79102ac6454SAndrew Thompson 792ed6d949aSAndrew Thompson if (error != USB_ERR_CANCELLED) { 79302ac6454SAndrew Thompson /* try to clear stall first */ 794ed6d949aSAndrew Thompson usbd_xfer_set_stall(xfer); 79502ac6454SAndrew Thompson goto tr_setup; 79602ac6454SAndrew Thompson } 79702ac6454SAndrew Thompson return; 79802ac6454SAndrew Thompson } 79902ac6454SAndrew Thompson } 80002ac6454SAndrew Thompson 80102ac6454SAndrew Thompson static void 802760bc48eSAndrew Thompson rue_tick(struct usb_ether *ue) 80302ac6454SAndrew Thompson { 804a593f6b8SAndrew Thompson struct rue_softc *sc = uether_getsc(ue); 80502ac6454SAndrew Thompson struct mii_data *mii = GET_MII(sc); 80602ac6454SAndrew Thompson 80702ac6454SAndrew Thompson RUE_LOCK_ASSERT(sc, MA_OWNED); 80802ac6454SAndrew Thompson 80902ac6454SAndrew Thompson mii_tick(mii); 81002ac6454SAndrew Thompson if ((sc->sc_flags & RUE_FLAG_LINK) == 0 81102ac6454SAndrew Thompson && mii->mii_media_status & IFM_ACTIVE && 81202ac6454SAndrew Thompson IFM_SUBTYPE(mii->mii_media_active) != IFM_NONE) { 81302ac6454SAndrew Thompson sc->sc_flags |= RUE_FLAG_LINK; 81402ac6454SAndrew Thompson rue_start(ue); 81502ac6454SAndrew Thompson } 81602ac6454SAndrew Thompson } 81702ac6454SAndrew Thompson 81802ac6454SAndrew Thompson static void 819760bc48eSAndrew Thompson rue_start(struct usb_ether *ue) 82002ac6454SAndrew Thompson { 821a593f6b8SAndrew Thompson struct rue_softc *sc = uether_getsc(ue); 82202ac6454SAndrew Thompson 82302ac6454SAndrew Thompson /* 82402ac6454SAndrew Thompson * start the USB transfers, if not already started: 82502ac6454SAndrew Thompson */ 826a593f6b8SAndrew Thompson usbd_transfer_start(sc->sc_xfer[RUE_INTR_DT_RD]); 827a593f6b8SAndrew Thompson usbd_transfer_start(sc->sc_xfer[RUE_BULK_DT_RD]); 828a593f6b8SAndrew Thompson usbd_transfer_start(sc->sc_xfer[RUE_BULK_DT_WR]); 82902ac6454SAndrew Thompson } 83002ac6454SAndrew Thompson 83102ac6454SAndrew Thompson static void 832760bc48eSAndrew Thompson rue_init(struct usb_ether *ue) 83302ac6454SAndrew Thompson { 834a593f6b8SAndrew Thompson struct rue_softc *sc = uether_getsc(ue); 835a593f6b8SAndrew Thompson struct ifnet *ifp = uether_getifp(ue); 83602ac6454SAndrew Thompson 83702ac6454SAndrew Thompson RUE_LOCK_ASSERT(sc, MA_OWNED); 83802ac6454SAndrew Thompson 83902ac6454SAndrew Thompson /* 84002ac6454SAndrew Thompson * Cancel pending I/O 84102ac6454SAndrew Thompson */ 84202ac6454SAndrew Thompson rue_reset(sc); 84302ac6454SAndrew Thompson 84402ac6454SAndrew Thompson /* Set MAC address */ 84502ac6454SAndrew Thompson rue_write_mem(sc, RUE_IDR0, IF_LLADDR(ifp), ETHER_ADDR_LEN); 84602ac6454SAndrew Thompson 84702ac6454SAndrew Thompson rue_stop(ue); 84802ac6454SAndrew Thompson 84902ac6454SAndrew Thompson /* 85002ac6454SAndrew Thompson * Set the initial TX and RX configuration. 85102ac6454SAndrew Thompson */ 85202ac6454SAndrew Thompson rue_csr_write_1(sc, RUE_TCR, RUE_TCR_CONFIG); 85302ac6454SAndrew Thompson rue_csr_write_2(sc, RUE_RCR, RUE_RCR_CONFIG|RUE_RCR_AB); 85402ac6454SAndrew Thompson 85502ac6454SAndrew Thompson /* Load the multicast filter */ 85602ac6454SAndrew Thompson rue_setpromisc(ue); 85702ac6454SAndrew Thompson /* Load the multicast filter. */ 85802ac6454SAndrew Thompson rue_setmulti(ue); 85902ac6454SAndrew Thompson 86002ac6454SAndrew Thompson /* Enable RX and TX */ 86102ac6454SAndrew Thompson rue_csr_write_1(sc, RUE_CR, (RUE_CR_TE | RUE_CR_RE | RUE_CR_EP3CLREN)); 86202ac6454SAndrew Thompson 863ed6d949aSAndrew Thompson usbd_xfer_set_stall(sc->sc_xfer[RUE_BULK_DT_WR]); 86402ac6454SAndrew Thompson 86502ac6454SAndrew Thompson ifp->if_drv_flags |= IFF_DRV_RUNNING; 86602ac6454SAndrew Thompson rue_start(ue); 86702ac6454SAndrew Thompson } 86802ac6454SAndrew Thompson 86902ac6454SAndrew Thompson /* 87002ac6454SAndrew Thompson * Set media options. 87102ac6454SAndrew Thompson */ 87202ac6454SAndrew Thompson static int 87302ac6454SAndrew Thompson rue_ifmedia_upd(struct ifnet *ifp) 87402ac6454SAndrew Thompson { 87502ac6454SAndrew Thompson struct rue_softc *sc = ifp->if_softc; 87602ac6454SAndrew Thompson struct mii_data *mii = GET_MII(sc); 8773fcb7a53SMarius Strobl struct mii_softc *miisc; 878ebe01023SKevin Lo int error; 87902ac6454SAndrew Thompson 88002ac6454SAndrew Thompson RUE_LOCK_ASSERT(sc, MA_OWNED); 88102ac6454SAndrew Thompson 88202ac6454SAndrew Thompson sc->sc_flags &= ~RUE_FLAG_LINK; 88302ac6454SAndrew Thompson LIST_FOREACH(miisc, &mii->mii_phys, mii_list) 8843fcb7a53SMarius Strobl PHY_RESET(miisc); 885ebe01023SKevin Lo error = mii_mediachg(mii); 886ebe01023SKevin Lo return (error); 88702ac6454SAndrew Thompson } 88802ac6454SAndrew Thompson 88902ac6454SAndrew Thompson /* 89002ac6454SAndrew Thompson * Report current media status. 89102ac6454SAndrew Thompson */ 89202ac6454SAndrew Thompson static void 89302ac6454SAndrew Thompson rue_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr) 89402ac6454SAndrew Thompson { 89502ac6454SAndrew Thompson struct rue_softc *sc = ifp->if_softc; 89602ac6454SAndrew Thompson struct mii_data *mii = GET_MII(sc); 89702ac6454SAndrew Thompson 89802ac6454SAndrew Thompson RUE_LOCK(sc); 89902ac6454SAndrew Thompson mii_pollstat(mii); 90002ac6454SAndrew Thompson ifmr->ifm_active = mii->mii_media_active; 90102ac6454SAndrew Thompson ifmr->ifm_status = mii->mii_media_status; 902e9e549efSPyun YongHyeon RUE_UNLOCK(sc); 90302ac6454SAndrew Thompson } 90402ac6454SAndrew Thompson 90502ac6454SAndrew Thompson static void 906760bc48eSAndrew Thompson rue_stop(struct usb_ether *ue) 90702ac6454SAndrew Thompson { 908a593f6b8SAndrew Thompson struct rue_softc *sc = uether_getsc(ue); 909a593f6b8SAndrew Thompson struct ifnet *ifp = uether_getifp(ue); 91002ac6454SAndrew Thompson 91102ac6454SAndrew Thompson RUE_LOCK_ASSERT(sc, MA_OWNED); 91202ac6454SAndrew Thompson 91302ac6454SAndrew Thompson ifp->if_drv_flags &= ~IFF_DRV_RUNNING; 91402ac6454SAndrew Thompson sc->sc_flags &= ~RUE_FLAG_LINK; 91502ac6454SAndrew Thompson 91602ac6454SAndrew Thompson /* 91702ac6454SAndrew Thompson * stop all the transfers, if not already stopped: 91802ac6454SAndrew Thompson */ 919a593f6b8SAndrew Thompson usbd_transfer_stop(sc->sc_xfer[RUE_BULK_DT_WR]); 920a593f6b8SAndrew Thompson usbd_transfer_stop(sc->sc_xfer[RUE_BULK_DT_RD]); 921a593f6b8SAndrew Thompson usbd_transfer_stop(sc->sc_xfer[RUE_INTR_DT_RD]); 92202ac6454SAndrew Thompson 92302ac6454SAndrew Thompson rue_csr_write_1(sc, RUE_CR, 0x00); 92402ac6454SAndrew Thompson 92502ac6454SAndrew Thompson rue_reset(sc); 92602ac6454SAndrew Thompson } 927