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 /*- 2802ac6454SAndrew Thompson * Copyright (c) 1997, 1998, 1999, 2000 2902ac6454SAndrew Thompson * Bill Paul <wpaul@ee.columbia.edu>. All rights reserved. 3002ac6454SAndrew Thompson * 3102ac6454SAndrew Thompson * Redistribution and use in source and binary forms, with or without 3202ac6454SAndrew Thompson * modification, are permitted provided that the following conditions 3302ac6454SAndrew Thompson * are met: 3402ac6454SAndrew Thompson * 1. Redistributions of source code must retain the above copyright 3502ac6454SAndrew Thompson * notice, this list of conditions and the following disclaimer. 3602ac6454SAndrew Thompson * 2. Redistributions in binary form must reproduce the above copyright 3702ac6454SAndrew Thompson * notice, this list of conditions and the following disclaimer in the 3802ac6454SAndrew Thompson * documentation and/or other materials provided with the distribution. 3902ac6454SAndrew Thompson * 3. All advertising materials mentioning features or use of this software 4002ac6454SAndrew Thompson * must display the following acknowledgement: 4102ac6454SAndrew Thompson * This product includes software developed by Bill Paul. 4202ac6454SAndrew Thompson * 4. Neither the name of the author nor the names of any co-contributors 4302ac6454SAndrew Thompson * may be used to endorse or promote products derived from this software 4402ac6454SAndrew Thompson * without specific prior written permission. 4502ac6454SAndrew Thompson * 4602ac6454SAndrew Thompson * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND 4702ac6454SAndrew Thompson * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 4802ac6454SAndrew Thompson * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 4902ac6454SAndrew Thompson * ARE DISCLAIMED. IN NO EVENT SHALL Bill Paul OR THE VOICES IN HIS HEAD 5002ac6454SAndrew Thompson * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 5102ac6454SAndrew Thompson * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 5202ac6454SAndrew Thompson * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 5302ac6454SAndrew Thompson * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 5402ac6454SAndrew Thompson * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 5502ac6454SAndrew Thompson * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 5602ac6454SAndrew Thompson * THE POSSIBILITY OF SUCH DAMAGE. 5702ac6454SAndrew Thompson */ 5802ac6454SAndrew Thompson 5902ac6454SAndrew Thompson #include <sys/cdefs.h> 6002ac6454SAndrew Thompson __FBSDID("$FreeBSD$"); 6102ac6454SAndrew Thompson 6202ac6454SAndrew Thompson /* 6302ac6454SAndrew Thompson * RealTek RTL8150 USB to fast ethernet controller driver. 6402ac6454SAndrew Thompson * Datasheet is available from 6502ac6454SAndrew Thompson * ftp://ftp.realtek.com.tw/lancard/data_sheet/8150/. 6602ac6454SAndrew Thompson */ 6702ac6454SAndrew Thompson 68ed6d949aSAndrew Thompson #include <sys/stdint.h> 69ed6d949aSAndrew Thompson #include <sys/stddef.h> 70ed6d949aSAndrew Thompson #include <sys/param.h> 71ed6d949aSAndrew Thompson #include <sys/queue.h> 72ed6d949aSAndrew Thompson #include <sys/types.h> 73ed6d949aSAndrew Thompson #include <sys/systm.h> 74ed6d949aSAndrew Thompson #include <sys/kernel.h> 75ed6d949aSAndrew Thompson #include <sys/bus.h> 76ed6d949aSAndrew Thompson #include <sys/module.h> 77ed6d949aSAndrew Thompson #include <sys/lock.h> 78ed6d949aSAndrew Thompson #include <sys/mutex.h> 79ed6d949aSAndrew Thompson #include <sys/condvar.h> 80ed6d949aSAndrew Thompson #include <sys/sysctl.h> 81ed6d949aSAndrew Thompson #include <sys/sx.h> 82ed6d949aSAndrew Thompson #include <sys/unistd.h> 83ed6d949aSAndrew Thompson #include <sys/callout.h> 84ed6d949aSAndrew Thompson #include <sys/malloc.h> 85ed6d949aSAndrew Thompson #include <sys/priv.h> 86ed6d949aSAndrew Thompson 8702ac6454SAndrew Thompson #include <dev/usb/usb.h> 88ed6d949aSAndrew Thompson #include <dev/usb/usbdi.h> 89ed6d949aSAndrew Thompson #include <dev/usb/usbdi_util.h> 90ed6d949aSAndrew Thompson #include "usbdevs.h" 9102ac6454SAndrew Thompson 9202ac6454SAndrew Thompson #define USB_DEBUG_VAR rue_debug 9302ac6454SAndrew Thompson #include <dev/usb/usb_debug.h> 94ed6d949aSAndrew Thompson #include <dev/usb/usb_process.h> 9502ac6454SAndrew Thompson 9602ac6454SAndrew Thompson #include <dev/usb/net/usb_ethernet.h> 9702ac6454SAndrew Thompson #include <dev/usb/net/if_ruereg.h> 9802ac6454SAndrew Thompson 99b850ecc1SAndrew Thompson #ifdef USB_DEBUG 10002ac6454SAndrew Thompson static int rue_debug = 0; 10102ac6454SAndrew Thompson 1029360ae40SAndrew Thompson SYSCTL_NODE(_hw_usb, OID_AUTO, rue, CTLFLAG_RW, 0, "USB rue"); 1039360ae40SAndrew Thompson SYSCTL_INT(_hw_usb_rue, OID_AUTO, debug, CTLFLAG_RW, 10402ac6454SAndrew Thompson &rue_debug, 0, "Debug level"); 10502ac6454SAndrew Thompson #endif 10602ac6454SAndrew Thompson 10702ac6454SAndrew Thompson /* 10802ac6454SAndrew Thompson * Various supported device vendors/products. 10902ac6454SAndrew Thompson */ 11002ac6454SAndrew Thompson 111f1a16106SHans Petter Selasky static const STRUCT_USB_HOST_ID rue_devs[] = { 11202ac6454SAndrew Thompson {USB_VPI(USB_VENDOR_MELCO, USB_PRODUCT_MELCO_LUAKTX, 0)}, 11302ac6454SAndrew Thompson {USB_VPI(USB_VENDOR_REALTEK, USB_PRODUCT_REALTEK_USBKR100, 0)}, 1148f55d259SAndrew Thompson {USB_VPI(USB_VENDOR_OQO, USB_PRODUCT_OQO_ETHER01, 0)}, 11502ac6454SAndrew Thompson }; 11602ac6454SAndrew Thompson 11702ac6454SAndrew Thompson /* prototypes */ 11802ac6454SAndrew Thompson 11902ac6454SAndrew Thompson static device_probe_t rue_probe; 12002ac6454SAndrew Thompson static device_attach_t rue_attach; 12102ac6454SAndrew Thompson static device_detach_t rue_detach; 12202ac6454SAndrew Thompson 12302ac6454SAndrew Thompson static miibus_readreg_t rue_miibus_readreg; 12402ac6454SAndrew Thompson static miibus_writereg_t rue_miibus_writereg; 12502ac6454SAndrew Thompson static miibus_statchg_t rue_miibus_statchg; 12602ac6454SAndrew Thompson 127e0a69b51SAndrew Thompson static usb_callback_t rue_intr_callback; 128e0a69b51SAndrew Thompson static usb_callback_t rue_bulk_read_callback; 129e0a69b51SAndrew Thompson static usb_callback_t rue_bulk_write_callback; 13002ac6454SAndrew Thompson 131e0a69b51SAndrew Thompson static uether_fn_t rue_attach_post; 132e0a69b51SAndrew Thompson static uether_fn_t rue_init; 133e0a69b51SAndrew Thompson static uether_fn_t rue_stop; 134e0a69b51SAndrew Thompson static uether_fn_t rue_start; 135e0a69b51SAndrew Thompson static uether_fn_t rue_tick; 136e0a69b51SAndrew Thompson static uether_fn_t rue_setmulti; 137e0a69b51SAndrew Thompson static uether_fn_t rue_setpromisc; 13802ac6454SAndrew Thompson 13902ac6454SAndrew Thompson static int rue_read_mem(struct rue_softc *, uint16_t, void *, int); 14002ac6454SAndrew Thompson static int rue_write_mem(struct rue_softc *, uint16_t, void *, int); 14102ac6454SAndrew Thompson static uint8_t rue_csr_read_1(struct rue_softc *, uint16_t); 14202ac6454SAndrew Thompson static uint16_t rue_csr_read_2(struct rue_softc *, uint16_t); 14302ac6454SAndrew Thompson static int rue_csr_write_1(struct rue_softc *, uint16_t, uint8_t); 14402ac6454SAndrew Thompson static int rue_csr_write_2(struct rue_softc *, uint16_t, uint16_t); 14502ac6454SAndrew Thompson static int rue_csr_write_4(struct rue_softc *, int, uint32_t); 14602ac6454SAndrew Thompson 14702ac6454SAndrew Thompson static void rue_reset(struct rue_softc *); 14802ac6454SAndrew Thompson static int rue_ifmedia_upd(struct ifnet *); 14902ac6454SAndrew Thompson static void rue_ifmedia_sts(struct ifnet *, struct ifmediareq *); 15002ac6454SAndrew Thompson 151760bc48eSAndrew Thompson static const struct usb_config rue_config[RUE_N_TRANSFER] = { 15202ac6454SAndrew Thompson 15302ac6454SAndrew Thompson [RUE_BULK_DT_WR] = { 15402ac6454SAndrew Thompson .type = UE_BULK, 15502ac6454SAndrew Thompson .endpoint = UE_ADDR_ANY, 15602ac6454SAndrew Thompson .direction = UE_DIR_OUT, 1574eae601eSAndrew Thompson .bufsize = MCLBYTES, 1584eae601eSAndrew Thompson .flags = {.pipe_bof = 1,.force_short_xfer = 1,}, 1594eae601eSAndrew Thompson .callback = rue_bulk_write_callback, 1604eae601eSAndrew Thompson .timeout = 10000, /* 10 seconds */ 16102ac6454SAndrew Thompson }, 16202ac6454SAndrew Thompson 16302ac6454SAndrew Thompson [RUE_BULK_DT_RD] = { 16402ac6454SAndrew Thompson .type = UE_BULK, 16502ac6454SAndrew Thompson .endpoint = UE_ADDR_ANY, 16602ac6454SAndrew Thompson .direction = UE_DIR_IN, 1674eae601eSAndrew Thompson .bufsize = (MCLBYTES + 4), 1684eae601eSAndrew Thompson .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, 1694eae601eSAndrew Thompson .callback = rue_bulk_read_callback, 1704eae601eSAndrew Thompson .timeout = 0, /* no timeout */ 17102ac6454SAndrew Thompson }, 17202ac6454SAndrew Thompson 17302ac6454SAndrew Thompson [RUE_INTR_DT_RD] = { 17402ac6454SAndrew Thompson .type = UE_INTERRUPT, 17502ac6454SAndrew Thompson .endpoint = UE_ADDR_ANY, 17602ac6454SAndrew Thompson .direction = UE_DIR_IN, 1774eae601eSAndrew Thompson .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, 1784eae601eSAndrew Thompson .bufsize = 0, /* use wMaxPacketSize */ 1794eae601eSAndrew Thompson .callback = rue_intr_callback, 18002ac6454SAndrew Thompson }, 18102ac6454SAndrew Thompson }; 18202ac6454SAndrew Thompson 18302ac6454SAndrew Thompson static device_method_t rue_methods[] = { 18402ac6454SAndrew Thompson /* Device interface */ 18502ac6454SAndrew Thompson DEVMETHOD(device_probe, rue_probe), 18602ac6454SAndrew Thompson DEVMETHOD(device_attach, rue_attach), 18702ac6454SAndrew Thompson DEVMETHOD(device_detach, rue_detach), 18802ac6454SAndrew Thompson 18902ac6454SAndrew Thompson /* Bus interface */ 19002ac6454SAndrew Thompson DEVMETHOD(bus_print_child, bus_generic_print_child), 19102ac6454SAndrew Thompson DEVMETHOD(bus_driver_added, bus_generic_driver_added), 19202ac6454SAndrew Thompson 19302ac6454SAndrew Thompson /* MII interface */ 19402ac6454SAndrew Thompson DEVMETHOD(miibus_readreg, rue_miibus_readreg), 19502ac6454SAndrew Thompson DEVMETHOD(miibus_writereg, rue_miibus_writereg), 19602ac6454SAndrew Thompson DEVMETHOD(miibus_statchg, rue_miibus_statchg), 19702ac6454SAndrew Thompson 19802ac6454SAndrew Thompson {0, 0} 19902ac6454SAndrew Thompson }; 20002ac6454SAndrew Thompson 20102ac6454SAndrew Thompson static driver_t rue_driver = { 20202ac6454SAndrew Thompson .name = "rue", 20302ac6454SAndrew Thompson .methods = rue_methods, 20402ac6454SAndrew Thompson .size = sizeof(struct rue_softc), 20502ac6454SAndrew Thompson }; 20602ac6454SAndrew Thompson 20702ac6454SAndrew Thompson static devclass_t rue_devclass; 20802ac6454SAndrew Thompson 2099aef556dSAndrew Thompson DRIVER_MODULE(rue, uhub, rue_driver, rue_devclass, NULL, 0); 21002ac6454SAndrew Thompson DRIVER_MODULE(miibus, rue, miibus_driver, miibus_devclass, 0, 0); 21102ac6454SAndrew Thompson MODULE_DEPEND(rue, uether, 1, 1, 1); 21202ac6454SAndrew Thompson MODULE_DEPEND(rue, usb, 1, 1, 1); 21302ac6454SAndrew Thompson MODULE_DEPEND(rue, ether, 1, 1, 1); 21402ac6454SAndrew Thompson MODULE_DEPEND(rue, miibus, 1, 1, 1); 215910cb8feSAndrew Thompson MODULE_VERSION(rue, 1); 21602ac6454SAndrew Thompson 217760bc48eSAndrew Thompson static const struct usb_ether_methods rue_ue_methods = { 21802ac6454SAndrew Thompson .ue_attach_post = rue_attach_post, 21902ac6454SAndrew Thompson .ue_start = rue_start, 22002ac6454SAndrew Thompson .ue_init = rue_init, 22102ac6454SAndrew Thompson .ue_stop = rue_stop, 22202ac6454SAndrew Thompson .ue_tick = rue_tick, 22302ac6454SAndrew Thompson .ue_setmulti = rue_setmulti, 22402ac6454SAndrew Thompson .ue_setpromisc = rue_setpromisc, 22502ac6454SAndrew Thompson .ue_mii_upd = rue_ifmedia_upd, 22602ac6454SAndrew Thompson .ue_mii_sts = rue_ifmedia_sts, 22702ac6454SAndrew Thompson }; 22802ac6454SAndrew Thompson 22902ac6454SAndrew Thompson #define RUE_SETBIT(sc, reg, x) \ 23002ac6454SAndrew Thompson rue_csr_write_1(sc, reg, rue_csr_read_1(sc, reg) | (x)) 23102ac6454SAndrew Thompson 23202ac6454SAndrew Thompson #define RUE_CLRBIT(sc, reg, x) \ 23302ac6454SAndrew Thompson rue_csr_write_1(sc, reg, rue_csr_read_1(sc, reg) & ~(x)) 23402ac6454SAndrew Thompson 23502ac6454SAndrew Thompson static int 23602ac6454SAndrew Thompson rue_read_mem(struct rue_softc *sc, uint16_t addr, void *buf, int len) 23702ac6454SAndrew Thompson { 238760bc48eSAndrew Thompson struct usb_device_request req; 23902ac6454SAndrew Thompson 24002ac6454SAndrew Thompson req.bmRequestType = UT_READ_VENDOR_DEVICE; 24102ac6454SAndrew Thompson req.bRequest = UR_SET_ADDRESS; 24202ac6454SAndrew Thompson USETW(req.wValue, addr); 24302ac6454SAndrew Thompson USETW(req.wIndex, 0); 24402ac6454SAndrew Thompson USETW(req.wLength, len); 24502ac6454SAndrew Thompson 246a593f6b8SAndrew Thompson return (uether_do_request(&sc->sc_ue, &req, buf, 1000)); 24702ac6454SAndrew Thompson } 24802ac6454SAndrew Thompson 24902ac6454SAndrew Thompson static int 25002ac6454SAndrew Thompson rue_write_mem(struct rue_softc *sc, uint16_t addr, void *buf, int len) 25102ac6454SAndrew Thompson { 252760bc48eSAndrew Thompson struct usb_device_request req; 25302ac6454SAndrew Thompson 25402ac6454SAndrew Thompson req.bmRequestType = UT_WRITE_VENDOR_DEVICE; 25502ac6454SAndrew Thompson req.bRequest = UR_SET_ADDRESS; 25602ac6454SAndrew Thompson USETW(req.wValue, addr); 25702ac6454SAndrew Thompson USETW(req.wIndex, 0); 25802ac6454SAndrew Thompson USETW(req.wLength, len); 25902ac6454SAndrew Thompson 260a593f6b8SAndrew Thompson return (uether_do_request(&sc->sc_ue, &req, buf, 1000)); 26102ac6454SAndrew Thompson } 26202ac6454SAndrew Thompson 26302ac6454SAndrew Thompson static uint8_t 26402ac6454SAndrew Thompson rue_csr_read_1(struct rue_softc *sc, uint16_t reg) 26502ac6454SAndrew Thompson { 26602ac6454SAndrew Thompson uint8_t val; 26702ac6454SAndrew Thompson 26802ac6454SAndrew Thompson rue_read_mem(sc, reg, &val, 1); 26902ac6454SAndrew Thompson return (val); 27002ac6454SAndrew Thompson } 27102ac6454SAndrew Thompson 27202ac6454SAndrew Thompson static uint16_t 27302ac6454SAndrew Thompson rue_csr_read_2(struct rue_softc *sc, uint16_t reg) 27402ac6454SAndrew Thompson { 27502ac6454SAndrew Thompson uint8_t val[2]; 27602ac6454SAndrew Thompson 27702ac6454SAndrew Thompson rue_read_mem(sc, reg, &val, 2); 27802ac6454SAndrew Thompson return (UGETW(val)); 27902ac6454SAndrew Thompson } 28002ac6454SAndrew Thompson 28102ac6454SAndrew Thompson static int 28202ac6454SAndrew Thompson rue_csr_write_1(struct rue_softc *sc, uint16_t reg, uint8_t val) 28302ac6454SAndrew Thompson { 28402ac6454SAndrew Thompson return (rue_write_mem(sc, reg, &val, 1)); 28502ac6454SAndrew Thompson } 28602ac6454SAndrew Thompson 28702ac6454SAndrew Thompson static int 28802ac6454SAndrew Thompson rue_csr_write_2(struct rue_softc *sc, uint16_t reg, uint16_t val) 28902ac6454SAndrew Thompson { 29002ac6454SAndrew Thompson uint8_t temp[2]; 29102ac6454SAndrew Thompson 29202ac6454SAndrew Thompson USETW(temp, val); 29302ac6454SAndrew Thompson return (rue_write_mem(sc, reg, &temp, 2)); 29402ac6454SAndrew Thompson } 29502ac6454SAndrew Thompson 29602ac6454SAndrew Thompson static int 29702ac6454SAndrew Thompson rue_csr_write_4(struct rue_softc *sc, int reg, uint32_t val) 29802ac6454SAndrew Thompson { 29902ac6454SAndrew Thompson uint8_t temp[4]; 30002ac6454SAndrew Thompson 30102ac6454SAndrew Thompson USETDW(temp, val); 30202ac6454SAndrew Thompson return (rue_write_mem(sc, reg, &temp, 4)); 30302ac6454SAndrew Thompson } 30402ac6454SAndrew Thompson 30502ac6454SAndrew Thompson static int 30602ac6454SAndrew Thompson rue_miibus_readreg(device_t dev, int phy, int reg) 30702ac6454SAndrew Thompson { 30802ac6454SAndrew Thompson struct rue_softc *sc = device_get_softc(dev); 30902ac6454SAndrew Thompson uint16_t rval; 31002ac6454SAndrew Thompson uint16_t ruereg; 31102ac6454SAndrew Thompson int locked; 31202ac6454SAndrew Thompson 31302ac6454SAndrew Thompson if (phy != 0) /* RTL8150 supports PHY == 0, only */ 31402ac6454SAndrew Thompson return (0); 31502ac6454SAndrew Thompson 31602ac6454SAndrew Thompson locked = mtx_owned(&sc->sc_mtx); 31702ac6454SAndrew Thompson if (!locked) 31802ac6454SAndrew Thompson RUE_LOCK(sc); 31902ac6454SAndrew Thompson 32002ac6454SAndrew Thompson switch (reg) { 32102ac6454SAndrew Thompson case MII_BMCR: 32202ac6454SAndrew Thompson ruereg = RUE_BMCR; 32302ac6454SAndrew Thompson break; 32402ac6454SAndrew Thompson case MII_BMSR: 32502ac6454SAndrew Thompson ruereg = RUE_BMSR; 32602ac6454SAndrew Thompson break; 32702ac6454SAndrew Thompson case MII_ANAR: 32802ac6454SAndrew Thompson ruereg = RUE_ANAR; 32902ac6454SAndrew Thompson break; 33002ac6454SAndrew Thompson case MII_ANER: 33102ac6454SAndrew Thompson ruereg = RUE_AER; 33202ac6454SAndrew Thompson break; 33302ac6454SAndrew Thompson case MII_ANLPAR: 33402ac6454SAndrew Thompson ruereg = RUE_ANLP; 33502ac6454SAndrew Thompson break; 33602ac6454SAndrew Thompson case MII_PHYIDR1: 33702ac6454SAndrew Thompson case MII_PHYIDR2: 33802ac6454SAndrew Thompson rval = 0; 33902ac6454SAndrew Thompson goto done; 34002ac6454SAndrew Thompson default: 34102ac6454SAndrew Thompson if (RUE_REG_MIN <= reg && reg <= RUE_REG_MAX) { 34202ac6454SAndrew Thompson rval = rue_csr_read_1(sc, reg); 34302ac6454SAndrew Thompson goto done; 34402ac6454SAndrew Thompson } 34502ac6454SAndrew Thompson device_printf(sc->sc_ue.ue_dev, "bad phy register\n"); 34602ac6454SAndrew Thompson rval = 0; 34702ac6454SAndrew Thompson goto done; 34802ac6454SAndrew Thompson } 34902ac6454SAndrew Thompson 35002ac6454SAndrew Thompson rval = rue_csr_read_2(sc, ruereg); 35102ac6454SAndrew Thompson done: 35202ac6454SAndrew Thompson if (!locked) 35302ac6454SAndrew Thompson RUE_UNLOCK(sc); 35402ac6454SAndrew Thompson return (rval); 35502ac6454SAndrew Thompson } 35602ac6454SAndrew Thompson 35702ac6454SAndrew Thompson static int 35802ac6454SAndrew Thompson rue_miibus_writereg(device_t dev, int phy, int reg, int data) 35902ac6454SAndrew Thompson { 36002ac6454SAndrew Thompson struct rue_softc *sc = device_get_softc(dev); 36102ac6454SAndrew Thompson uint16_t ruereg; 36202ac6454SAndrew Thompson int locked; 36302ac6454SAndrew Thompson 36402ac6454SAndrew Thompson if (phy != 0) /* RTL8150 supports PHY == 0, only */ 36502ac6454SAndrew Thompson return (0); 36602ac6454SAndrew Thompson 36702ac6454SAndrew Thompson locked = mtx_owned(&sc->sc_mtx); 36802ac6454SAndrew Thompson if (!locked) 36902ac6454SAndrew Thompson RUE_LOCK(sc); 37002ac6454SAndrew Thompson 37102ac6454SAndrew Thompson switch (reg) { 37202ac6454SAndrew Thompson case MII_BMCR: 37302ac6454SAndrew Thompson ruereg = RUE_BMCR; 37402ac6454SAndrew Thompson break; 37502ac6454SAndrew Thompson case MII_BMSR: 37602ac6454SAndrew Thompson ruereg = RUE_BMSR; 37702ac6454SAndrew Thompson break; 37802ac6454SAndrew Thompson case MII_ANAR: 37902ac6454SAndrew Thompson ruereg = RUE_ANAR; 38002ac6454SAndrew Thompson break; 38102ac6454SAndrew Thompson case MII_ANER: 38202ac6454SAndrew Thompson ruereg = RUE_AER; 38302ac6454SAndrew Thompson break; 38402ac6454SAndrew Thompson case MII_ANLPAR: 38502ac6454SAndrew Thompson ruereg = RUE_ANLP; 38602ac6454SAndrew Thompson break; 38702ac6454SAndrew Thompson case MII_PHYIDR1: 38802ac6454SAndrew Thompson case MII_PHYIDR2: 38902ac6454SAndrew Thompson goto done; 39002ac6454SAndrew Thompson default: 39102ac6454SAndrew Thompson if (RUE_REG_MIN <= reg && reg <= RUE_REG_MAX) { 39202ac6454SAndrew Thompson rue_csr_write_1(sc, reg, data); 39302ac6454SAndrew Thompson goto done; 39402ac6454SAndrew Thompson } 39502ac6454SAndrew Thompson device_printf(sc->sc_ue.ue_dev, " bad phy register\n"); 39602ac6454SAndrew Thompson goto done; 39702ac6454SAndrew Thompson } 39802ac6454SAndrew Thompson rue_csr_write_2(sc, ruereg, data); 39902ac6454SAndrew Thompson done: 40002ac6454SAndrew Thompson if (!locked) 40102ac6454SAndrew Thompson RUE_UNLOCK(sc); 40202ac6454SAndrew Thompson return (0); 40302ac6454SAndrew Thompson } 40402ac6454SAndrew Thompson 40502ac6454SAndrew Thompson static void 40602ac6454SAndrew Thompson rue_miibus_statchg(device_t dev) 40702ac6454SAndrew Thompson { 40802ac6454SAndrew Thompson /* 40902ac6454SAndrew Thompson * When the code below is enabled the card starts doing weird 41002ac6454SAndrew Thompson * things after link going from UP to DOWN and back UP. 41102ac6454SAndrew Thompson * 41202ac6454SAndrew Thompson * Looks like some of register writes below messes up PHY 41302ac6454SAndrew Thompson * interface. 41402ac6454SAndrew Thompson * 41502ac6454SAndrew Thompson * No visible regressions were found after commenting this code 41602ac6454SAndrew Thompson * out, so that disable it for good. 41702ac6454SAndrew Thompson */ 41802ac6454SAndrew Thompson #if 0 41902ac6454SAndrew Thompson struct rue_softc *sc = device_get_softc(dev); 42002ac6454SAndrew Thompson struct mii_data *mii = GET_MII(sc); 42102ac6454SAndrew Thompson uint16_t bmcr; 42202ac6454SAndrew Thompson int locked; 42302ac6454SAndrew Thompson 42402ac6454SAndrew Thompson locked = mtx_owned(&sc->sc_mtx); 42502ac6454SAndrew Thompson if (!locked) 42602ac6454SAndrew Thompson RUE_LOCK(sc); 42702ac6454SAndrew Thompson 42802ac6454SAndrew Thompson RUE_CLRBIT(sc, RUE_CR, (RUE_CR_RE | RUE_CR_TE)); 42902ac6454SAndrew Thompson 43002ac6454SAndrew Thompson bmcr = rue_csr_read_2(sc, RUE_BMCR); 43102ac6454SAndrew Thompson 43202ac6454SAndrew Thompson if (IFM_SUBTYPE(mii->mii_media_active) == IFM_100_TX) 43302ac6454SAndrew Thompson bmcr |= RUE_BMCR_SPD_SET; 43402ac6454SAndrew Thompson else 43502ac6454SAndrew Thompson bmcr &= ~RUE_BMCR_SPD_SET; 43602ac6454SAndrew Thompson 43702ac6454SAndrew Thompson if ((mii->mii_media_active & IFM_GMASK) == IFM_FDX) 43802ac6454SAndrew Thompson bmcr |= RUE_BMCR_DUPLEX; 43902ac6454SAndrew Thompson else 44002ac6454SAndrew Thompson bmcr &= ~RUE_BMCR_DUPLEX; 44102ac6454SAndrew Thompson 44202ac6454SAndrew Thompson rue_csr_write_2(sc, RUE_BMCR, bmcr); 44302ac6454SAndrew Thompson 44402ac6454SAndrew Thompson RUE_SETBIT(sc, RUE_CR, (RUE_CR_RE | RUE_CR_TE)); 44502ac6454SAndrew Thompson 44602ac6454SAndrew Thompson if (!locked) 44702ac6454SAndrew Thompson RUE_UNLOCK(sc); 44802ac6454SAndrew Thompson #endif 44902ac6454SAndrew Thompson } 45002ac6454SAndrew Thompson 45102ac6454SAndrew Thompson static void 452760bc48eSAndrew Thompson rue_setpromisc(struct usb_ether *ue) 45302ac6454SAndrew Thompson { 454a593f6b8SAndrew Thompson struct rue_softc *sc = uether_getsc(ue); 455a593f6b8SAndrew Thompson struct ifnet *ifp = uether_getifp(ue); 45602ac6454SAndrew Thompson 45702ac6454SAndrew Thompson RUE_LOCK_ASSERT(sc, MA_OWNED); 45802ac6454SAndrew Thompson 45902ac6454SAndrew Thompson /* If we want promiscuous mode, set the allframes bit. */ 46002ac6454SAndrew Thompson if (ifp->if_flags & IFF_PROMISC) 46102ac6454SAndrew Thompson RUE_SETBIT(sc, RUE_RCR, RUE_RCR_AAP); 46202ac6454SAndrew Thompson else 46302ac6454SAndrew Thompson RUE_CLRBIT(sc, RUE_RCR, RUE_RCR_AAP); 46402ac6454SAndrew Thompson } 46502ac6454SAndrew Thompson 46602ac6454SAndrew Thompson /* 46702ac6454SAndrew Thompson * Program the 64-bit multicast hash filter. 46802ac6454SAndrew Thompson */ 46902ac6454SAndrew Thompson static void 470760bc48eSAndrew Thompson rue_setmulti(struct usb_ether *ue) 47102ac6454SAndrew Thompson { 472a593f6b8SAndrew Thompson struct rue_softc *sc = uether_getsc(ue); 473a593f6b8SAndrew Thompson struct ifnet *ifp = uether_getifp(ue); 47402ac6454SAndrew Thompson uint16_t rxcfg; 47502ac6454SAndrew Thompson int h = 0; 47602ac6454SAndrew Thompson uint32_t hashes[2] = { 0, 0 }; 47702ac6454SAndrew Thompson struct ifmultiaddr *ifma; 47802ac6454SAndrew Thompson int mcnt = 0; 47902ac6454SAndrew Thompson 48002ac6454SAndrew Thompson RUE_LOCK_ASSERT(sc, MA_OWNED); 48102ac6454SAndrew Thompson 48202ac6454SAndrew Thompson rxcfg = rue_csr_read_2(sc, RUE_RCR); 48302ac6454SAndrew Thompson 48402ac6454SAndrew Thompson if (ifp->if_flags & IFF_ALLMULTI || ifp->if_flags & IFF_PROMISC) { 48502ac6454SAndrew Thompson rxcfg |= (RUE_RCR_AAM | RUE_RCR_AAP); 48602ac6454SAndrew Thompson rxcfg &= ~RUE_RCR_AM; 48702ac6454SAndrew Thompson rue_csr_write_2(sc, RUE_RCR, rxcfg); 48802ac6454SAndrew Thompson rue_csr_write_4(sc, RUE_MAR0, 0xFFFFFFFF); 48902ac6454SAndrew Thompson rue_csr_write_4(sc, RUE_MAR4, 0xFFFFFFFF); 49002ac6454SAndrew Thompson return; 49102ac6454SAndrew Thompson } 49202ac6454SAndrew Thompson 49302ac6454SAndrew Thompson /* first, zot all the existing hash bits */ 49402ac6454SAndrew Thompson rue_csr_write_4(sc, RUE_MAR0, 0); 49502ac6454SAndrew Thompson rue_csr_write_4(sc, RUE_MAR4, 0); 49602ac6454SAndrew Thompson 49702ac6454SAndrew Thompson /* now program new ones */ 498eb956cd0SRobert Watson if_maddr_rlock(ifp); 49902ac6454SAndrew Thompson TAILQ_FOREACH (ifma, &ifp->if_multiaddrs, ifma_link) 50002ac6454SAndrew Thompson { 50102ac6454SAndrew Thompson if (ifma->ifma_addr->sa_family != AF_LINK) 50202ac6454SAndrew Thompson continue; 50302ac6454SAndrew Thompson h = ether_crc32_be(LLADDR((struct sockaddr_dl *) 50402ac6454SAndrew Thompson ifma->ifma_addr), ETHER_ADDR_LEN) >> 26; 50502ac6454SAndrew Thompson if (h < 32) 50602ac6454SAndrew Thompson hashes[0] |= (1 << h); 50702ac6454SAndrew Thompson else 50802ac6454SAndrew Thompson hashes[1] |= (1 << (h - 32)); 50902ac6454SAndrew Thompson mcnt++; 51002ac6454SAndrew Thompson } 511eb956cd0SRobert Watson if_maddr_runlock(ifp); 51202ac6454SAndrew Thompson 51302ac6454SAndrew Thompson if (mcnt) 51402ac6454SAndrew Thompson rxcfg |= RUE_RCR_AM; 51502ac6454SAndrew Thompson else 51602ac6454SAndrew Thompson rxcfg &= ~RUE_RCR_AM; 51702ac6454SAndrew Thompson 51802ac6454SAndrew Thompson rxcfg &= ~(RUE_RCR_AAM | RUE_RCR_AAP); 51902ac6454SAndrew Thompson 52002ac6454SAndrew Thompson rue_csr_write_2(sc, RUE_RCR, rxcfg); 52102ac6454SAndrew Thompson rue_csr_write_4(sc, RUE_MAR0, hashes[0]); 52202ac6454SAndrew Thompson rue_csr_write_4(sc, RUE_MAR4, hashes[1]); 52302ac6454SAndrew Thompson } 52402ac6454SAndrew Thompson 52502ac6454SAndrew Thompson static void 52602ac6454SAndrew Thompson rue_reset(struct rue_softc *sc) 52702ac6454SAndrew Thompson { 52802ac6454SAndrew Thompson int i; 52902ac6454SAndrew Thompson 53002ac6454SAndrew Thompson rue_csr_write_1(sc, RUE_CR, RUE_CR_SOFT_RST); 53102ac6454SAndrew Thompson 53202ac6454SAndrew Thompson for (i = 0; i != RUE_TIMEOUT; i++) { 533a593f6b8SAndrew Thompson if (uether_pause(&sc->sc_ue, hz / 1000)) 53402ac6454SAndrew Thompson break; 53502ac6454SAndrew Thompson if (!(rue_csr_read_1(sc, RUE_CR) & RUE_CR_SOFT_RST)) 53602ac6454SAndrew Thompson break; 53702ac6454SAndrew Thompson } 53802ac6454SAndrew Thompson if (i == RUE_TIMEOUT) 539767cb2e2SAndrew Thompson device_printf(sc->sc_ue.ue_dev, "reset never completed\n"); 54002ac6454SAndrew Thompson 541a593f6b8SAndrew Thompson uether_pause(&sc->sc_ue, hz / 100); 54202ac6454SAndrew Thompson } 54302ac6454SAndrew Thompson 54402ac6454SAndrew Thompson static void 545760bc48eSAndrew Thompson rue_attach_post(struct usb_ether *ue) 54602ac6454SAndrew Thompson { 547a593f6b8SAndrew Thompson struct rue_softc *sc = uether_getsc(ue); 54802ac6454SAndrew Thompson 54902ac6454SAndrew Thompson /* reset the adapter */ 55002ac6454SAndrew Thompson rue_reset(sc); 55102ac6454SAndrew Thompson 55202ac6454SAndrew Thompson /* get station address from the EEPROM */ 55302ac6454SAndrew Thompson rue_read_mem(sc, RUE_EEPROM_IDR0, ue->ue_eaddr, ETHER_ADDR_LEN); 55402ac6454SAndrew Thompson } 55502ac6454SAndrew Thompson 55602ac6454SAndrew Thompson /* 55702ac6454SAndrew Thompson * Probe for a RTL8150 chip. 55802ac6454SAndrew Thompson */ 55902ac6454SAndrew Thompson static int 56002ac6454SAndrew Thompson rue_probe(device_t dev) 56102ac6454SAndrew Thompson { 562760bc48eSAndrew Thompson struct usb_attach_arg *uaa = device_get_ivars(dev); 56302ac6454SAndrew Thompson 564f29a0724SAndrew Thompson if (uaa->usb_mode != USB_MODE_HOST) 56502ac6454SAndrew Thompson return (ENXIO); 56602ac6454SAndrew Thompson if (uaa->info.bConfigIndex != RUE_CONFIG_IDX) 56702ac6454SAndrew Thompson return (ENXIO); 56802ac6454SAndrew Thompson if (uaa->info.bIfaceIndex != RUE_IFACE_IDX) 56902ac6454SAndrew Thompson return (ENXIO); 57002ac6454SAndrew Thompson 571a593f6b8SAndrew Thompson return (usbd_lookup_id_by_uaa(rue_devs, sizeof(rue_devs), uaa)); 57202ac6454SAndrew Thompson } 57302ac6454SAndrew Thompson 57402ac6454SAndrew Thompson /* 57502ac6454SAndrew Thompson * Attach the interface. Allocate softc structures, do ifmedia 57602ac6454SAndrew Thompson * setup and ethernet/BPF attach. 57702ac6454SAndrew Thompson */ 57802ac6454SAndrew Thompson static int 57902ac6454SAndrew Thompson rue_attach(device_t dev) 58002ac6454SAndrew Thompson { 581760bc48eSAndrew Thompson struct usb_attach_arg *uaa = device_get_ivars(dev); 58202ac6454SAndrew Thompson struct rue_softc *sc = device_get_softc(dev); 583760bc48eSAndrew Thompson struct usb_ether *ue = &sc->sc_ue; 58402ac6454SAndrew Thompson uint8_t iface_index; 58502ac6454SAndrew Thompson int error; 58602ac6454SAndrew Thompson 587a593f6b8SAndrew Thompson device_set_usb_desc(dev); 58802ac6454SAndrew Thompson mtx_init(&sc->sc_mtx, device_get_nameunit(dev), NULL, MTX_DEF); 58902ac6454SAndrew Thompson 59002ac6454SAndrew Thompson iface_index = RUE_IFACE_IDX; 591a593f6b8SAndrew Thompson error = usbd_transfer_setup(uaa->device, &iface_index, 59202ac6454SAndrew Thompson sc->sc_xfer, rue_config, RUE_N_TRANSFER, 59302ac6454SAndrew Thompson sc, &sc->sc_mtx); 59402ac6454SAndrew Thompson if (error) { 595767cb2e2SAndrew Thompson device_printf(dev, "allocating USB transfers failed\n"); 59602ac6454SAndrew Thompson goto detach; 59702ac6454SAndrew Thompson } 59802ac6454SAndrew Thompson 59902ac6454SAndrew Thompson ue->ue_sc = sc; 60002ac6454SAndrew Thompson ue->ue_dev = dev; 60102ac6454SAndrew Thompson ue->ue_udev = uaa->device; 60202ac6454SAndrew Thompson ue->ue_mtx = &sc->sc_mtx; 60302ac6454SAndrew Thompson ue->ue_methods = &rue_ue_methods; 60402ac6454SAndrew Thompson 605a593f6b8SAndrew Thompson error = uether_ifattach(ue); 60602ac6454SAndrew Thompson if (error) { 60702ac6454SAndrew Thompson device_printf(dev, "could not attach interface\n"); 60802ac6454SAndrew Thompson goto detach; 60902ac6454SAndrew Thompson } 61002ac6454SAndrew Thompson return (0); /* success */ 61102ac6454SAndrew Thompson 61202ac6454SAndrew Thompson detach: 61302ac6454SAndrew Thompson rue_detach(dev); 61402ac6454SAndrew Thompson return (ENXIO); /* failure */ 61502ac6454SAndrew Thompson } 61602ac6454SAndrew Thompson 61702ac6454SAndrew Thompson static int 61802ac6454SAndrew Thompson rue_detach(device_t dev) 61902ac6454SAndrew Thompson { 62002ac6454SAndrew Thompson struct rue_softc *sc = device_get_softc(dev); 621760bc48eSAndrew Thompson struct usb_ether *ue = &sc->sc_ue; 62202ac6454SAndrew Thompson 623a593f6b8SAndrew Thompson usbd_transfer_unsetup(sc->sc_xfer, RUE_N_TRANSFER); 624a593f6b8SAndrew Thompson uether_ifdetach(ue); 62502ac6454SAndrew Thompson mtx_destroy(&sc->sc_mtx); 62602ac6454SAndrew Thompson 62702ac6454SAndrew Thompson return (0); 62802ac6454SAndrew Thompson } 62902ac6454SAndrew Thompson 63002ac6454SAndrew Thompson static void 631ed6d949aSAndrew Thompson rue_intr_callback(struct usb_xfer *xfer, usb_error_t error) 63202ac6454SAndrew Thompson { 633ed6d949aSAndrew Thompson struct rue_softc *sc = usbd_xfer_softc(xfer); 634a593f6b8SAndrew Thompson struct ifnet *ifp = uether_getifp(&sc->sc_ue); 63502ac6454SAndrew Thompson struct rue_intrpkt pkt; 636ed6d949aSAndrew Thompson struct usb_page_cache *pc; 637ed6d949aSAndrew Thompson int actlen; 638ed6d949aSAndrew Thompson 639ed6d949aSAndrew Thompson usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL); 64002ac6454SAndrew Thompson 64102ac6454SAndrew Thompson switch (USB_GET_STATE(xfer)) { 64202ac6454SAndrew Thompson case USB_ST_TRANSFERRED: 64302ac6454SAndrew Thompson 64402ac6454SAndrew Thompson if (ifp && (ifp->if_drv_flags & IFF_DRV_RUNNING) && 645ed6d949aSAndrew Thompson actlen >= sizeof(pkt)) { 64602ac6454SAndrew Thompson 647ed6d949aSAndrew Thompson pc = usbd_xfer_get_frame(xfer, 0); 648ed6d949aSAndrew Thompson usbd_copy_out(pc, 0, &pkt, sizeof(pkt)); 64902ac6454SAndrew Thompson 65002ac6454SAndrew Thompson ifp->if_ierrors += pkt.rue_rxlost_cnt; 65102ac6454SAndrew Thompson ifp->if_ierrors += pkt.rue_crcerr_cnt; 65202ac6454SAndrew Thompson ifp->if_collisions += pkt.rue_col_cnt; 65302ac6454SAndrew Thompson } 65402ac6454SAndrew Thompson /* FALLTHROUGH */ 65502ac6454SAndrew Thompson case USB_ST_SETUP: 65602ac6454SAndrew Thompson tr_setup: 657ed6d949aSAndrew Thompson usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer)); 658a593f6b8SAndrew Thompson usbd_transfer_submit(xfer); 65902ac6454SAndrew Thompson return; 66002ac6454SAndrew Thompson 66102ac6454SAndrew Thompson default: /* Error */ 662ed6d949aSAndrew Thompson if (error != USB_ERR_CANCELLED) { 66302ac6454SAndrew Thompson /* try to clear stall first */ 664ed6d949aSAndrew Thompson usbd_xfer_set_stall(xfer); 66502ac6454SAndrew Thompson goto tr_setup; 66602ac6454SAndrew Thompson } 66702ac6454SAndrew Thompson return; 66802ac6454SAndrew Thompson } 66902ac6454SAndrew Thompson } 67002ac6454SAndrew Thompson 67102ac6454SAndrew Thompson static void 672ed6d949aSAndrew Thompson rue_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error) 67302ac6454SAndrew Thompson { 674ed6d949aSAndrew Thompson struct rue_softc *sc = usbd_xfer_softc(xfer); 675760bc48eSAndrew Thompson struct usb_ether *ue = &sc->sc_ue; 676a593f6b8SAndrew Thompson struct ifnet *ifp = uether_getifp(ue); 677ed6d949aSAndrew Thompson struct usb_page_cache *pc; 67802ac6454SAndrew Thompson uint16_t status; 679ed6d949aSAndrew Thompson int actlen; 680ed6d949aSAndrew Thompson 681ed6d949aSAndrew Thompson usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL); 68202ac6454SAndrew Thompson 68302ac6454SAndrew Thompson switch (USB_GET_STATE(xfer)) { 68402ac6454SAndrew Thompson case USB_ST_TRANSFERRED: 68502ac6454SAndrew Thompson 686ed6d949aSAndrew Thompson if (actlen < 4) { 68702ac6454SAndrew Thompson ifp->if_ierrors++; 68802ac6454SAndrew Thompson goto tr_setup; 68902ac6454SAndrew Thompson } 690ed6d949aSAndrew Thompson pc = usbd_xfer_get_frame(xfer, 0); 691ed6d949aSAndrew Thompson usbd_copy_out(pc, actlen - 4, &status, sizeof(status)); 692ed6d949aSAndrew Thompson actlen -= 4; 69302ac6454SAndrew Thompson 69402ac6454SAndrew Thompson /* check recieve packet was valid or not */ 69502ac6454SAndrew Thompson status = le16toh(status); 69602ac6454SAndrew Thompson if ((status & RUE_RXSTAT_VALID) == 0) { 69702ac6454SAndrew Thompson ifp->if_ierrors++; 69802ac6454SAndrew Thompson goto tr_setup; 69902ac6454SAndrew Thompson } 700ed6d949aSAndrew Thompson uether_rxbuf(ue, pc, 0, actlen); 70102ac6454SAndrew Thompson /* FALLTHROUGH */ 70202ac6454SAndrew Thompson case USB_ST_SETUP: 70302ac6454SAndrew Thompson tr_setup: 704ed6d949aSAndrew Thompson usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer)); 705a593f6b8SAndrew Thompson usbd_transfer_submit(xfer); 706a593f6b8SAndrew Thompson uether_rxflush(ue); 70702ac6454SAndrew Thompson return; 70802ac6454SAndrew Thompson 70902ac6454SAndrew Thompson default: /* Error */ 71002ac6454SAndrew Thompson DPRINTF("bulk read error, %s\n", 711ed6d949aSAndrew Thompson usbd_errstr(error)); 71202ac6454SAndrew Thompson 713ed6d949aSAndrew Thompson if (error != USB_ERR_CANCELLED) { 71402ac6454SAndrew Thompson /* try to clear stall first */ 715ed6d949aSAndrew Thompson usbd_xfer_set_stall(xfer); 71602ac6454SAndrew Thompson goto tr_setup; 71702ac6454SAndrew Thompson } 71802ac6454SAndrew Thompson return; 71902ac6454SAndrew Thompson } 72002ac6454SAndrew Thompson } 72102ac6454SAndrew Thompson 72202ac6454SAndrew Thompson static void 723ed6d949aSAndrew Thompson rue_bulk_write_callback(struct usb_xfer *xfer, usb_error_t error) 72402ac6454SAndrew Thompson { 725ed6d949aSAndrew Thompson struct rue_softc *sc = usbd_xfer_softc(xfer); 726a593f6b8SAndrew Thompson struct ifnet *ifp = uether_getifp(&sc->sc_ue); 727ed6d949aSAndrew Thompson struct usb_page_cache *pc; 72802ac6454SAndrew Thompson struct mbuf *m; 72902ac6454SAndrew Thompson int temp_len; 73002ac6454SAndrew Thompson 73102ac6454SAndrew Thompson switch (USB_GET_STATE(xfer)) { 73202ac6454SAndrew Thompson case USB_ST_TRANSFERRED: 73302ac6454SAndrew Thompson DPRINTFN(11, "transfer complete\n"); 73402ac6454SAndrew Thompson ifp->if_opackets++; 73502ac6454SAndrew Thompson 73602ac6454SAndrew Thompson /* FALLTHROUGH */ 73702ac6454SAndrew Thompson case USB_ST_SETUP: 73802ac6454SAndrew Thompson tr_setup: 73902ac6454SAndrew Thompson if ((sc->sc_flags & RUE_FLAG_LINK) == 0) { 74002ac6454SAndrew Thompson /* 74102ac6454SAndrew Thompson * don't send anything if there is no link ! 74202ac6454SAndrew Thompson */ 74302ac6454SAndrew Thompson return; 74402ac6454SAndrew Thompson } 74502ac6454SAndrew Thompson IFQ_DRV_DEQUEUE(&ifp->if_snd, m); 74602ac6454SAndrew Thompson 74702ac6454SAndrew Thompson if (m == NULL) 74802ac6454SAndrew Thompson return; 74902ac6454SAndrew Thompson if (m->m_pkthdr.len > MCLBYTES) 75002ac6454SAndrew Thompson m->m_pkthdr.len = MCLBYTES; 75102ac6454SAndrew Thompson temp_len = m->m_pkthdr.len; 75202ac6454SAndrew Thompson 753ed6d949aSAndrew Thompson pc = usbd_xfer_get_frame(xfer, 0); 754ed6d949aSAndrew Thompson usbd_m_copy_in(pc, 0, m, 0, m->m_pkthdr.len); 75502ac6454SAndrew Thompson 75602ac6454SAndrew Thompson /* 75702ac6454SAndrew Thompson * This is an undocumented behavior. 75802ac6454SAndrew Thompson * RTL8150 chip doesn't send frame length smaller than 75902ac6454SAndrew Thompson * RUE_MIN_FRAMELEN (60) byte packet. 76002ac6454SAndrew Thompson */ 76102ac6454SAndrew Thompson if (temp_len < RUE_MIN_FRAMELEN) { 762ed6d949aSAndrew Thompson usbd_frame_zero(pc, temp_len, 76302ac6454SAndrew Thompson RUE_MIN_FRAMELEN - temp_len); 76402ac6454SAndrew Thompson temp_len = RUE_MIN_FRAMELEN; 76502ac6454SAndrew Thompson } 766ed6d949aSAndrew Thompson usbd_xfer_set_frame_len(xfer, 0, temp_len); 76702ac6454SAndrew Thompson 76802ac6454SAndrew Thompson /* 76902ac6454SAndrew Thompson * if there's a BPF listener, bounce a copy 77002ac6454SAndrew Thompson * of this frame to him: 77102ac6454SAndrew Thompson */ 77202ac6454SAndrew Thompson BPF_MTAP(ifp, m); 77302ac6454SAndrew Thompson 77402ac6454SAndrew Thompson m_freem(m); 77502ac6454SAndrew Thompson 776a593f6b8SAndrew Thompson usbd_transfer_submit(xfer); 77702ac6454SAndrew Thompson 77802ac6454SAndrew Thompson return; 77902ac6454SAndrew Thompson 78002ac6454SAndrew Thompson default: /* Error */ 78102ac6454SAndrew Thompson DPRINTFN(11, "transfer error, %s\n", 782ed6d949aSAndrew Thompson usbd_errstr(error)); 78302ac6454SAndrew Thompson 78402ac6454SAndrew Thompson ifp->if_oerrors++; 78502ac6454SAndrew Thompson 786ed6d949aSAndrew Thompson if (error != USB_ERR_CANCELLED) { 78702ac6454SAndrew Thompson /* try to clear stall first */ 788ed6d949aSAndrew Thompson usbd_xfer_set_stall(xfer); 78902ac6454SAndrew Thompson goto tr_setup; 79002ac6454SAndrew Thompson } 79102ac6454SAndrew Thompson return; 79202ac6454SAndrew Thompson } 79302ac6454SAndrew Thompson } 79402ac6454SAndrew Thompson 79502ac6454SAndrew Thompson static void 796760bc48eSAndrew Thompson rue_tick(struct usb_ether *ue) 79702ac6454SAndrew Thompson { 798a593f6b8SAndrew Thompson struct rue_softc *sc = uether_getsc(ue); 79902ac6454SAndrew Thompson struct mii_data *mii = GET_MII(sc); 80002ac6454SAndrew Thompson 80102ac6454SAndrew Thompson RUE_LOCK_ASSERT(sc, MA_OWNED); 80202ac6454SAndrew Thompson 80302ac6454SAndrew Thompson mii_tick(mii); 80402ac6454SAndrew Thompson if ((sc->sc_flags & RUE_FLAG_LINK) == 0 80502ac6454SAndrew Thompson && mii->mii_media_status & IFM_ACTIVE && 80602ac6454SAndrew Thompson IFM_SUBTYPE(mii->mii_media_active) != IFM_NONE) { 80702ac6454SAndrew Thompson sc->sc_flags |= RUE_FLAG_LINK; 80802ac6454SAndrew Thompson rue_start(ue); 80902ac6454SAndrew Thompson } 81002ac6454SAndrew Thompson } 81102ac6454SAndrew Thompson 81202ac6454SAndrew Thompson static void 813760bc48eSAndrew Thompson rue_start(struct usb_ether *ue) 81402ac6454SAndrew Thompson { 815a593f6b8SAndrew Thompson struct rue_softc *sc = uether_getsc(ue); 81602ac6454SAndrew Thompson 81702ac6454SAndrew Thompson /* 81802ac6454SAndrew Thompson * start the USB transfers, if not already started: 81902ac6454SAndrew Thompson */ 820a593f6b8SAndrew Thompson usbd_transfer_start(sc->sc_xfer[RUE_INTR_DT_RD]); 821a593f6b8SAndrew Thompson usbd_transfer_start(sc->sc_xfer[RUE_BULK_DT_RD]); 822a593f6b8SAndrew Thompson usbd_transfer_start(sc->sc_xfer[RUE_BULK_DT_WR]); 82302ac6454SAndrew Thompson } 82402ac6454SAndrew Thompson 82502ac6454SAndrew Thompson static void 826760bc48eSAndrew Thompson rue_init(struct usb_ether *ue) 82702ac6454SAndrew Thompson { 828a593f6b8SAndrew Thompson struct rue_softc *sc = uether_getsc(ue); 829a593f6b8SAndrew Thompson struct ifnet *ifp = uether_getifp(ue); 83002ac6454SAndrew Thompson 83102ac6454SAndrew Thompson RUE_LOCK_ASSERT(sc, MA_OWNED); 83202ac6454SAndrew Thompson 83302ac6454SAndrew Thompson /* 83402ac6454SAndrew Thompson * Cancel pending I/O 83502ac6454SAndrew Thompson */ 83602ac6454SAndrew Thompson rue_reset(sc); 83702ac6454SAndrew Thompson 83802ac6454SAndrew Thompson /* Set MAC address */ 83902ac6454SAndrew Thompson rue_write_mem(sc, RUE_IDR0, IF_LLADDR(ifp), ETHER_ADDR_LEN); 84002ac6454SAndrew Thompson 84102ac6454SAndrew Thompson rue_stop(ue); 84202ac6454SAndrew Thompson 84302ac6454SAndrew Thompson /* 84402ac6454SAndrew Thompson * Set the initial TX and RX configuration. 84502ac6454SAndrew Thompson */ 84602ac6454SAndrew Thompson rue_csr_write_1(sc, RUE_TCR, RUE_TCR_CONFIG); 84702ac6454SAndrew Thompson rue_csr_write_2(sc, RUE_RCR, RUE_RCR_CONFIG|RUE_RCR_AB); 84802ac6454SAndrew Thompson 84902ac6454SAndrew Thompson /* Load the multicast filter */ 85002ac6454SAndrew Thompson rue_setpromisc(ue); 85102ac6454SAndrew Thompson /* Load the multicast filter. */ 85202ac6454SAndrew Thompson rue_setmulti(ue); 85302ac6454SAndrew Thompson 85402ac6454SAndrew Thompson /* Enable RX and TX */ 85502ac6454SAndrew Thompson rue_csr_write_1(sc, RUE_CR, (RUE_CR_TE | RUE_CR_RE | RUE_CR_EP3CLREN)); 85602ac6454SAndrew Thompson 857ed6d949aSAndrew Thompson usbd_xfer_set_stall(sc->sc_xfer[RUE_BULK_DT_WR]); 85802ac6454SAndrew Thompson 85902ac6454SAndrew Thompson ifp->if_drv_flags |= IFF_DRV_RUNNING; 86002ac6454SAndrew Thompson rue_start(ue); 86102ac6454SAndrew Thompson } 86202ac6454SAndrew Thompson 86302ac6454SAndrew Thompson /* 86402ac6454SAndrew Thompson * Set media options. 86502ac6454SAndrew Thompson */ 86602ac6454SAndrew Thompson static int 86702ac6454SAndrew Thompson rue_ifmedia_upd(struct ifnet *ifp) 86802ac6454SAndrew Thompson { 86902ac6454SAndrew Thompson struct rue_softc *sc = ifp->if_softc; 87002ac6454SAndrew Thompson struct mii_data *mii = GET_MII(sc); 8713fcb7a53SMarius Strobl struct mii_softc *miisc; 87202ac6454SAndrew Thompson 87302ac6454SAndrew Thompson RUE_LOCK_ASSERT(sc, MA_OWNED); 87402ac6454SAndrew Thompson 87502ac6454SAndrew Thompson sc->sc_flags &= ~RUE_FLAG_LINK; 87602ac6454SAndrew Thompson LIST_FOREACH(miisc, &mii->mii_phys, mii_list) 8773fcb7a53SMarius Strobl PHY_RESET(miisc); 87802ac6454SAndrew Thompson mii_mediachg(mii); 87902ac6454SAndrew Thompson return (0); 88002ac6454SAndrew Thompson } 88102ac6454SAndrew Thompson 88202ac6454SAndrew Thompson /* 88302ac6454SAndrew Thompson * Report current media status. 88402ac6454SAndrew Thompson */ 88502ac6454SAndrew Thompson static void 88602ac6454SAndrew Thompson rue_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr) 88702ac6454SAndrew Thompson { 88802ac6454SAndrew Thompson struct rue_softc *sc = ifp->if_softc; 88902ac6454SAndrew Thompson struct mii_data *mii = GET_MII(sc); 89002ac6454SAndrew Thompson 89102ac6454SAndrew Thompson RUE_LOCK(sc); 89202ac6454SAndrew Thompson mii_pollstat(mii); 89302ac6454SAndrew Thompson RUE_UNLOCK(sc); 89402ac6454SAndrew Thompson ifmr->ifm_active = mii->mii_media_active; 89502ac6454SAndrew Thompson ifmr->ifm_status = mii->mii_media_status; 89602ac6454SAndrew Thompson } 89702ac6454SAndrew Thompson 89802ac6454SAndrew Thompson static void 899760bc48eSAndrew Thompson rue_stop(struct usb_ether *ue) 90002ac6454SAndrew Thompson { 901a593f6b8SAndrew Thompson struct rue_softc *sc = uether_getsc(ue); 902a593f6b8SAndrew Thompson struct ifnet *ifp = uether_getifp(ue); 90302ac6454SAndrew Thompson 90402ac6454SAndrew Thompson RUE_LOCK_ASSERT(sc, MA_OWNED); 90502ac6454SAndrew Thompson 90602ac6454SAndrew Thompson ifp->if_drv_flags &= ~IFF_DRV_RUNNING; 90702ac6454SAndrew Thompson sc->sc_flags &= ~RUE_FLAG_LINK; 90802ac6454SAndrew Thompson 90902ac6454SAndrew Thompson /* 91002ac6454SAndrew Thompson * stop all the transfers, if not already stopped: 91102ac6454SAndrew Thompson */ 912a593f6b8SAndrew Thompson usbd_transfer_stop(sc->sc_xfer[RUE_BULK_DT_WR]); 913a593f6b8SAndrew Thompson usbd_transfer_stop(sc->sc_xfer[RUE_BULK_DT_RD]); 914a593f6b8SAndrew Thompson usbd_transfer_stop(sc->sc_xfer[RUE_INTR_DT_RD]); 91502ac6454SAndrew Thompson 91602ac6454SAndrew Thompson rue_csr_write_1(sc, RUE_CR, 0x00); 91702ac6454SAndrew Thompson 91802ac6454SAndrew Thompson rue_reset(sc); 91902ac6454SAndrew Thompson } 920