From owner-svn-src-all@freebsd.org Mon May 28 21:00:18 2018 Return-Path: Delivered-To: svn-src-all@mailman.ysv.freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2610:1c1:1:606c::19:1]) by mailman.ysv.freebsd.org (Postfix) with ESMTP id 6581BEEF8F8; Mon, 28 May 2018 21:00:18 +0000 (UTC) (envelope-from ronald-lists@klop.ws) Received: from smarthost1.greenhost.nl (smarthost1.greenhost.nl [195.190.28.92]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (Client did not present a certificate) by mx1.freebsd.org (Postfix) with ESMTPS id B756486A25; Mon, 28 May 2018 21:00:17 +0000 (UTC) (envelope-from ronald-lists@klop.ws) Received: from smtp.greenhost.nl ([213.108.110.112]) by smarthost1.greenhost.nl with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.84_2) (envelope-from ) id 1fNPFV-0000d1-It; Mon, 28 May 2018 23:00:16 +0200 Content-Type: text/plain; charset=utf-8; format=flowed; delsp=yes To: src-committers@freebsd.org, svn-src-all@freebsd.org, svn-src-head@freebsd.org, "Ed Maste" Subject: Re: svn commit: r333713 - in head/sys: dev/usb/net modules/usb/muge References: <201805171405.w4HE50pg052669@repo.freebsd.org> Date: Mon, 28 May 2018 23:00:17 +0200 MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: "Ronald Klop" Message-ID: In-Reply-To: <201805171405.w4HE50pg052669@repo.freebsd.org> User-Agent: Opera Mail/12.16 (FreeBSD) X-Authenticated-As-Hash: 398f5522cb258ce43cb679602f8cfe8b62a256d1 X-Virus-Scanned: by clamav at smarthost1.samage.net X-Spam-Level: ++ X-Spam-Score: 2.5 X-Spam-Status: No, score=2.5 required=5.0 tests=ALL_TRUSTED, BAYES_99 autolearn=disabled version=3.4.0 X-Scan-Signature: 14ebef1324bd6128eaf48fef81dc9d3b X-BeenThere: svn-src-all@freebsd.org X-Mailman-Version: 2.1.26 Precedence: list List-Id: "SVN commit messages for the entire src tree \(except for " user" and " projects" \)" List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Mon, 28 May 2018 21:00:18 -0000 The addition of this driver made me finally buy a RPI3B+. Thanks a lot! Regards, Ronald. On Thu, 17 May 2018 16:05:00 +0200, Ed Maste wrote: > Author: emaste > Date: Thu May 17 14:04:59 2018 > New Revision: 333713 > URL: https://svnweb.freebsd.org/changeset/base/333713 > > Log: > Add driver for Microchip LAN78xx USB3-GigE controller > This driver supports two Microchip USB-Ethernet controllers: > LAN7800 USB 3.1 to 10/100/1000 Mbps Ethernet > LAN7515 USB 2 to 10/100/1000 Mbps Ethernet with built-in USB hub > The LAN7515 is the Ethernet controller on the Raspberry Pi 3B+. > At present there is no datasheet for the LAN7515, but it is effectively > a USB 2 hub combined with a LAN7800 controller. A comprehensive > LAN7800 > datasheet is at http://www.microchip.com/wwwproducts/en/LAN7800. > This driver is based on the structure of the smsc(4) driver which > supports Microchip/SMSC's LAN95xx family. (Microchip acquired SMSC > in May 2012.) The Linux lan78xx driver served as a reference for some > functionality and registers. > The 'muge' driver name comes from "Microchip USB Gigabit Ethernet". > I made some style adjustments and minor edits to Arshan's submission. > It will be connected to the build after additional review and testing. > Thanks to Microchip for providing a number of Evaluation Boards (EVBs) > for development and testing. > Submitted by: Arshan Khanifar > Reviewed by: hselasky (earlier) > Sponsored by: The FreeBSD Foundation > Differential Revision: https://reviews.freebsd.org/D15168 > > Added: > head/sys/dev/usb/net/if_muge.c (contents, props changed) > head/sys/dev/usb/net/if_mugereg.h (contents, props changed) > head/sys/modules/usb/muge/ > head/sys/modules/usb/muge/Makefile (contents, props changed) > > Added: head/sys/dev/usb/net/if_muge.c > ============================================================================== > --- /dev/null 00:00:00 1970 (empty, because file is newly added) > +++ head/sys/dev/usb/net/if_muge.c Thu May 17 14:04:59 2018 (r333713) > @@ -0,0 +1,2199 @@ > +/*- > + * SPDX-License-Identifier: BSD-2-Clause-FreeBSD > + * > + * Copyright (C) 2012 Ben Gray . > + * Copyright (C) 2018 The FreeBSD Foundation. > + * > + * This software was developed by Arshan Khanifar > > + * under sponsorship from the FreeBSD Foundation. > + * > + * Redistribution and use in source and binary forms, with or without > + * modification, are permitted provided that the following conditions > + * are met: > + * 1. Redistributions of source code must retain the above copyright > + * notice, this list of conditions and the following disclaimer. > + * 2. Redistributions in binary form must reproduce the above copyright > + * notice, this list of conditions and the following disclaimer in > the > + * documentation and/or other materials provided with the > distribution. > + * > + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' > AND > + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE > + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR > PURPOSE > + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE > LIABLE > + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR > CONSEQUENTIAL > + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE > GOODS > + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) > + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, > STRICT > + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN > ANY WAY > + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY > OF > + * SUCH DAMAGE. > + * > + * $FreeBSD$ > + */ > + > +#include > +__FBSDID("$FreeBSD$"); > + > +/* > + * USB-To-Ethernet adapter driver for Microchip's LAN78XX and related > families. > + * > + * USB 3.1 to 10/100/1000 Mbps Ethernet > + * LAN7800 http://www.microchip.com/wwwproducts/en/LAN7800 > + * > + * USB 2 to 10/100/1000 Mbps Ethernet with built-in USB hub > + * LAN7515 (no datasheet available, but probes and functions as LAN7800) > + * > + * This driver is based on the if_smsc driver, with lan78xx-specific > + * functionality modelled on Microchip's Linux lan78xx driver. > + * > + * UNIMPLEMENTED FEATURES > + * ------------------ > + * A number of features supported by the lan78xx are not yet > implemented in > + * this driver: > + * > + * 1. RX/TX checksum offloading: Nothing has been implemented yet for > + * TX checksumming. RX checksumming works with ICMP messages, but is > broken > + * for TCP/UDP packets. > + * 2. Direct address translation filtering: Implemented but untested. > + * 3. VLAN tag removal. > + * 4. Reading MAC address from the device tree: Specific to the RPi 3B+. > + * Currently, the driver assigns a random MAC address itself. > + * 5. Support for USB interrupt endpoints. > + * 6. Latency Tolerance Messaging (LTM) support. > + * 7. TCP LSO support. > + * > + */ > + > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > + > +#include > +#include > + > +#include > +#include > + > +#include "opt_platform.h" > + > +#include > +#include > +#include > +#include "usbdevs.h" > + > +#define USB_DEBUG_VAR lan78xx_debug > +#include > +#include > + > +#include > + > +#include > + > +#ifdef USB_DEBUG > +static int muge_debug = 0; > + > +SYSCTL_NODE(_hw_usb, OID_AUTO, muge, CTLFLAG_RW, 0, > + "Microchip LAN78xx USB-GigE"); > +SYSCTL_INT(_hw_usb_muge, OID_AUTO, debug, CTLFLAG_RWTUN, &muge_debug, 0, > + "Debug level"); > +#endif > + > +#define MUGE_DEFAULT_RX_CSUM_ENABLE (false) > +#define MUGE_DEFAULT_TX_CSUM_ENABLE (false) > +#define MUGE_DEFAULT_TSO_CSUM_ENABLE (false) > + > +/* Supported Vendor and Product IDs. */ > +static const struct usb_device_id lan78xx_devs[] = { > +#define MUGE_DEV(p,i) { USB_VPI(USB_VENDOR_SMC2, USB_PRODUCT_SMC2_##p, > i) } > + MUGE_DEV(LAN7800_ETH, 0), > +#undef MUGE_DEV > +}; > + > +#ifdef USB_DEBUG > +#define lan78xx_dbg_printf(sc, fmt, args...) \ > +do { \ > + if (muge_debug > 0) \ > + device_printf((sc)->sc_ue.ue_dev, "debug: " fmt, ##args); \ > +} while(0) > +#else > +#define muge_dbg_printf(sc, fmt, args...) do { } while (0) > +#endif > + > +#define muge_warn_printf(sc, fmt, args...) \ > + device_printf((sc)->sc_ue.ue_dev, "warning: " fmt, ##args) > + > +#define muge_err_printf(sc, fmt, args...) \ > + device_printf((sc)->sc_ue.ue_dev, "error: " fmt, ##args) > + > +#define ETHER_IS_ZERO(addr) \ > + (!(addr[0] | addr[1] | addr[2] | addr[3] | addr[4] | addr[5])) > + > +#define ETHER_IS_VALID(addr) \ > + (!ETHER_IS_MULTICAST(addr) && !ETHER_IS_ZERO(addr)) > + > +/* USB endpoints. */ > + > +enum { > + MUGE_BULK_DT_RD, > + MUGE_BULK_DT_WR, > + /* > + * the device does support interrupt endpoints, > + * but they're not needed as we poll on MII status. > + * MUGE_INTR_DT_WR, > + * MUGE_INTR_DT_RD, > + */ > + MUGE_N_TRANSFER, > +}; > + > +struct muge_softc { > + struct usb_ether sc_ue; > + struct mtx sc_mtx; > + struct usb_xfer *sc_xfer[MUGE_N_TRANSFER]; > + int sc_phyno; > + > + /* Settings for the mac control (MAC_CSR) register. */ > + uint32_t sc_rfe_ctl; > + uint32_t sc_mdix_ctl; > + uint32_t sc_rev_id; > + uint32_t sc_mchash_table[DP_SEL_VHF_HASH_LEN]; > + uint32_t sc_pfilter_table[MUGE_NUM_PFILTER_ADDRS_][2]; > + > + uint32_t sc_flags; > +#define MUGE_FLAG_LINK 0x0001 > +}; > + > +#define MUGE_IFACE_IDX 0 > + > +#define MUGE_LOCK(_sc) mtx_lock(&(_sc)->sc_mtx) > +#define MUGE_UNLOCK(_sc) mtx_unlock(&(_sc)->sc_mtx) > +#define MUGE_LOCK_ASSERT(_sc, t) mtx_assert(&(_sc)->sc_mtx, t) > + > + > +static device_probe_t muge_probe; > +static device_attach_t muge_attach; > +static device_detach_t muge_detach; > + > +static usb_callback_t muge_bulk_read_callback; > +static usb_callback_t muge_bulk_write_callback; > + > +static miibus_readreg_t lan78xx_miibus_readreg; > +static miibus_writereg_t lan78xx_miibus_writereg; > +static miibus_statchg_t lan78xx_miibus_statchg; > + > +static int muge_attach_post_sub(struct usb_ether *ue); > +static uether_fn_t muge_attach_post; > +static uether_fn_t muge_init; > +static uether_fn_t muge_stop; > +static uether_fn_t muge_start; > +static uether_fn_t muge_tick; > +static uether_fn_t muge_setmulti; > +static uether_fn_t muge_setpromisc; > + > +static int muge_ifmedia_upd(struct ifnet *); > +static void muge_ifmedia_sts(struct ifnet *, struct ifmediareq *); > + > +static int lan78xx_chip_init(struct muge_softc *sc); > +static int muge_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data); > + > +static const struct usb_config muge_config[MUGE_N_TRANSFER] = { > + > + [MUGE_BULK_DT_WR] = { > + .type = UE_BULK, > + .endpoint = UE_ADDR_ANY, > + .direction = UE_DIR_OUT, > + .frames = 16, > + .bufsize = 16 * (MCLBYTES + 16), > + .flags = {.pipe_bof = 1,.force_short_xfer = 1,}, > + .callback = muge_bulk_write_callback, > + .timeout = 10000, /* 10 seconds */ > + }, > + > + [MUGE_BULK_DT_RD] = { > + .type = UE_BULK, > + .endpoint = UE_ADDR_ANY, > + .direction = UE_DIR_IN, > + .bufsize = 20480, /* bytes */ > + .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, > + .callback = muge_bulk_read_callback, > + .timeout = 0, /* no timeout */ > + }, > + /* > + * The chip supports interrupt endpoints, however they aren't > + * needed as we poll on the MII status. > + */ > +}; > + > +static const struct usb_ether_methods muge_ue_methods = { > + .ue_attach_post = muge_attach_post, > + .ue_attach_post_sub = muge_attach_post_sub, > + .ue_start = muge_start, > + .ue_ioctl = muge_ioctl, > + .ue_init = muge_init, > + .ue_stop = muge_stop, > + .ue_tick = muge_tick, > + .ue_setmulti = muge_setmulti, > + .ue_setpromisc = muge_setpromisc, > + .ue_mii_upd = muge_ifmedia_upd, > + .ue_mii_sts = muge_ifmedia_sts, > +}; > + > +/** > + * lan78xx_read_reg - Read a 32-bit register on the device > + * @sc: driver soft context > + * @off: offset of the register > + * @data: pointer a value that will be populated with the register value > + * > + * LOCKING: > + * The device lock must be held before calling this function. > + * > + * RETURNS: > + * 0 on success, a USB_ERR_?? error code on failure. > + */ > +static int > +lan78xx_read_reg(struct muge_softc *sc, uint32_t off, uint32_t *data) > +{ > + struct usb_device_request req; > + uint32_t buf; > + usb_error_t err; > + > + MUGE_LOCK_ASSERT(sc, MA_OWNED); > + > + req.bmRequestType = UT_READ_VENDOR_DEVICE; > + req.bRequest = UVR_READ_REG; > + USETW(req.wValue, 0); > + USETW(req.wIndex, off); > + USETW(req.wLength, 4); > + > + err = uether_do_request(&sc->sc_ue, &req, &buf, 1000); > + if (err != 0) > + muge_warn_printf(sc, "Failed to read register 0x%0x\n", off); > + *data = le32toh(buf); > + return (err); > +} > + > +/** > + * lan78xx_write_reg - Write a 32-bit register on the device > + * @sc: driver soft context > + * @off: offset of the register > + * @data: the 32-bit value to write into the register > + * > + * LOCKING: > + * The device lock must be held before calling this function. > + * > + * RETURNS: > + * 0 on success, a USB_ERR_?? error code on failure. > + */ > +static int > +lan78xx_write_reg(struct muge_softc *sc, uint32_t off, uint32_t data) > +{ > + struct usb_device_request req; > + uint32_t buf; > + usb_error_t err; > + > + MUGE_LOCK_ASSERT(sc, MA_OWNED); > + > + buf = htole32(data); > + > + req.bmRequestType = UT_WRITE_VENDOR_DEVICE; > + req.bRequest = UVR_WRITE_REG; > + USETW(req.wValue, 0); > + USETW(req.wIndex, off); > + USETW(req.wLength, 4); > + > + err = uether_do_request(&sc->sc_ue, &req, &buf, 1000); > + if (err != 0) > + muge_warn_printf(sc, "Failed to write register 0x%0x\n", off); > + return (err); > +} > + > +/** > + * lan78xx_wait_for_bits - Poll on a register value until bits are > cleared > + * @sc: soft context > + * @reg: offset of the register > + * @bits: if the bits are clear the function returns > + * > + * LOCKING: > + * The device lock must be held before calling this function. > + * > + * RETURNS: > + * 0 on success, or a USB_ERR_?? error code on failure. > + */ > +static int > +lan78xx_wait_for_bits(struct muge_softc *sc, uint32_t reg, uint32_t > bits) > +{ > + usb_ticks_t start_ticks; > + const usb_ticks_t max_ticks = USB_MS_TO_TICKS(1000); > + uint32_t val; > + int err; > + > + MUGE_LOCK_ASSERT(sc, MA_OWNED); > + > + start_ticks = (usb_ticks_t)ticks; > + do { > + if ((err = lan78xx_read_reg(sc, reg, &val)) != 0) > + return (err); > + if (!(val & bits)) > + return (0); > + uether_pause(&sc->sc_ue, hz / 100); > + } while (((usb_ticks_t)(ticks - start_ticks)) < max_ticks); > + > + return (USB_ERR_TIMEOUT); > +} > + > +/** > + * lan78xx_eeprom_read_raw - Read the attached EEPROM > + * @sc: soft context > + * @off: the eeprom address offset > + * @buf: stores the bytes > + * @buflen: the number of bytes to read > + * > + * Simply reads bytes from an attached eeprom. > + * > + * LOCKING: > + * The function takes and releases the device lock if not already held. > + * > + * RETURNS: > + * 0 on success, or a USB_ERR_?? error code on failure. > + */ > +static int > +lan78xx_eeprom_read_raw(struct muge_softc *sc, uint16_t off, uint8_t > *buf, > + uint16_t buflen) > +{ > + usb_ticks_t start_ticks; > + const usb_ticks_t max_ticks = USB_MS_TO_TICKS(1000); > + int err, locked; > + uint32_t val, saved; > + uint16_t i; > + > + locked = mtx_owned(&sc->sc_mtx); /* XXX */ > + if (!locked) > + MUGE_LOCK(sc); > + > + err = lan78xx_read_reg(sc, HW_CFG, &val); > + saved = val; > + > + val &= ~(HW_CFG_LEDO_EN_ | HW_CFG_LED1_EN_); > + err = lan78xx_write_reg(sc, HW_CFG, val); > + > + err = lan78xx_wait_for_bits(sc, E2P_CMD, E2P_CMD_BUSY_); > + if (err != 0) { > + muge_warn_printf(sc, "eeprom busy, failed to read data\n"); > + goto done; > + } > + > + /* Start reading the bytes, one at a time. */ > + for (i = 0; i < buflen; i++) { > + val = E2P_CMD_BUSY_ | E2P_CMD_READ_; > + val |= (E2P_CMD_ADDR_MASK_ & (off + i)); > + if ((err = lan78xx_write_reg(sc, E2P_CMD, val)) != 0) > + goto done; > + > + start_ticks = (usb_ticks_t)ticks; > + do { > + if ((err = lan78xx_read_reg(sc, E2P_CMD, &val)) != 0) > + goto done; > + if (!(val & E2P_CMD_BUSY_) || (val & E2P_CMD_TIMEOUT_)) > + break; > + > + uether_pause(&sc->sc_ue, hz / 100); > + } while (((usb_ticks_t)(ticks - start_ticks)) < max_ticks); > + > + if (val & (E2P_CMD_BUSY_ | E2P_CMD_TIMEOUT_)) { > + muge_warn_printf(sc, "eeprom command failed\n"); > + err = USB_ERR_IOERROR; > + break; > + } > + > + if ((err = lan78xx_read_reg(sc, E2P_DATA, &val)) != 0) > + goto done; > + > + buf[i] = (val & 0xff); > + } > + > +done: > + if (!locked) > + MUGE_UNLOCK(sc); > + lan78xx_write_reg(sc, HW_CFG, saved); > + return (err); > +} > + > +/** > + * lan78xx_eeprom_read - Read EEPROM and confirm it is programmed > + * @sc: soft context > + * @off: the eeprom address offset > + * @buf: stores the bytes > + * @buflen: the number of bytes to read > + * > + * RETURNS: > + * 0 on success, or a USB_ERR_?? error code on failure. > + */ > +static int > +lan78xx_eeprom_read(struct muge_softc *sc, uint16_t off, uint8_t *buf, > + uint16_t buflen) > +{ > + uint8_t sig; > + int ret; > + > + ret = lan78xx_eeprom_read_raw(sc, E2P_INDICATOR_OFFSET, &sig, 1); > + if ((ret == 0) && (sig == E2P_INDICATOR)) { > + ret = lan78xx_eeprom_read_raw(sc, off, buf, buflen); > + muge_dbg_printf(sc, "EEPROM present\n"); > + } else { > + ret = -EINVAL; > + muge_dbg_printf(sc, "EEPROM not present\n"); > + } > + return ret; > +} > + > +/** > + * lan78xx_otp_read_raw > + * @sc: soft context > + * @off: the otp address offset > + * @buf: stores the bytes > + * @buflen: the number of bytes to read > + * > + * Simply reads bytes from the OTP. > + * > + * LOCKING: > + * The function takes and releases the device lock if not already held. > + * > + * RETURNS: > + * 0 on success, or a USB_ERR_?? error code on failure. > + * > + */ > +static int > +lan78xx_otp_read_raw(struct muge_softc *sc, uint16_t off, uint8_t *buf, > + uint16_t buflen) > +{ > + int locked, err; > + uint32_t val; > + uint16_t i; > + locked = mtx_owned(&sc->sc_mtx); > + if (!locked) > + MUGE_LOCK(sc); > + > + err = lan78xx_read_reg(sc, OTP_PWR_DN, &val); > + > + /* checking if bit is set */ > + if (val & OTP_PWR_DN_PWRDN_N) { > + /* clearing it, then waiting for it to be cleared */ > + lan78xx_write_reg(sc, OTP_PWR_DN, 0); > + err = lan78xx_wait_for_bits(sc, OTP_PWR_DN, OTP_PWR_DN_PWRDN_N); > + if (err != 0) { > + muge_warn_printf(sc, "OTP off? failed to read data\n"); > + goto done; > + } > + } > + /* start reading the bytes, one at a time */ > + for (i = 0; i < buflen; i++) { > + err = lan78xx_write_reg(sc, OTP_ADDR1, > + ((off + i) >> 8) & OTP_ADDR1_15_11); > + err = lan78xx_write_reg(sc, OTP_ADDR2, > + ((off + i) & OTP_ADDR2_10_3)); > + err = lan78xx_write_reg(sc, OTP_FUNC_CMD, OTP_FUNC_CMD_READ_); > + err = lan78xx_write_reg(sc, OTP_CMD_GO, OTP_CMD_GO_GO_); > + > + err = lan78xx_wait_for_bits(sc, OTP_STATUS, OTP_STATUS_BUSY_); > + if (err != 0) { > + muge_warn_printf(sc, "OTP busy failed to read data\n"); > + goto done; > + } > + > + if ((err = lan78xx_read_reg(sc, OTP_RD_DATA, &val)) != 0) > + goto done; > + > + buf[i] = (uint8_t)(val & 0xff); > + } > + > +done: > + if (!locked) > + MUGE_UNLOCK(sc); > + return (err); > +} > + > +/** > + * lan78xx_otp_read > + * @sc: soft context > + * @off: the otp address offset > + * @buf: stores the bytes > + * @buflen: the number of bytes to read > + * > + * Simply reads bytes from the otp. > + * > + * LOCKING: > + * The function takes and releases device lock if it is not already > held. > + * > + * RETURNS: > + * 0 on success, or a USB_ERR_?? error code on failure. > + */ > +static int > +lan78xx_otp_read(struct muge_softc *sc, uint16_t off, uint8_t *buf, > + uint16_t buflen) > +{ > + uint8_t sig; > + int err; > + > + err = lan78xx_otp_read_raw(sc, OTP_INDICATOR_OFFSET, &sig, 1); > + if (err == 0) { > + if (sig == OTP_INDICATOR_1) { > + } else if (sig == OTP_INDICATOR_2) { > + off += 0x100; > + } else { > + err = -EINVAL; > + } > + if(!err) > + err = lan78xx_otp_read_raw(sc, off, buf, buflen); > + } > + return err; > +} > + > +/** > + * lan78xx_setmacaddress - Set the mac address in the device > + * @sc: driver soft context > + * @addr: pointer to array contain at least 6 bytes of the mac > + * > + * LOCKING: > + * Should be called with the MUGE lock held. > + * > + * RETURNS: > + * Returns 0 on success or a negative error code. > + */ > +static int > +lan78xx_setmacaddress(struct muge_softc *sc, const uint8_t *addr) > +{ > + int err; > + uint32_t val; > + > + muge_dbg_printf(sc, > + "setting mac address to %02x:%02x:%02x:%02x:%02x:%02x\n", > + addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]); > + > + MUGE_LOCK_ASSERT(sc, MA_OWNED); > + > + val = (addr[3] << 24) | (addr[2] << 16) | (addr[1] << 8) | addr[0]; > + if ((err = lan78xx_write_reg(sc, RX_ADDRL, val)) != 0) > + goto done; > + > + val = (addr[5] << 8) | addr[4]; > + err = lan78xx_write_reg(sc, RX_ADDRH, val); > + > +done: > + return (err); > +} > + > +/** > + * lan78xx_set_rx_max_frame_length > + * @sc: driver soft context > + * @size: pointer to array contain at least 6 bytes of the mac > + * > + * Sets the maximum frame length to be received. Frames bigger than > + * this size are aborted. > + * > + * RETURNS: > + * Returns 0 on success or a negative error code. > + */ > +static int > +lan78xx_set_rx_max_frame_length(struct muge_softc *sc, int size) > +{ > + int err = 0; > + uint32_t buf; > + bool rxenabled; > + > + /* first we have to disable rx before changing the length */ > + > + err = lan78xx_read_reg(sc, MAC_RX, &buf); > + rxenabled = ((buf & MAC_RX_EN_) != 0); > + > + if (rxenabled) { > + buf &= ~MAC_RX_EN_; > + err = lan78xx_write_reg(sc, MAC_RX, buf); > + } > + > + /* setting max frame length */ > + > + buf &= ~MAC_RX_MAX_FR_SIZE_MASK_; > + buf |= (((size + 4) << MAC_RX_MAX_FR_SIZE_SHIFT_) & > + MAC_RX_MAX_FR_SIZE_MASK_); > + err = lan78xx_write_reg(sc, MAC_RX, buf); > + > + /* If it were enabled before, we enable it back. */ > + > + if (rxenabled) { > + buf |= MAC_RX_EN_; > + err = lan78xx_write_reg(sc, MAC_RX, buf); > + } > + > + return 0; > +} > + > +/** > + * lan78xx_miibus_readreg - Read a MII/MDIO register > + * @dev: usb ether device > + * @phy: the number of phy reading from > + * @reg: the register address > + * > + * LOCKING: > + * Takes and releases the device mutex lock if not already held. > + * > + * RETURNS: > + * Returns the 16-bits read from the MII register, if this function > fails > + * 0 is returned. > + */ > +static int > +lan78xx_miibus_readreg(device_t dev, int phy, int reg) { > + > + struct muge_softc *sc = device_get_softc(dev); > + int locked; > + uint32_t addr, val; > + > + val = 0; > + locked = mtx_owned(&sc->sc_mtx); > + if (!locked) > + MUGE_LOCK(sc); > + > + if (lan78xx_wait_for_bits(sc, MII_ACCESS, MII_BUSY_) != 0) { > + muge_warn_printf(sc, "MII is busy\n"); > + goto done; > + } > + > + addr = (phy << 11) | (reg << 6) | MII_READ_ | MII_BUSY_; > + lan78xx_write_reg(sc, MII_ACCESS, addr); > + > + if (lan78xx_wait_for_bits(sc, MII_ACCESS, MII_BUSY_) != 0) { > + muge_warn_printf(sc, "MII read timeout\n"); > + goto done; > + } > + > + lan78xx_read_reg(sc, MII_DATA, &val); > + val = le32toh(val); > + > +done: > + if (!locked) > + MUGE_UNLOCK(sc); > + > + return (val & 0xFFFF); > +} > + > +/** > + * lan78xx_miibus_writereg - Writes a MII/MDIO register > + * @dev: usb ether device > + * @phy: the number of phy writing to > + * @reg: the register address > + * @val: the value to write > + * > + * Attempts to write a PHY register through the usb controller > registers. > + * > + * LOCKING: > + * Takes and releases the device mutex lock if not already held. > + * > + * RETURNS: > + * Always returns 0 regardless of success or failure. > + */ > +static int > +lan78xx_miibus_writereg(device_t dev, int phy, int reg, int val) > +{ > + struct muge_softc *sc = device_get_softc(dev); > + int locked; > + uint32_t addr; > + > + if (sc->sc_phyno != phy) > + return (0); > + > + locked = mtx_owned(&sc->sc_mtx); > + if (!locked) > + MUGE_LOCK(sc); > + > + if (lan78xx_wait_for_bits(sc, MII_ACCESS, MII_BUSY_) != 0) { > + muge_warn_printf(sc, "MII is busy\n"); > + goto done; > + } > + > + val = htole32(val); > + lan78xx_write_reg(sc, MII_DATA, val); > + > + addr = (phy << 11) | (reg << 6) | MII_WRITE_ | MII_BUSY_; > + lan78xx_write_reg(sc, MII_ACCESS, addr); > + > + if (lan78xx_wait_for_bits(sc, MII_ACCESS, MII_BUSY_) != 0) > + muge_warn_printf(sc, "MII write timeout\n"); > + > +done: > + if (!locked) > + MUGE_UNLOCK(sc); > + return (0); > +} > + > +/* > + * lan78xx_miibus_statchg - Called to detect phy status change > + * @dev: usb ether device > + * > + * This function is called periodically by the system to poll for status > + * changes of the link. > + * > + * LOCKING: > + * Takes and releases the device mutex lock if not already held. > + */ > +static void > +lan78xx_miibus_statchg(device_t dev) > +{ > + struct muge_softc *sc = device_get_softc(dev); > + struct mii_data *mii = uether_getmii(&sc->sc_ue); > + struct ifnet *ifp; > + int locked; > + int err; > + uint32_t flow = 0; > + uint32_t fct_flow = 0; > + > + locked = mtx_owned(&sc->sc_mtx); > + if (!locked) > + MUGE_LOCK(sc); > + > + ifp = uether_getifp(&sc->sc_ue); > + if (mii == NULL || ifp == NULL || > + (ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) > + goto done; > + > + /* Use the MII status to determine link status */ > + sc->sc_flags &= ~MUGE_FLAG_LINK; > + if ((mii->mii_media_status & (IFM_ACTIVE | IFM_AVALID)) == > + (IFM_ACTIVE | IFM_AVALID)) { > + muge_dbg_printf(sc, "media is active\n"); > + switch (IFM_SUBTYPE(mii->mii_media_active)) { > + case IFM_10_T: > + case IFM_100_TX: > + sc->sc_flags |= MUGE_FLAG_LINK; > + muge_dbg_printf(sc, "10/100 ethernet\n"); > + break; > + case IFM_1000_T: > + sc->sc_flags |= MUGE_FLAG_LINK; > + muge_dbg_printf(sc, "Gigabit ethernet\n"); > + break; > + default: > + break; > + } > + } > + /* Lost link, do nothing. */ > + if ((sc->sc_flags & MUGE_FLAG_LINK) == 0) { > + muge_dbg_printf(sc, "link flag not set\n"); > + goto done; > + } > + > + err = lan78xx_read_reg(sc, FCT_FLOW, &fct_flow); > + if (err) { > + muge_warn_printf(sc, > + "failed to read initial flow control thresholds, error %d\n", > + err); > + goto done; > + } > + > + /* Enable/disable full duplex operation and TX/RX pause */ > + if ((IFM_OPTIONS(mii->mii_media_active) & IFM_FDX) != 0) { > + muge_dbg_printf(sc, "full duplex operation\n"); > + > + /* enable transmit MAC flow control function */ > + if ((IFM_OPTIONS(mii->mii_media_active) & IFM_ETH_TXPAUSE) != 0) > + flow |= FLOW_CR_TX_FCEN_ | 0xFFFF; > + > + if ((IFM_OPTIONS(mii->mii_media_active) & IFM_ETH_RXPAUSE) != 0) > + flow |= FLOW_CR_RX_FCEN_; > + } > + > + switch(usbd_get_speed(sc->sc_ue.ue_udev)) { > + case USB_SPEED_SUPER: > + fct_flow = 0x817; /* XXX */ > + break; > + case USB_SPEED_HIGH: > + fct_flow = 0x211; /* XXX */ > + break; > + default: > + break; > + } > + > + err += lan78xx_write_reg(sc, FLOW, flow); > + err += lan78xx_write_reg(sc, FCT_FLOW, fct_flow); > + if (err) > + muge_warn_printf(sc, "media change failed, error %d\n", err); > + > +done: > + if (!locked) > + MUGE_UNLOCK(sc); > +} > + > +/* > + * lan78xx_set_mdix_auto - Configure the device to enable automatic > + * crossover and polarity detection. LAN7800 provides HP Auto-MDIX > + * functionality for seamless crossover and polarity detection. > + * > + * @sc: driver soft context > + * > + * LOCKING: > + * Takes and releases the device mutex lock if not already held. > + */ > +static void > +lan78xx_set_mdix_auto(struct muge_softc *sc) > +{ > + uint32_t buf, err; > + > + err = lan78xx_miibus_writereg(sc->sc_ue.ue_dev, sc->sc_phyno, > + MUGE_EXT_PAGE_ACCESS, MUGE_EXT_PAGE_SPACE_1); > + > + buf = lan78xx_miibus_readreg(sc->sc_ue.ue_dev, sc->sc_phyno, > + MUGE_EXT_MODE_CTRL); > + buf &= ~MUGE_EXT_MODE_CTRL_MDIX_MASK_; > + buf |= MUGE_EXT_MODE_CTRL_AUTO_MDIX_; > + > + lan78xx_miibus_readreg(sc->sc_ue.ue_dev, sc->sc_phyno, MII_BMCR); > + err += lan78xx_miibus_writereg(sc->sc_ue.ue_dev, sc->sc_phyno, > + MUGE_EXT_MODE_CTRL, buf); > + > + err += lan78xx_miibus_writereg(sc->sc_ue.ue_dev, sc->sc_phyno, > + MUGE_EXT_PAGE_ACCESS, MUGE_EXT_PAGE_SPACE_0); > + > + if (err != 0) > + muge_warn_printf(sc, "error setting PHY's MDIX status\n"); > + > + sc->sc_mdix_ctl = buf; > +} > + > +/** > + * lan78xx_phy_init - Initialises the in-built MUGE phy > + * @sc: driver soft context > + * > + * Resets the PHY part of the chip and then initialises it to default > + * values. The 'link down' and 'auto-negotiation complete' interrupts > + * from the PHY are also enabled, however we don't monitor the interrupt > + * endpoints for the moment. > + * > + * RETURNS: > + * Returns 0 on success or EIO if failed to reset the PHY. > + */ > +static int > +lan78xx_phy_init(struct muge_softc *sc) > +{ > + muge_dbg_printf(sc, "Initializing PHY.\n"); > + uint16_t bmcr; > + usb_ticks_t start_ticks; > + const usb_ticks_t max_ticks = USB_MS_TO_TICKS(1000); > + > + MUGE_LOCK_ASSERT(sc, MA_OWNED); > + > + /* Reset phy and wait for reset to complete */ > + lan78xx_miibus_writereg(sc->sc_ue.ue_dev, sc->sc_phyno, MII_BMCR, > + BMCR_RESET); > + > + start_ticks = ticks; > + do { > + uether_pause(&sc->sc_ue, hz / 100); > + bmcr = lan78xx_miibus_readreg(sc->sc_ue.ue_dev, sc->sc_phyno, > + MII_BMCR); > + } while ((bmcr & BMCR_RESET) && ((ticks - start_ticks) < max_ticks)); > + > + if (((usb_ticks_t)(ticks - start_ticks)) >= max_ticks) { > + muge_err_printf(sc, "PHY reset timed-out\n"); > + return (EIO); > + } > + > + /* Setup phy to interrupt upon link down or autoneg completion. */ > + lan78xx_miibus_readreg(sc->sc_ue.ue_dev, sc->sc_phyno, > + MUGE_PHY_INTR_STAT); > + lan78xx_miibus_writereg(sc->sc_ue.ue_dev, sc->sc_phyno, > + MUGE_PHY_INTR_MASK, > + (MUGE_PHY_INTR_ANEG_COMP | MUGE_PHY_INTR_LINK_CHANGE)); > + > + /* Enable Auto-MDIX for crossover and polarity detection. */ > + lan78xx_set_mdix_auto(sc); > + > + /* Enable all modes. */ > + lan78xx_miibus_writereg(sc->sc_ue.ue_dev, sc->sc_phyno, MII_ANAR, > + ANAR_10 | ANAR_10_FD | ANAR_TX | ANAR_TX_FD | > + ANAR_CSMA | ANAR_FC | ANAR_PAUSE_ASYM); > + > + /* Restart auto-negotation */ > + bmcr |= BMCR_STARTNEG; > + bmcr |= BMCR_AUTOEN; > + lan78xx_miibus_writereg(sc->sc_ue.ue_dev, sc->sc_phyno, MII_BMCR, > bmcr); > + bmcr = lan78xx_miibus_readreg(sc->sc_ue.ue_dev, sc->sc_phyno, > MII_BMCR); > + return (0); > +} > + > +/** > + * lan78xx_chip_init - Initialises the chip after power on > + * @sc: driver soft context > + * > + * This initialisation sequence is modelled on the procedure in the > Linux > + * driver. > + * > + * RETURNS: > + * Returns 0 on success or an error code on failure. > + */ > +static int > +lan78xx_chip_init(struct muge_softc *sc) > +{ > + int err; > + int locked; > + uint32_t buf; > + uint32_t burst_cap; > + > + locked = mtx_owned(&sc->sc_mtx); > + if (!locked) > + MUGE_LOCK(sc); > + > + /* Enter H/W config mode */ > + lan78xx_write_reg(sc, HW_CFG, HW_CFG_LRST_); > + > + if ((err = lan78xx_wait_for_bits(sc, HW_CFG, HW_CFG_LRST_)) != 0) { > + muge_warn_printf(sc, > + "timed-out waiting for lite reset to complete\n"); > + goto init_failed; > + } > + > + /* Set the mac address */ > + if ((err = lan78xx_setmacaddress(sc, sc->sc_ue.ue_eaddr)) != 0) { > + muge_warn_printf(sc, "failed to set the MAC address\n"); > + goto init_failed; > + } > + > + /* Read and display the revision register */ > + if ((err = lan78xx_read_reg(sc, ID_REV, &sc->sc_rev_id)) < 0) { > + muge_warn_printf(sc, "failed to read ID_REV (err = %d)\n", err); > + goto init_failed; > + } > + > + device_printf(sc->sc_ue.ue_dev, "chip 0x%04lx, rev. %04lx\n", > + (sc->sc_rev_id & ID_REV_CHIP_ID_MASK_) >> 16, > + (sc->sc_rev_id & ID_REV_CHIP_REV_MASK_)); > + > + /* Respond to BULK-IN tokens with a NAK when RX FIFO is empty. */ > + if ((err = lan78xx_read_reg(sc, USB_CFG0, &buf)) != 0) { > + muge_warn_printf(sc, "failed to read USB_CFG0: %d\n", err); > + goto init_failed; > + } > + buf |= USB_CFG_BIR_; > + lan78xx_write_reg(sc, USB_CFG0, buf); > + > + /* > + * LTM support will go here. > + */ > + > + /* Configuring the burst cap. */ > + switch (usbd_get_speed(sc->sc_ue.ue_udev)) { > + case USB_SPEED_SUPER: > + burst_cap = MUGE_DEFAULT_BURST_CAP_SIZE/MUGE_SS_USB_PKT_SIZE; > > *** DIFF OUTPUT TRUNCATED AT 1000 LINES *** > _______________________________________________ > svn-src-all@freebsd.org mailing list > https://lists.freebsd.org/mailman/listinfo/svn-src-all > To unsubscribe, send any mail to "svn-src-all-unsubscribe@freebsd.org"