Aren/NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
11e94a8068
NetBSD/sys/dev/usb/if_upl.c
thorpej 7a9a30c5e7 Define and implement a locking protocol for the ifmedia / mii layers: 
- MP-safe drivers provide a mutex to ifmedia that is used to serialize
  access to media-related structures / hardware regsiters.  Converted
  drivers use the new ifmedia_init_with_lock() function for this.  The
  new name is provided to ease the transition.
- Un-converted drivers continue to call ifmedia_init(), which will supply
  a compatibility lock to be used instead.  Several media-related entry
  points must be aware of this compatibility lock, and are able to acquire
  it recursively a limited number of times, if needed.  This is a SPIN
  mutex with priority IPL_NET.
- This same lock is used to serialize access to PHY registers and other
  MII-related data structures.

The PHY drivers are modified to acquire and release the lock, as needed,
and assert the lock is held as a diagnostic aid.

The "usbnet" framework has had an overhaul of its internal locking
protocols to fit in with the media / mii changes, and the drivers adapted.

USB wifi drivers have been changed to provide their own adaptive mutex
to the ifmedia later via a new ieee80211_media_init_with_lock() function.
This is required because the USB drivers need an adaptive mutex.

Besised "usbnet", a few other drivers are converted: vmx, wm, ixgbe / ixv.

mcx also now calls ifmedia_init_with_lock() because it needs to also use
an adaptive mutex.  The mcx driver still needs to be fully converted to
NET_MPSAFE.
2020-03-15 23:04:50 +00:00

323 lines
8.2 KiB
C
Raw Blame History

