#SUBDIR= controller input misc net quirk serial storage template
-SUBDIR= usb audio controller input storage
+SUBDIR= usb audio controller input net storage
.include <bsd.subdir.mk>
--- /dev/null
+SUBDIR= uether if_axe if_udav
+
+.include <bsd.subdir.mk>
* THE POSSIBILITY OF SUCH DAMAGE.
*/
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-
/*
* ASIX Electronics AX88172/AX88178/AX88778 USB 2.0 ethernet driver.
* Used in the LinkSys USB200M and various other adapters.
#include <sys/malloc.h>
#include <sys/mbuf.h>
#include <sys/module.h>
-#include <sys/mutex.h>
#include <sys/socket.h>
#include <sys/sockio.h>
#include <sys/sysctl.h>
-#include <sys/sx.h>
#include <net/if.h>
#include <net/ethernet.h>
#include <net/if_types.h>
#include <net/if_media.h>
-#include <net/if_vlan_var.h>
+#include <net/vlan/if_vlan_var.h>
+#include <net/ifq_var.h>
-#include <dev/mii/mii.h>
-#include <dev/mii/miivar.h>
+#include <dev/netif/mii_layer/mii.h>
+#include <dev/netif/mii_layer/miivar.h>
-#include <dev/usb/usb.h>
-#include <dev/usb/usbdi.h>
-#include <dev/usb/usbdi_util.h>
-#include "usbdevs.h"
+#include <bus/u4b/usb.h>
+#include <bus/u4b/usbdi.h>
+#include <bus/u4b/usbdi_util.h>
+#include <bus/u4b/usbdevs.h>
#define USB_DEBUG_VAR axe_debug
-#include <dev/usb/usb_debug.h>
-#include <dev/usb/usb_process.h>
+#include <bus/u4b/usb_debug.h>
+#include <bus/u4b/usb_process.h>
-#include <dev/usb/net/usb_ethernet.h>
-#include <dev/usb/net/if_axereg.h>
+#include <bus/u4b/net/usb_ethernet.h>
+#include <bus/u4b/net/if_axereg.h>
/*
* AXE_178_MAX_FRAME_BURST
static miibus_writereg_t axe_miibus_writereg;
static miibus_statchg_t axe_miibus_statchg;
+/*
+static int axe_miibus_readreg(device_t dev, int phy, int reg);
+static int axe_miibus_writereg(device_t dev, int phy, int reg, int val);
+static void axe_miibus_statchg(device_t dev);
+*/
static uether_fn_t axe_attach_post;
static uether_fn_t axe_init;
static uether_fn_t axe_stop;
static void axe_ax88772a_init(struct axe_softc *);
static void axe_ax88772b_init(struct axe_softc *);
static int axe_get_phyno(struct axe_softc *, int);
-static int axe_ioctl(struct ifnet *, u_long, caddr_t);
+static int axe_ioctl(struct ifnet *, u_long, caddr_t, struct ucred *);
static int axe_rx_frame(struct usb_ether *, struct usb_page_cache *, int);
static int axe_rxeof(struct usb_ether *, struct usb_page_cache *,
unsigned int offset, unsigned int, struct axe_csum_hdr *);
DEVMETHOD(miibus_writereg, axe_miibus_writereg),
DEVMETHOD(miibus_statchg, axe_miibus_statchg),
- DEVMETHOD_END
+ {0, 0}
};
static driver_t axe_driver = {
struct usb_device_request req;
usb_error_t err;
- AXE_LOCK_ASSERT(sc, MA_OWNED);
+ AXE_LOCK_ASSERT(sc);
req.bmRequestType = (AXE_CMD_IS_WRITE(cmd) ?
UT_WRITE_VENDOR_DEVICE :
uint16_t val;
int locked;
- locked = mtx_owned(&sc->sc_mtx);
+ locked = lockowned(&sc->sc_lock);
+
+ if(phy != sc->sc_phyno){
+ return(0);
+ }
+
if (!locked)
AXE_LOCK(sc);
axe_cmd(sc, AXE_CMD_MII_OPMODE_SW, 0, 0, NULL);
axe_cmd(sc, AXE_CMD_MII_READ_REG, reg, phy, &val);
axe_cmd(sc, AXE_CMD_MII_OPMODE_HW, 0, 0, NULL);
-
+ DPRINTFN(9,"reg %x\n", reg);
+ DPRINTFN(9,"pre val %x\n", val);
val = le16toh(val);
+ DPRINTFN(9,"pos val %x\n", val);
+
if (AXE_IS_772(sc) && reg == MII_BMSR) {
/*
* BMSR of AX88772 indicates that it supports extended
int locked;
val = htole32(val);
- locked = mtx_owned(&sc->sc_mtx);
+ locked = lockowned(&sc->sc_lock);
if (!locked)
AXE_LOCK(sc);
uint16_t val;
int err, locked;
- locked = mtx_owned(&sc->sc_mtx);
+ locked = lockowned(&sc->sc_lock);
if (!locked)
AXE_LOCK(sc);
ifp = uether_getifp(&sc->sc_ue);
if (mii == NULL || ifp == NULL ||
- (ifp->if_drv_flags & IFF_DRV_RUNNING) == 0)
+ (ifp->if_flags & IFF_RUNNING) == 0)
goto done;
sc->sc_flags &= ~AXE_FLAG_LINK;
if ((sc->sc_flags & AXE_FLAG_178) == 0)
break;
sc->sc_flags |= AXE_FLAG_LINK;
+ DPRINTFN(11, "miibus_statchg: link should be up\n");
break;
default:
break;
}
+ } else {
+ DPRINTFN(11, "miibus_statchg: not active or not valid: %x\n", mii->mii_media_status);
}
/* Lost link, do nothing. */
- if ((sc->sc_flags & AXE_FLAG_LINK) == 0)
+ if ((sc->sc_flags & AXE_FLAG_LINK) == 0) {
goto done;
+ }
val = 0;
if ((IFM_OPTIONS(mii->mii_media_active) & IFM_FDX) != 0) {
struct mii_softc *miisc;
int error;
- AXE_LOCK_ASSERT(sc, MA_OWNED);
+ AXE_LOCK_ASSERT(sc);
LIST_FOREACH(miisc, &mii->mii_phys, mii_list)
- PHY_RESET(miisc);
+ mii_phy_reset(miisc);
error = mii_mediachg(mii);
return (error);
}
uint16_t rxmode;
uint8_t hashtbl[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
- AXE_LOCK_ASSERT(sc, MA_OWNED);
+ AXE_LOCK_ASSERT(sc);
axe_cmd(sc, AXE_CMD_RXCTL_READ, 0, 0, &rxmode);
rxmode = le16toh(rxmode);
}
rxmode &= ~AXE_RXCMD_ALLMULTI;
- if_maddr_rlock(ifp);
+ /* if_maddr_rlock(ifp); */
TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link)
{
if (ifma->ifma_addr->sa_family != AF_LINK)
ifma->ifma_addr), ETHER_ADDR_LEN) >> 26;
hashtbl[h / 8] |= 1 << (h % 8);
}
- if_maddr_runlock(ifp);
+/* if_maddr_runlock(ifp); */
axe_cmd(sc, AXE_CMD_WRITE_MCAST, 0, 0, (void *)&hashtbl);
axe_cmd(sc, AXE_CMD_RXCTL_WRITE, 0, rxmode, NULL);
cd = usbd_get_config_descriptor(sc->sc_ue.ue_udev);
- err = usbd_req_set_config(sc->sc_ue.ue_udev, &sc->sc_mtx,
+ err = usbd_req_set_config(sc->sc_ue.ue_udev, &sc->sc_lock,
cd->bConfigurationValue);
if (err)
DPRINTF("reset failed (ignored)\n");
ifp->if_start = uether_start;
ifp->if_ioctl = axe_ioctl;
ifp->if_init = uether_init;
- IFQ_SET_MAXLEN(&ifp->if_snd, ifqmaxlen);
+ ifq_set_maxlen(&ifp->if_snd, ifqmaxlen);
+ /* XXX
ifp->if_snd.ifq_drv_maxlen = ifqmaxlen;
- IFQ_SET_READY(&ifp->if_snd);
+ */
+ ifq_set_ready(&ifp->if_snd);
if (AXE_IS_178_FAMILY(sc))
ifp->if_capabilities |= IFCAP_VLAN_MTU;
adv_pause = MIIF_DOPAUSE;
else
adv_pause = 0;
- mtx_lock(&Giant);
+
+ error = mii_phy_probe(ue->ue_dev, &ue->ue_miibus,
+ uether_ifmedia_upd, ue->ue_methods->ue_mii_sts);
+ /* XXX
error = mii_attach(ue->ue_dev, &ue->ue_miibus, ifp,
uether_ifmedia_upd, ue->ue_methods->ue_mii_sts,
BMSR_DEFCAPMASK, sc->sc_phyno, MII_OFFSET_ANY, adv_pause);
- mtx_unlock(&Giant);
-
+ */
return (error);
}
device_set_usb_desc(dev);
- mtx_init(&sc->sc_mtx, device_get_nameunit(dev), NULL, MTX_DEF);
+ lockinit(&sc->sc_lock, device_get_nameunit(dev), 0, 0);
iface_index = AXE_IFACE_IDX;
error = usbd_transfer_setup(uaa->device, &iface_index, sc->sc_xfer,
- axe_config, AXE_N_TRANSFER, sc, &sc->sc_mtx);
+ axe_config, AXE_N_TRANSFER, sc, &sc->sc_lock);
if (error) {
device_printf(dev, "allocating USB transfers failed\n");
goto detach;
ue->ue_sc = sc;
ue->ue_dev = dev;
ue->ue_udev = uaa->device;
- ue->ue_mtx = &sc->sc_mtx;
+ ue->ue_lock = &sc->sc_lock;
ue->ue_methods = &axe_ue_methods;
error = uether_ifattach(ue);
usbd_transfer_unsetup(sc->sc_xfer, AXE_N_TRANSFER);
uether_ifdetach(ue);
- mtx_destroy(&sc->sc_mtx);
+ lockuninit(&sc->sc_lock);
+
return (0);
}
return (EINVAL);
}
- m = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR);
+ m = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
if (m == NULL) {
ifp->if_iqdrops++;
return (ENOMEM);
}
}
}
-
- _IF_ENQUEUE(&ue->ue_rxq, m);
+
+ IF_ENQUEUE(&ue->ue_rxq, m);
return (0);
}
struct mbuf *m;
int nframes, pos;
+ DPRINTFN(11, "starting transfer\n");
+
switch (USB_GET_STATE(xfer)) {
case USB_ST_TRANSFERRED:
DPRINTFN(11, "transfer complete\n");
- ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
+
+ ifp->if_flags &= ~IFF_OACTIVE;
+
/* FALLTHROUGH */
case USB_ST_SETUP:
tr_setup:
if ((sc->sc_flags & AXE_FLAG_LINK) == 0 ||
- (ifp->if_drv_flags & IFF_DRV_OACTIVE) != 0) {
+ (ifp->if_flags & IFF_OACTIVE) != 0) {
/*
* Don't send anything if there is no link or
* controller is busy.
*/
+ DPRINTFN(11, "controller busy: sc_flags: %x if_flags %x\n",sc->sc_flags, ifp->if_flags);
return;
}
+ DPRINTFN(11, "copying frames, 16 at a time\n");
for (nframes = 0; nframes < 16 &&
- !IFQ_DRV_IS_EMPTY(&ifp->if_snd); nframes++) {
- IFQ_DRV_DEQUEUE(&ifp->if_snd, m);
+ !ifq_is_empty(&ifp->if_snd); nframes++) {
+ m = ifq_dequeue(&ifp->if_snd, NULL);
if (m == NULL)
break;
usbd_xfer_set_frame_offset(xfer, nframes * MCLBYTES,
hdr.len |= htole16(
AXE_TX_CSUM_DIS);
}
+ DPRINTFN(11, "usbd copy in\n");
usbd_copy_in(pc, pos, &hdr, sizeof(hdr));
pos += sizeof(hdr);
usbd_m_copy_in(pc, pos, m, 0, m->m_pkthdr.len);
}
if (nframes != 0) {
usbd_xfer_set_frames(xfer, nframes);
+ DPRINTFN(5, "submitting transfer\n");
usbd_transfer_submit(xfer);
- ifp->if_drv_flags |= IFF_DRV_OACTIVE;
+ ifp->if_flags |= IFF_OACTIVE;
}
return;
/* NOTREACHED */
usbd_errstr(error));
ifp->if_oerrors++;
- ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
-
+ ifp->if_flags &= ~IFF_OACTIVE;
if (error != USB_ERR_CANCELLED) {
/* try to clear stall first */
usbd_xfer_set_stall(xfer);
struct axe_softc *sc = uether_getsc(ue);
struct mii_data *mii = GET_MII(sc);
- AXE_LOCK_ASSERT(sc, MA_OWNED);
+ AXE_LOCK_ASSERT(sc);
mii_tick(mii);
if ((sc->sc_flags & AXE_FLAG_LINK) == 0) {
uint16_t csum1, csum2;
sc = uether_getsc(ue);
- AXE_LOCK_ASSERT(sc, MA_OWNED);
+ AXE_LOCK_ASSERT(sc);
if ((sc->sc_flags & AXE_FLAG_772B) != 0) {
ifp = uether_getifp(ue);
struct ifnet *ifp = uether_getifp(ue);
uint16_t rxmode;
- AXE_LOCK_ASSERT(sc, MA_OWNED);
+ AXE_LOCK_ASSERT(sc);
- if ((ifp->if_drv_flags & IFF_DRV_RUNNING) != 0)
+
+ if ((ifp->if_flags & IFF_RUNNING) != 0)
return;
-
+
/* Cancel pending I/O */
axe_stop(ue);
usbd_xfer_set_stall(sc->sc_xfer[AXE_BULK_DT_WR]);
- ifp->if_drv_flags |= IFF_DRV_RUNNING;
+
+ ifp->if_flags |= IFF_RUNNING;
+
/* Switch to selected media. */
axe_ifmedia_upd(ifp);
}
struct axe_softc *sc = uether_getsc(ue);
struct ifnet *ifp = uether_getifp(ue);
- AXE_LOCK_ASSERT(sc, MA_OWNED);
+ AXE_LOCK_ASSERT(sc);
- ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
+
+ ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
+
sc->sc_flags &= ~AXE_FLAG_LINK;
/*
}
static int
-axe_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
+axe_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data, struct ucred *uc)
{
struct usb_ether *ue = ifp->if_softc;
struct axe_softc *sc;
ifp->if_capenable ^= IFCAP_RXCSUM;
reinit++;
}
- if (reinit > 0 && ifp->if_drv_flags & IFF_DRV_RUNNING)
- ifp->if_drv_flags &= ~IFF_DRV_RUNNING;
- else
+ if (reinit > 0 && ifp->if_flags & IFF_RUNNING)
+ ifp->if_flags &= ~IFF_RUNNING;
+ else
reinit = 0;
AXE_UNLOCK(sc);
if (reinit > 0)
uether_init(ue);
} else
- error = uether_ioctl(ifp, cmd, data);
+ error = uether_ioctl(ifp, cmd, data, uc);
return (error);
}
--- /dev/null
+.PATH: ${.CURDIR}/..
+
+KMOD= if_axe
+SRCS= opt_bus.h opt_usb.h device_if.h bus_if.h usb_if.h \
+ miibus_if.h opt_inet.h \
+ if_axe.c
+
+.include <bsd.kmod.mk>
struct axe_softc {
struct usb_ether sc_ue;
- struct mtx sc_mtx;
+ struct lock sc_lock;
struct usb_xfer *sc_xfer[AXE_N_TRANSFER];
int sc_phyno;
#define AXE_IS_772(sc) \
((sc)->sc_flags & (AXE_FLAG_772 | AXE_FLAG_772A | AXE_FLAG_772B))
-#define AXE_LOCK(_sc) mtx_lock(&(_sc)->sc_mtx)
-#define AXE_UNLOCK(_sc) mtx_unlock(&(_sc)->sc_mtx)
-#define AXE_LOCK_ASSERT(_sc, t) mtx_assert(&(_sc)->sc_mtx, t)
+#define AXE_LOCK(_sc) lockmgr(&(_sc)->sc_lock, LK_EXCLUSIVE)
+#define AXE_UNLOCK(_sc) lockmgr(&(_sc)->sc_lock, LK_RELEASE)
+#define AXE_LOCK_ASSERT(_sc) KKASSERT(lockowned(&(_sc)->sc_lock))
* External PHYs
*/
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-
#include <sys/stdint.h>
-#include <sys/stddef.h>
#include <sys/param.h>
#include <sys/queue.h>
#include <sys/types.h>
#include <sys/mutex.h>
#include <sys/condvar.h>
#include <sys/sysctl.h>
-#include <sys/sx.h>
#include <sys/unistd.h>
#include <sys/callout.h>
#include <sys/malloc.h>
#include <sys/priv.h>
-#include <dev/usb/usb.h>
-#include <dev/usb/usbdi.h>
-#include <dev/usb/usbdi_util.h>
-#include "usbdevs.h"
+#include <net/ifq_var.h>
+
+#include <bus/u4b/usb.h>
+#include <bus/u4b/usbdi.h>
+#include <bus/u4b/usbdi_util.h>
+#include <bus/u4b/usbdevs.h>
#define USB_DEBUG_VAR udav_debug
-#include <dev/usb/usb_debug.h>
-#include <dev/usb/usb_process.h>
+#include <bus/u4b/usb_debug.h>
+#include <bus/u4b/usb_process.h>
-#include <dev/usb/net/usb_ethernet.h>
-#include <dev/usb/net/if_udavreg.h>
+#include <bus/u4b/net/usb_ethernet.h>
+#include <bus/u4b/net/if_udavreg.h>
/* prototypes */
DEVMETHOD(miibus_writereg, udav_miibus_writereg),
DEVMETHOD(miibus_statchg, udav_miibus_statchg),
- DEVMETHOD_END
+ {0, 0}
};
static driver_t udav_driver = {
device_set_usb_desc(dev);
- mtx_init(&sc->sc_mtx, device_get_nameunit(dev), NULL, MTX_DEF);
+ lockinit(&sc->sc_lock, device_get_nameunit(dev), 0, 0);
iface_index = UDAV_IFACE_INDEX;
error = usbd_transfer_setup(uaa->device, &iface_index,
- sc->sc_xfer, udav_config, UDAV_N_TRANSFER, sc, &sc->sc_mtx);
+ sc->sc_xfer, udav_config, UDAV_N_TRANSFER, sc, &sc->sc_lock);
if (error) {
device_printf(dev, "allocating USB transfers failed\n");
goto detach;
ue->ue_sc = sc;
ue->ue_dev = dev;
ue->ue_udev = uaa->device;
- ue->ue_mtx = &sc->sc_mtx;
+ ue->ue_lock = &sc->sc_lock;
ue->ue_methods = &udav_ue_methods;
error = uether_ifattach(ue);
usbd_transfer_unsetup(sc->sc_xfer, UDAV_N_TRANSFER);
uether_ifdetach(ue);
- mtx_destroy(&sc->sc_mtx);
+ lockuninit(&sc->sc_lock);
return (0);
}
struct udav_softc *sc = ue->ue_sc;
struct ifnet *ifp = uether_getifp(&sc->sc_ue);
- UDAV_LOCK_ASSERT(sc, MA_OWNED);
+ UDAV_LOCK_ASSERT(sc);
/*
* Cancel pending I/O
usbd_xfer_set_stall(sc->sc_xfer[UDAV_BULK_DT_WR]);
- ifp->if_drv_flags |= IFF_DRV_RUNNING;
+/* XXX ifp->if_drv_flags |= IFF_DRV_RUNNING;
+ */
udav_start(ue);
}
uint8_t hashtbl[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
int h = 0;
- UDAV_LOCK_ASSERT(sc, MA_OWNED);
+ UDAV_LOCK_ASSERT(sc);
if (ifp->if_flags & IFF_ALLMULTI || ifp->if_flags & IFF_PROMISC) {
UDAV_SETBIT(sc, UDAV_RCR, UDAV_RCR_ALL|UDAV_RCR_PRMSC);
udav_csr_write(sc, UDAV_MAR, hashtbl, sizeof(hashtbl));
/* now program new ones */
- if_maddr_rlock(ifp);
TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link)
{
if (ifma->ifma_addr->sa_family != AF_LINK)
ifma->ifma_addr), ETHER_ADDR_LEN) >> 26;
hashtbl[h / 8] |= 1 << (h % 8);
}
- if_maddr_runlock(ifp);
/* disable all multicast */
UDAV_CLRBIT(sc, UDAV_RCR, UDAV_RCR_ALL);
*/
return;
}
- IFQ_DRV_DEQUEUE(&ifp->if_snd, m);
+ m = ifq_dequeue(&ifp->if_snd, NULL);
if (m == NULL)
return;
struct udav_softc *sc = ue->ue_sc;
struct ifnet *ifp = uether_getifp(&sc->sc_ue);
- UDAV_LOCK_ASSERT(sc, MA_OWNED);
+ UDAV_LOCK_ASSERT(sc);
+ /* XXX
ifp->if_drv_flags &= ~IFF_DRV_RUNNING;
+ */
sc->sc_flags &= ~UDAV_FLAG_LINK;
/*
struct mii_data *mii = GET_MII(sc);
struct mii_softc *miisc;
- UDAV_LOCK_ASSERT(sc, MA_OWNED);
+ kprintf("ifmedia upd\n");
+
+ UDAV_LOCK_ASSERT(sc);
sc->sc_flags &= ~UDAV_FLAG_LINK;
LIST_FOREACH(miisc, &mii->mii_phys, mii_list)
- PHY_RESET(miisc);
+ mii_phy_reset(miisc);
mii_mediachg(mii);
return (0);
}
struct udav_softc *sc = ifp->if_softc;
struct mii_data *mii = GET_MII(sc);
+ kprintf("ifmedia status\n");
+
UDAV_LOCK(sc);
mii_pollstat(mii);
ifmr->ifm_active = mii->mii_media_active;
struct udav_softc *sc = ue->ue_sc;
struct mii_data *mii = GET_MII(sc);
- UDAV_LOCK_ASSERT(sc, MA_OWNED);
+ UDAV_LOCK_ASSERT(sc);
mii_tick(mii);
if ((sc->sc_flags & UDAV_FLAG_LINK) == 0
if (phy != 0)
return (0);
- locked = mtx_owned(&sc->sc_mtx);
+ locked = lockowned(&sc->sc_lock);
if (!locked)
UDAV_LOCK(sc);
if (phy != 0)
return (0);
- locked = mtx_owned(&sc->sc_mtx);
+ locked = lockowned(&sc->sc_lock);
if (!locked)
UDAV_LOCK(sc);
--- /dev/null
+.PATH: ${.CURDIR}/..
+
+KMOD= if_udav
+SRCS= opt_bus.h opt_usb.h device_if.h bus_if.h usb_if.h \
+ miibus_if.h opt_inet.h \
+ if_udav.c
+
+.include <bsd.kmod.mk>
struct udav_softc {
struct usb_ether sc_ue;
- struct mtx sc_mtx;
+ struct lock sc_lock;
struct usb_xfer *sc_xfer[UDAV_N_TRANSFER];
int sc_flags;
#define UDAV_FLAG_EXT_PHY 0x0040
};
-#define UDAV_LOCK(_sc) mtx_lock(&(_sc)->sc_mtx)
-#define UDAV_UNLOCK(_sc) mtx_unlock(&(_sc)->sc_mtx)
-#define UDAV_LOCK_ASSERT(_sc, t) mtx_assert(&(_sc)->sc_mtx, t)
+#define UDAV_LOCK(_sc) lockmgr(&(_sc)->sc_lock, LK_EXCLUSIVE)
+#define UDAV_UNLOCK(_sc) lockmgr(&(_sc)->sc_lock, LK_RELEASE)
+#define UDAV_LOCK_ASSERT(_sc) KKASSERT(lockowned(&(_sc)->sc_lock))
--- /dev/null
+.PATH: ${.CURDIR}/..
+
+KMOD= uether
+SRCS= opt_bus.h opt_usb.h device_if.h bus_if.h usb_if.h \
+ miibus_if.h opt_inet.h \
+ usb_ethernet.c
+
+.include <bsd.kmod.mk>
* SUCH DAMAGE.
*/
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/bus.h>
#include <sys/malloc.h>
#include <sys/mbuf.h>
#include <sys/module.h>
-#include <sys/mutex.h>
#include <sys/socket.h>
#include <sys/sockio.h>
#include <sys/sysctl.h>
-#include <sys/sx.h>
#include <net/if.h>
+#include <net/ifq_var.h>
#include <net/ethernet.h>
#include <net/if_types.h>
#include <net/if_media.h>
-#include <net/if_vlan_var.h>
+#include <net/vlan/if_vlan_var.h>
+
+#include <sys/devfs.h>
-#include <dev/mii/mii.h>
-#include <dev/mii/miivar.h>
+#include <dev/netif/mii_layer/mii.h>
+#include <dev/netif/mii_layer/miivar.h>
-#include <dev/usb/usb.h>
-#include <dev/usb/usbdi.h>
+#include <bus/u4b/usb.h>
+#include <bus/u4b/usbdi.h>
-#include <dev/usb/usb_process.h>
-#include <dev/usb/net/usb_ethernet.h>
+#include <bus/u4b/usb_process.h>
+#include <bus/u4b/net/usb_ethernet.h>
static SYSCTL_NODE(_net, OID_AUTO, ue, CTLFLAG_RD, 0,
"USB Ethernet parameters");
-#define UE_LOCK(_ue) mtx_lock((_ue)->ue_mtx)
-#define UE_UNLOCK(_ue) mtx_unlock((_ue)->ue_mtx)
-#define UE_LOCK_ASSERT(_ue, t) mtx_assert((_ue)->ue_mtx, t)
+#define UE_LOCK(_ue) lockmgr((_ue)->ue_lock, LK_EXCLUSIVE)
+#define UE_UNLOCK(_ue) lockmgr((_ue)->ue_lock, LK_RELEASE)
+#define UE_LOCK_ASSERT(_ue) KKASSERT(lockowned((_ue)->ue_lock))
MODULE_DEPEND(uether, usb, 1, 1, 1);
MODULE_DEPEND(uether, miibus, 1, 1, 1);
+/*
static struct unrhdr *ueunit;
+*/
+DEVFS_DECLARE_CLONE_BITMAP(ue);
static usb_proc_callback_t ue_attach_post_task;
static usb_proc_callback_t ue_promisc_task;
/* nothing to do */
return (1);
}
- usb_pause_mtx(ue->ue_mtx, _ticks);
+ usb_pause_mtx(ue->ue_lock, _ticks);
return (0);
}
{
struct usb_ether_cfg_task *task;
- UE_LOCK_ASSERT(ue, MA_OWNED);
+ UE_LOCK_ASSERT(ue);
if (usb_proc_is_gone(&ue->ue_tq)) {
return; /* nothing to do */
/* check some critical parameters */
if ((ue->ue_dev == NULL) ||
(ue->ue_udev == NULL) ||
- (ue->ue_mtx == NULL) ||
+ (ue->ue_lock == NULL) ||
(ue->ue_methods == NULL))
return (EINVAL);
- error = usb_proc_create(&ue->ue_tq, ue->ue_mtx,
+ error = usb_proc_create(&ue->ue_tq, ue->ue_lock,
device_get_nameunit(ue->ue_dev), USB_PRI_MED);
if (error) {
device_printf(ue->ue_dev, "could not setup taskqueue\n");
UE_UNLOCK(ue);
+ /* XXX
ue->ue_unit = alloc_unr(ueunit);
- usb_callout_init_mtx(&ue->ue_watchdog, ue->ue_mtx, 0);
+ */
+ ue->ue_unit = devfs_clone_bitmap_get(&DEVFS_CLONE_BITMAP(ue), 0);
+ usb_callout_init_mtx(&ue->ue_watchdog, ue->ue_lock, 0);
sysctl_ctx_init(&ue->ue_sysctl_ctx);
error = 0;
ifp->if_ioctl = uether_ioctl;
ifp->if_start = ue_start;
ifp->if_init = ue_init;
- IFQ_SET_MAXLEN(&ifp->if_snd, ifqmaxlen);
+ ifq_set_maxlen(&ifp->if_snd, ifqmaxlen);
+ /* XXX
ifp->if_snd.ifq_drv_maxlen = ifqmaxlen;
- IFQ_SET_READY(&ifp->if_snd);
+ */
+ ifq_set_ready(&ifp->if_snd);
ue->ue_ifp = ifp;
if (ue->ue_methods->ue_mii_upd != NULL &&
ue->ue_methods->ue_mii_sts != NULL) {
/* device_xxx() depends on this */
- mtx_lock(&Giant);
+/* mtx_lock(&Giant);*/
+ error = mii_phy_probe(ue->ue_dev, &ue->ue_miibus,
+ ue_ifmedia_upd, ue->ue_methods->ue_mii_sts);
+ /*
error = mii_attach(ue->ue_dev, &ue->ue_miibus, ifp,
ue_ifmedia_upd, ue->ue_methods->ue_mii_sts,
BMSR_DEFCAPMASK, MII_PHY_ANY, MII_OFFSET_ANY, 0);
- mtx_unlock(&Giant);
+*/ /* mtx_unlock(&Giant);*/
}
}
}
if_printf(ifp, "<USB Ethernet> on %s\n", device_get_nameunit(ue->ue_dev));
- ether_ifattach(ifp, ue->ue_eaddr);
+ ether_ifattach(ifp, ue->ue_eaddr, NULL);
/* Tell upper layer we support VLAN oversized frames. */
if (ifp->if_capabilities & IFCAP_VLAN_MTU)
ifp->if_hdrlen = sizeof(struct ether_vlan_header);
- snprintf(num, sizeof(num), "%u", ue->ue_unit);
+ ksnprintf(num, sizeof(num), "%u", ue->ue_unit);
ue->ue_sysctl_oid = SYSCTL_ADD_NODE(&ue->ue_sysctl_ctx,
&SYSCTL_NODE_CHILDREN(_net, ue),
OID_AUTO, num, CTLFLAG_RD, NULL, "");
return;
fail:
+ /* XXX
free_unr(ueunit, ue->ue_unit);
+ */
+ devfs_clone_bitmap_put(&DEVFS_CLONE_BITMAP(ue), ue->ue_unit);
if (ue->ue_ifp != NULL) {
if_free(ue->ue_ifp);
ue->ue_ifp = NULL;
/* we are not running any more */
UE_LOCK(ue);
- ifp->if_drv_flags &= ~IFF_DRV_RUNNING;
+ ifp->if_flags &= ~IFF_RUNNING;
UE_UNLOCK(ue);
-
+
/* drain any callouts */
usb_callout_drain(&ue->ue_watchdog);
/* detach miibus */
if (ue->ue_miibus != NULL) {
- mtx_lock(&Giant); /* device_xxx() depends on this */
+ /*mtx_lock(&Giant);*/ /* device_xxx() depends on this */
device_delete_child(ue->ue_dev, ue->ue_miibus);
- mtx_unlock(&Giant);
+ /*mtx_unlock(&Giant);*/
}
/* detach ethernet */
sysctl_ctx_free(&ue->ue_sysctl_ctx);
/* free unit */
+ devfs_clone_bitmap_put(&DEVFS_CLONE_BITMAP(ue), ue->ue_unit);
+ /*
free_unr(ueunit, ue->ue_unit);
+ */
}
/* free taskqueue, if any */
struct usb_ether *ue = task->ue;
struct ifnet *ifp = ue->ue_ifp;
- UE_LOCK_ASSERT(ue, MA_OWNED);
+ UE_LOCK_ASSERT(ue);
ue->ue_methods->ue_init(ue);
- if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0)
+ if ((ifp->if_flags & IFF_RUNNING) == 0)
return;
-
if (ue->ue_methods->ue_tick != NULL)
usb_callout_reset(&ue->ue_watchdog, hz, ue_watchdog, ue);
}
(struct usb_ether_cfg_task *)_task;
struct usb_ether *ue = task->ue;
- UE_LOCK_ASSERT(ue, MA_OWNED);
+ UE_LOCK_ASSERT(ue);
usb_callout_stop(&ue->ue_watchdog);
{
struct usb_ether *ue = ifp->if_softc;
- if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0)
+ if ((ifp->if_flags & IFF_RUNNING) == 0)
return;
-
UE_LOCK(ue);
ue->ue_methods->ue_start(ue);
UE_UNLOCK(ue);
{
struct usb_ether *ue = arg;
struct ifnet *ifp = ue->ue_ifp;
-
- if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0)
+
+ if ((ifp->if_flags & IFF_RUNNING) == 0)
return;
ue_queue_command(ue, ue_tick_task,
(struct usb_ether_cfg_task *)_task;
struct usb_ether *ue = task->ue;
struct ifnet *ifp = ue->ue_ifp;
-
- if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0)
+
+ if ((ifp->if_flags & IFF_RUNNING) == 0)
return;
ue->ue_methods->ue_tick(ue);
}
int
-uether_ioctl(struct ifnet *ifp, u_long command, caddr_t data)
+uether_ioctl(struct ifnet *ifp, u_long command, caddr_t data, struct ucred* uc)
{
struct usb_ether *ue = ifp->if_softc;
struct ifreq *ifr = (struct ifreq *)data;
case SIOCSIFFLAGS:
UE_LOCK(ue);
if (ifp->if_flags & IFF_UP) {
- if (ifp->if_drv_flags & IFF_DRV_RUNNING)
+ if (ifp->if_flags & IFF_RUNNING)
ue_queue_command(ue, ue_promisc_task,
&ue->ue_promisc_task[0].hdr,
&ue->ue_promisc_task[1].hdr);
static int
uether_modevent(module_t mod, int type, void *data)
{
+ static int attached = 0;
switch (type) {
case MOD_LOAD:
- ueunit = new_unrhdr(0, INT_MAX, NULL);
- break;
+ if (attached)
+ return (EEXIST);
+
+ devfs_clone_bitmap_init(&DEVFS_CLONE_BITMAP(ue));
+
+ attached = 1;
+ break;
case MOD_UNLOAD:
+ devfs_clone_bitmap_uninit(&DEVFS_CLONE_BITMAP(ue));
break;
default:
return (EOPNOTSUPP);
{
struct mbuf *m_new;
- m_new = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR);
+ m_new = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
if (m_new == NULL)
return (NULL);
m_new->m_len = m_new->m_pkthdr.len = MCLBYTES;
{
struct ifnet *ifp = ue->ue_ifp;
- UE_LOCK_ASSERT(ue, MA_OWNED);
+ UE_LOCK_ASSERT(ue);
/* finalize mbuf */
ifp->if_ipackets++;
m->m_pkthdr.len = m->m_len = len;
/* enqueue for later when the lock can be released */
- _IF_ENQUEUE(&ue->ue_rxq, m);
+ IF_ENQUEUE(&ue->ue_rxq, m);
return (0);
}
struct ifnet *ifp = ue->ue_ifp;
struct mbuf *m;
- UE_LOCK_ASSERT(ue, MA_OWNED);
+ UE_LOCK_ASSERT(ue);
if (len < ETHER_HDR_LEN || len > MCLBYTES - ETHER_ALIGN)
return (1);
m->m_pkthdr.len = m->m_len = len;
/* enqueue for later when the lock can be released */
- _IF_ENQUEUE(&ue->ue_rxq, m);
+ IF_ENQUEUE(&ue->ue_rxq, m);
return (0);
}
struct ifnet *ifp = ue->ue_ifp;
struct mbuf *m;
- UE_LOCK_ASSERT(ue, MA_OWNED);
+ UE_LOCK_ASSERT(ue);
for (;;) {
- _IF_DEQUEUE(&ue->ue_rxq, m);
+ IF_DEQUEUE(&ue->ue_rxq, m);
if (m == NULL)
break;
#include "miibus_if.h"
-#include <dev/mii/mii.h>
-#include <dev/mii/miivar.h>
+#include <dev/netif/mii_layer/mii.h>
+#include <dev/netif/mii_layer/miivar.h>
struct usb_ether;
struct usb_device_request;
struct usb_ether {
/* NOTE: the "ue_ifp" pointer must be first --hps */
struct ifnet *ue_ifp;
- struct mtx *ue_mtx;
+ struct lock *ue_lock;
const struct usb_ether_methods *ue_methods;
struct sysctl_oid *ue_sysctl_oid;
void *ue_sc;
void uether_ifdetach(struct usb_ether *);
int uether_ifmedia_upd(struct ifnet *);
void uether_init(void *);
-int uether_ioctl(struct ifnet *, u_long, caddr_t);
+int uether_ioctl(struct ifnet *, u_long, caddr_t, struct ucred *);
struct mbuf *uether_newbuf(void);
int uether_rxmbuf(struct usb_ether *, struct mbuf *,
unsigned int);
projects / dragonfly.git / commitdiff