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 <bg...@freebsd.org>.
+ * Copyright (C) 2018 The FreeBSD Foundation.
+ *
+ * This software was developed by Arshan Khanifar <arshankhani...@gmail.com>
+ * 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 <sys/cdefs.h>
+__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 <sys/param.h>
+#include <sys/bus.h>
+#include <sys/callout.h>
+#include <sys/condvar.h>
+#include <sys/kernel.h>
+#include <sys/lock.h>
+#include <sys/malloc.h>
+#include <sys/module.h>
+#include <sys/mutex.h>
+#include <sys/priv.h>
+#include <sys/queue.h>
+#include <sys/random.h>
+#include <sys/socket.h>
+#include <sys/stddef.h>
+#include <sys/stdint.h>
+#include <sys/sx.h>
+#include <sys/sysctl.h>
+#include <sys/systm.h>
+#include <sys/unistd.h>
+
+#include <net/if.h>
+#include <net/if_var.h>
+
+#include <netinet/in.h>
+#include <netinet/ip.h>
+
+#include "opt_platform.h"
+
+#include <dev/usb/usb.h>
+#include <dev/usb/usbdi.h>
+#include <dev/usb/usbdi_util.h>
+#include "usbdevs.h"
+
+#define USB_DEBUG_VAR lan78xx_debug
+#include <dev/usb/usb_debug.h>
+#include <dev/usb/usb_process.h>
+
+#include <dev/usb/net/usb_ethernet.h>
+
+#include <dev/usb/net/if_mugereg.h>
+
+#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-unsubscr...@freebsd.org"

Reply via email to