/* $NetBSD: if_upl.c,v 1.71 2020/03/15 23:04:51 thorpej Exp $ */
/*
* Copyright (c) 2000 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Lennart Augustsson (lennart@augustsson.net) at
* Carlstedt Research & Technology.
*
* 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
*/
/*
* Prolific PL2301/PL2302 driver
*/
#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: if_upl.c,v 1.71 2020/03/15 23:04:51 thorpej Exp $");
#ifdef _KERNEL_OPT
#include "opt_inet.h"
#include "opt_usb.h"
#endif
#include <sys/param.h>
#include <dev/usb/usbnet.h>
#include <net/if_types.h>
#ifdef INET
#include <netinet/in.h>
#include <netinet/in_var.h>
#include <netinet/if_inarp.h>
#endif
/*
* 7 6 5 4 3 2 1 0
* tx rx 1 0
* 1110 0000 rxdata
* 1010 0000 idle
* 0010 0000 tx over
* 0110 tx over + rxd
*/
#define UPL_RXDATA 0x40
#define UPL_TXOK 0x80
#define UPL_CONFIG_NO 1
#define UPL_IFACE_IDX 0
/***/
#define UPL_INTR_INTERVAL 20
#define UPL_BUFSZ 1024
#define UPL_RX_LIST_CNT 1
#define UPL_TX_LIST_CNT 1
#ifdef UPL_DEBUG
#define DPRINTF(x) if (upldebug) printf x
#define DPRINTFN(n,x) if (upldebug >= (n)) printf x
int upldebug = 0;
#else
#define DPRINTF(x)
#define DPRINTFN(n,x)
#endif
/*
* Various supported device vendors/products.
*/
static const struct usb_devno sc_devs[] = {
{ USB_VENDOR_PROLIFIC, USB_PRODUCT_PROLIFIC_PL2301 },
{ USB_VENDOR_PROLIFIC, USB_PRODUCT_PROLIFIC_PL2302 },
{ USB_VENDOR_PROLIFIC, USB_PRODUCT_PROLIFIC_PL25A1 },
{ USB_VENDOR_BELKIN, USB_PRODUCT_BELKIN_F5U258 },
{ USB_VENDOR_NI, USB_PRODUCT_NI_HTOH_7825 }
};
static int upl_match(device_t, cfdata_t, void *);
static void upl_attach(device_t, device_t, void *);
CFATTACH_DECL_NEW(upl, sizeof(struct usbnet), upl_match, upl_attach,
usbnet_detach, usbnet_activate);
#if 0
static void upl_uno_intr(struct usbnet *, usbd_status);
#endif
static void upl_uno_rx_loop(struct usbnet *, struct usbnet_chain *, uint32_t);
static unsigned upl_uno_tx_prepare(struct usbnet *, struct mbuf *,
struct usbnet_chain *);
static int upl_uno_ioctl(struct ifnet *, u_long, void *);
static int upl_uno_init(struct ifnet *);
static const struct usbnet_ops upl_ops = {
.uno_init = upl_uno_init,
.uno_tx_prepare = upl_uno_tx_prepare,
.uno_rx_loop = upl_uno_rx_loop,
.uno_ioctl = upl_uno_ioctl,
#if 0
.uno_intr = upl_uno_intr,
#endif
};
static int upl_output(struct ifnet *, struct mbuf *, const struct sockaddr *,
const struct rtentry *);
static void upl_input(struct ifnet *, struct mbuf *);
/*
* Probe for a Prolific chip.
*/
static int
upl_match(device_t parent, cfdata_t match, void *aux)
{
struct usb_attach_arg *uaa = aux;
return usb_lookup(sc_devs, uaa->uaa_vendor, uaa->uaa_product) != NULL ?
UMATCH_VENDOR_PRODUCT : UMATCH_NONE;
}
static void
upl_attach(device_t parent, device_t self, void *aux)
{
struct usbnet * const un = device_private(self);
struct usb_attach_arg *uaa = aux;
char *devinfop;
struct usbd_device * dev = uaa->uaa_device;
usbd_status err;
usb_interface_descriptor_t *id;
usb_endpoint_descriptor_t *ed;
int i;
DPRINTFN(5,(" : upl_attach: un=%p, dev=%p", un, dev));
aprint_naive("\n");
aprint_normal("\n");
devinfop = usbd_devinfo_alloc(dev, 0);
aprint_normal_dev(self, "%s\n", devinfop);
usbd_devinfo_free(devinfop);
un->un_dev = self;
un->un_udev = dev;
un->un_sc = un;
un->un_ops = &upl_ops;
un->un_rx_xfer_flags = USBD_SHORT_XFER_OK;
un->un_tx_xfer_flags = USBD_FORCE_SHORT_XFER;
un->un_rx_list_cnt = UPL_RX_LIST_CNT;
un->un_tx_list_cnt = UPL_TX_LIST_CNT;
un->un_rx_bufsz = UPL_BUFSZ;
un->un_tx_bufsz = UPL_BUFSZ;
err = usbd_set_config_no(dev, UPL_CONFIG_NO, 1);
if (err) {
aprint_error_dev(self, "failed to set configuration"
", err=%s\n", usbd_errstr(err));
return;
}
err = usbd_device2interface_handle(dev, UPL_IFACE_IDX, &un->un_iface);
if (err) {
aprint_error_dev(self, "getting interface handle failed\n");
return;
}
id = usbd_get_interface_descriptor(un->un_iface);
/* Find endpoints. */
for (i = 0; i < id->bNumEndpoints; i++) {
ed = usbd_interface2endpoint_descriptor(un->un_iface, i);
if (ed == NULL) {
aprint_error_dev(self, "couldn't get ep %d\n", i);
return;
}
if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
un->un_ed[USBNET_ENDPT_RX] = ed->bEndpointAddress;
} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
un->un_ed[USBNET_ENDPT_TX] = ed->bEndpointAddress;
}
}
if (un->un_ed[USBNET_ENDPT_RX] == 0 || un->un_ed[USBNET_ENDPT_TX] == 0 /*||
un->un_ed[USBNET_ENDPT_INTR] == 0*/) {
aprint_error_dev(self, "missing endpoint\n");
return;
}
usbnet_attach(un, "upldet");
/* Initialize interface info.*/
struct ifnet *ifp = usbnet_ifp(un);
ifp->if_mtu = UPL_BUFSZ;
ifp->if_type = IFT_OTHER;
ifp->if_addrlen = 0;
ifp->if_hdrlen = 0;
ifp->if_output = upl_output;
ifp->_if_input = upl_input;
ifp->if_baudrate = 12000000;
ifp->if_dlt = DLT_RAW;
usbnet_attach_ifp(un, IFF_POINTOPOINT | IFF_NOARP | IFF_SIMPLEX,
0, NULL);
}
static void
upl_uno_rx_loop(struct usbnet * un, struct usbnet_chain *c, uint32_t total_len)
{
DPRINTFN(9,("%s: %s: enter length=%d\n",
device_xname(un->un_dev), __func__, total_len));
usbnet_input(un, c->unc_buf, total_len);
}
static unsigned
upl_uno_tx_prepare(struct usbnet *un, struct mbuf *m, struct usbnet_chain *c)
{
int total_len;
if ((unsigned)m->m_pkthdr.len > un->un_tx_bufsz)
return 0;
m_copydata(m, 0, m->m_pkthdr.len, c->unc_buf);
total_len = m->m_pkthdr.len;
DPRINTFN(10,("%s: %s: total_len=%d\n",
device_xname(un->un_dev), __func__, total_len));
return total_len;
}
static int
upl_uno_init(struct ifnet *ifp)
{
struct usbnet * const un = ifp->if_softc;
int rv;
usbnet_lock_core(un);
if (usbnet_isdying(un))
rv = EIO;
else
rv = usbnet_init_rx_tx(un);
usbnet_unlock_core(un);
return rv;
}
static int
upl_uno_ioctl(struct ifnet *ifp, u_long cmd, void *data)
{
if (cmd == SIOCSIFMTU) {
struct ifreq *ifr = data;
if (ifr->ifr_mtu > UPL_BUFSZ)
return EINVAL;
}
return 0;
}
static int
upl_output(struct ifnet *ifp, struct mbuf *m, const struct sockaddr *dst,
const struct rtentry *rt0)
{
struct usbnet * const un __unused = ifp->if_softc;
DPRINTFN(10,("%s: %s: enter\n", device_xname(un->un_dev), __func__));
/* If the queueing discipline needs packet classification, do it now. */
IFQ_CLASSIFY(&ifp->if_snd, m, dst->sa_family);
/*
* Queue message on interface, and start output if interface
* not yet active.
*/
return if_transmit_lock(ifp, m);
}
static void
upl_input(struct ifnet *ifp, struct mbuf *m)
{
#ifdef INET
size_t pktlen = m->m_len;
int s;
s = splnet();
if (__predict_false(!pktq_enqueue(ip_pktq, m, 0))) {
if_statinc(ifp, if_iqdrops);
m_freem(m);
} else {
if_statadd2(ifp, if_ipackets, 1, if_ibytes, pktlen);
}
splx(s);
#endif
}
#ifdef _MODULE
#include "ioconf.c"
#endif
USBNET_MODULE(upl)
Reference in New Issue View Git Blame Copy Permalink