root/dev/usb/if_upl.c

DEFINITIONS

1. upl_match
2. upl_attach
3. upl_detach
4. upl_activate
5. upl_newbuf
6. upl_rx_list_init
7. upl_tx_list_init
8. upl_rxeof
9. upl_txeof
10. upl_send
11. upl_start
12. upl_init
13. upl_openpipes
14. upl_intr
15. upl_ioctl
16. upl_watchdog
17. upl_stop
18. upl_output
19. upl_input

    1 /*      $OpenBSD: if_upl.c,v 1.38 2007/06/14 10:11:15 mbalmer Exp $ */
    2 /*      $NetBSD: if_upl.c,v 1.19 2002/07/11 21:14:26 augustss Exp $     */
    3 /*
    4  * Copyright (c) 2000 The NetBSD Foundation, Inc.
    5  * All rights reserved.
    6  *
    7  * This code is derived from software contributed to The NetBSD Foundation
    8  * by Lennart Augustsson (lennart@augustsson.net) at
    9  * Carlstedt Research & Technology.
   10  *
   11  * Redistribution and use in source and binary forms, with or without
   12  * modification, are permitted provided that the following conditions
   13  * are met:
   14  * 1. Redistributions of source code must retain the above copyright
   15  *    notice, this list of conditions and the following disclaimer.
   16  * 2. Redistributions in binary form must reproduce the above copyright
   17  *    notice, this list of conditions and the following disclaimer in the
   18  *    documentation and/or other materials provided with the distribution.
   19  * 3. All advertising materials mentioning features or use of this software
   20  *    must display the following acknowledgement:
   21  *        This product includes software developed by the NetBSD
   22  *        Foundation, Inc. and its contributors.
   23  * 4. Neither the name of The NetBSD Foundation nor the names of its
   24  *    contributors may be used to endorse or promote products derived
   25  *    from this software without specific prior written permission.
   26  *
   27  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
   28  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   29  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   30  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
   31  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   32  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   33  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   34  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   35  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   36  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   37  * POSSIBILITY OF SUCH DAMAGE.
   38  */
   40 /*
   41  * Prolific PL2301/PL2302 driver
   42  */
   44 #include "bpfilter.h"
   46 #include <sys/param.h>
   47 #include <sys/systm.h>
   48 #include <sys/timeout.h>
   49 #include <sys/sockio.h>
   50 #include <sys/mbuf.h>
   51 #include <sys/malloc.h>
   52 #include <sys/kernel.h>
   53 #include <sys/socket.h>
   55 #include <sys/device.h>
   57 #include <net/if.h>
   58 #include <net/if_types.h>
   59 #include <net/if_dl.h>
   60 #include <net/netisr.h>
   62 #if NBPFILTER > 0
   63 #include <net/bpf.h>
   64 #endif
   66 #ifdef INET
   67 #include <netinet/in.h>
   68 #include <netinet/in_var.h>
   69 #include <netinet/in_systm.h>
   70 #include <netinet/ip.h>
   71 #include <netinet/if_ether.h>
   72 #else
   73 #error upl without INET?
   74 #endif
   76 #include <dev/usb/usb.h>
   77 #include <dev/usb/usbdi.h>
   78 #include <dev/usb/usbdi_util.h>
   79 #include <dev/usb/usbdevs.h>
   81 /*
   82  * 7  6  5  4  3  2  1  0
   83  * tx rx 1  0
   84  * 1110 0000 rxdata
   85  * 1010 0000 idle
   86  * 0010 0000 tx over
   87  * 0110      tx over + rxd
   88  */
   90 #define UPL_RXDATA              0x40
   91 #define UPL_TXOK                0x80
   93 #define UPL_INTR_PKTLEN         1
   95 #define UPL_CONFIG_NO           1
   96 #define UPL_IFACE_IDX           0
   98 /***/
  100 #define UPL_INTR_INTERVAL       20
  102 #define UPL_BUFSZ               1024
  104 #define UPL_RX_FRAMES           1
  105 #define UPL_TX_FRAMES           1
  107 #define UPL_RX_LIST_CNT         1
  108 #define UPL_TX_LIST_CNT         1
  110 #define UPL_ENDPT_RX            0x0
  111 #define UPL_ENDPT_TX            0x1
  112 #define UPL_ENDPT_INTR          0x2
  113 #define UPL_ENDPT_MAX           0x3
  115 struct upl_type {
u_int16_t               upl_vid;
u_int16_t               upl_did;
  118 };
  120 struct upl_softc;
  122 struct upl_chain {
  123         struct upl_softc        *upl_sc;
usbd_xfer_handle        upl_xfer;
  125         char                    *upl_buf;
  126         struct mbuf             *upl_mbuf;
  127         int                     upl_idx;
  128 };
  130 struct upl_cdata {
  131         struct upl_chain        upl_tx_chain[UPL_TX_LIST_CNT];
  132         struct upl_chain        upl_rx_chain[UPL_RX_LIST_CNT];
  133         int                     upl_tx_prod;
  134         int                     upl_tx_cons;
  135         int                     upl_tx_cnt;
  136         int                     upl_rx_prod;
  137 };
  139 struct upl_softc {
  140         struct device           sc_dev;
  142         struct ifnet            sc_if;
  143         struct timeout          sc_stat_ch;
usbd_device_handle      sc_udev;
usbd_interface_handle   sc_iface;
u_int16_t               sc_vendor;
u_int16_t               sc_product;
  149         int                     sc_ed[UPL_ENDPT_MAX];
usbd_pipe_handle        sc_ep[UPL_ENDPT_MAX];
  151         struct upl_cdata        sc_cdata;
uByte                   sc_ibuf;
  155         char                    sc_dying;
  156         char                    sc_attached;
u_int                   sc_rx_errs;
  158         struct timeval          sc_rx_notice;
u_int                   sc_intr_errs;
  160 };
  162 #ifdef UPL_DEBUG
  163 #define DPRINTF(x)      do { if (upldebug) printf x; } while (0)
  164 #define DPRINTFN(n,x)   do { if (upldebug >= (n)) printf x; } while (0)
  165 int     upldebug = 0;
  166 #else
  167 #define DPRINTF(x)
  168 #define DPRINTFN(n,x)
  169 #endif
  171 /*
  172  * Various supported device vendors/products.
  173  */
  174 struct upl_type sc_devs[] = {
  175         { USB_VENDOR_PROLIFIC, USB_PRODUCT_PROLIFIC_PL2301 },
  176         { USB_VENDOR_PROLIFIC, USB_PRODUCT_PROLIFIC_PL2302 },
  177         { 0, 0 }
  178 };
  180 int upl_match(struct device *, void *, void *); 
  181 void upl_attach(struct device *, struct device *, void *); 
  182 int upl_detach(struct device *, int); 
  183 int upl_activate(struct device *, enum devact); 
  185 struct cfdriver upl_cd = { 
NULL, "upl", DV_IFNET 
  187 }; 
  189 const struct cfattach upl_ca = { 
  190         sizeof(struct upl_softc), 
upl_match, 
upl_attach, 
upl_detach, 
upl_activate, 
  195 };
  197 int upl_openpipes(struct upl_softc *);
  198 int upl_tx_list_init(struct upl_softc *);
  199 int upl_rx_list_init(struct upl_softc *);
  200 int upl_newbuf(struct upl_softc *, struct upl_chain *, struct mbuf *);
  201 int upl_send(struct upl_softc *, struct mbuf *, int);
  202 void upl_intr(usbd_xfer_handle, usbd_private_handle, usbd_status);
  203 void upl_rxeof(usbd_xfer_handle, usbd_private_handle, usbd_status);
  204 void upl_txeof(usbd_xfer_handle, usbd_private_handle, usbd_status);
  205 void upl_start(struct ifnet *);
  206 int upl_ioctl(struct ifnet *, u_long, caddr_t);
  207 void upl_init(void *);
  208 void upl_stop(struct upl_softc *);
  209 void upl_watchdog(struct ifnet *);
  211 int upl_output(struct ifnet *, struct mbuf *, struct sockaddr *,
  212                       struct rtentry *);
  213 void upl_input(struct ifnet *, struct mbuf *);
  215 /*
  216  * Probe for a Prolific chip.
  217  */
  218 int
upl_match(struct device *parent, void *match, void *aux)
  220 {
  221         struct usb_attach_arg           *uaa = aux;
  222         struct upl_type                 *t;
  224         if (uaa->iface != NULL)
  225                 return (UMATCH_NONE);
  227         for (t = sc_devs; t->upl_vid != 0; t++)
  228                 if (uaa->vendor == t->upl_vid && uaa->product == t->upl_did)
  229                         return (UMATCH_VENDOR_PRODUCT);
  231         return (UMATCH_NONE);
  232 }
  234 void
upl_attach(struct device *parent, struct device *self, void *aux)
  236 {
  237         struct upl_softc        *sc = (struct upl_softc *)self;
  238         struct usb_attach_arg   *uaa = aux;
  239         char                    *devinfop;
  240         int                     s;
usbd_device_handle      dev = uaa->device;
usbd_interface_handle   iface;
usbd_status             err;
  244         struct ifnet            *ifp;
usb_interface_descriptor_t      *id;
usb_endpoint_descriptor_t       *ed;
  247         int                     i;
DPRINTFN(5,(" : upl_attach: sc=%p, dev=%p", sc, dev));
devinfop = usbd_devinfo_alloc(dev, 0);
printf("\n%s: %s\n", sc->sc_dev.dv_xname, devinfop);
usbd_devinfo_free(devinfop);
err = usbd_set_config_no(dev, UPL_CONFIG_NO, 1);
  256         if (err) {
printf("%s: setting config no failed\n",
sc->sc_dev.dv_xname);
  259                 return;
  260         }
sc->sc_udev = dev;
sc->sc_product = uaa->product;
sc->sc_vendor = uaa->vendor;
err = usbd_device2interface_handle(dev, UPL_IFACE_IDX, &iface);
  267         if (err) {
printf("%s: getting interface handle failed\n",
sc->sc_dev.dv_xname);
  270                 return;
  271         }
sc->sc_iface = iface;
id = usbd_get_interface_descriptor(iface);
  276         /* Find endpoints. */
  277         for (i = 0; i < id->bNumEndpoints; i++) {
ed = usbd_interface2endpoint_descriptor(iface, i);
  279                 if (ed == NULL) {
printf("%s: couldn't get ep %d\n",
sc->sc_dev.dv_xname, i);
  282                         return;
  283                 }
  284                 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
sc->sc_ed[UPL_ENDPT_RX] = ed->bEndpointAddress;
  287                 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
sc->sc_ed[UPL_ENDPT_TX] = ed->bEndpointAddress;
  290                 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
sc->sc_ed[UPL_ENDPT_INTR] = ed->bEndpointAddress;
  293                 }
  294         }
  296         if (sc->sc_ed[UPL_ENDPT_RX] == 0 || sc->sc_ed[UPL_ENDPT_TX] == 0 ||
sc->sc_ed[UPL_ENDPT_INTR] == 0) {
printf("%s: missing endpoint\n", sc->sc_dev.dv_xname);
  299                 return;
  300         }
s = splnet();
  304         /* Initialize interface info.*/
ifp = &sc->sc_if;
ifp->if_softc = sc;
ifp->if_mtu = UPL_BUFSZ;
ifp->if_flags = IFF_POINTOPOINT | IFF_NOARP | IFF_SIMPLEX;
ifp->if_ioctl = upl_ioctl;
ifp->if_start = upl_start;
ifp->if_watchdog = upl_watchdog;
strlcpy(ifp->if_xname, sc->sc_dev.dv_xname, IFNAMSIZ);
ifp->if_type = IFT_OTHER;
ifp->if_addrlen = 0;
ifp->if_hdrlen = 0;
ifp->if_output = upl_output;
ifp->if_baudrate = 12000000;
IFQ_SET_READY(&ifp->if_snd);
  321         /* Attach the interface. */
if_attach(ifp);
if_alloc_sadl(ifp);
sc->sc_attached = 1;
splx(s);
usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev,
  329             &sc->sc_dev);
  330 }
  332 int
upl_detach(struct device *self, int flags)
  334 {
  335         struct upl_softc        *sc = (struct upl_softc *)self;
  336         struct ifnet            *ifp = &sc->sc_if;
  337         int                     s;
DPRINTFN(2,("%s: %s: enter\n", sc->sc_dev.dv_xname, __func__));
s = splusb();
  343         if (!sc->sc_attached) {
  344                 /* Detached before attached finished, so just bail out. */
splx(s);
  346                 return (0);
  347         }
  349         if (ifp->if_flags & IFF_RUNNING)
upl_stop(sc);
if_detach(ifp);
  354 #ifdef DIAGNOSTIC
  355         if (sc->sc_ep[UPL_ENDPT_TX] != NULL ||
sc->sc_ep[UPL_ENDPT_RX] != NULL ||
sc->sc_ep[UPL_ENDPT_INTR] != NULL)
printf("%s: detach has active endpoints\n",
sc->sc_dev.dv_xname);
  360 #endif
sc->sc_attached = 0;
splx(s);
usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
  366             &sc->sc_dev);
  368         return (0);
  369 }
  371 int
upl_activate(struct device *self, enum devact act)
  373 {
  374         struct upl_softc *sc = (struct upl_softc *)self;
DPRINTFN(2,("%s: %s: enter\n", sc->sc_dev.dv_xname, __func__));
  378         switch (act) {
  379         case DVACT_ACTIVATE:
  380                 break;
  382         case DVACT_DEACTIVATE:
sc->sc_dying = 1;
  384                 break;
  385         }
  386         return (0);
  387 }
  389 /*
  390  * Initialize an RX descriptor and attach an MBUF cluster.
  391  */
  392 int
upl_newbuf(struct upl_softc *sc, struct upl_chain *c, struct mbuf *m)
  394 {
  395         struct mbuf             *m_new = NULL;
DPRINTFN(8,("%s: %s: enter\n", sc->sc_dev.dv_xname, __func__));
  399         if (m == NULL) {
MGETHDR(m_new, M_DONTWAIT, MT_DATA);
  401                 if (m_new == NULL) {
printf("%s: no memory for rx list "
  403                             "-- packet dropped!\n", sc->sc_dev.dv_xname);
  404                         return (ENOBUFS);
  405                 }
MCLGET(m_new, M_DONTWAIT);
  408                 if (!(m_new->m_flags & M_EXT)) {
printf("%s: no memory for rx list "
  410                             "-- packet dropped!\n", sc->sc_dev.dv_xname);
m_freem(m_new);
  412                         return (ENOBUFS);
  413                 }
m_new->m_len = m_new->m_pkthdr.len = MCLBYTES;
  415         } else {
m_new = m;
m_new->m_len = m_new->m_pkthdr.len = MCLBYTES;
m_new->m_data = m_new->m_ext.ext_buf;
  419         }
c->upl_mbuf = m_new;
  423         return (0);
  424 }
  426 int
upl_rx_list_init(struct upl_softc *sc)
  428 {
  429         struct upl_cdata        *cd;
  430         struct upl_chain        *c;
  431         int                     i;
DPRINTFN(5,("%s: %s: enter\n", sc->sc_dev.dv_xname, __func__));
cd = &sc->sc_cdata;
  436         for (i = 0; i < UPL_RX_LIST_CNT; i++) {
c = &cd->upl_rx_chain[i];
c->upl_sc = sc;
c->upl_idx = i;
  440                 if (upl_newbuf(sc, c, NULL) == ENOBUFS)
  441                         return (ENOBUFS);
  442                 if (c->upl_xfer == NULL) {
c->upl_xfer = usbd_alloc_xfer(sc->sc_udev);
  444                         if (c->upl_xfer == NULL)
  445                                 return (ENOBUFS);
c->upl_buf = usbd_alloc_buffer(c->upl_xfer, UPL_BUFSZ);
  447                         if (c->upl_buf == NULL) {
usbd_free_xfer(c->upl_xfer);
  449                                 return (ENOBUFS);
  450                         }
  451                 }
  452         }
  454         return (0);
  455 }
  457 int
upl_tx_list_init(struct upl_softc *sc)
  459 {
  460         struct upl_cdata        *cd;
  461         struct upl_chain        *c;
  462         int                     i;
DPRINTFN(5,("%s: %s: enter\n", sc->sc_dev.dv_xname, __func__));
cd = &sc->sc_cdata;
  467         for (i = 0; i < UPL_TX_LIST_CNT; i++) {
c = &cd->upl_tx_chain[i];
c->upl_sc = sc;
c->upl_idx = i;
c->upl_mbuf = NULL;
  472                 if (c->upl_xfer == NULL) {
c->upl_xfer = usbd_alloc_xfer(sc->sc_udev);
  474                         if (c->upl_xfer == NULL)
  475                                 return (ENOBUFS);
c->upl_buf = usbd_alloc_buffer(c->upl_xfer, UPL_BUFSZ);
  477                         if (c->upl_buf == NULL) {
usbd_free_xfer(c->upl_xfer);
  479                                 return (ENOBUFS);
  480                         }
  481                 }
  482         }
  484         return (0);
  485 }
  487 /*
  488  * A frame has been uploaded: pass the resulting mbuf chain up to
  489  * the higher level protocols.
  490  */
  491 void
upl_rxeof(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
  493 {
  494         struct upl_chain        *c = priv;
  495         struct upl_softc        *sc = c->upl_sc;
  496         struct ifnet            *ifp = &sc->sc_if;
  497         struct mbuf             *m;
  498         int                     total_len = 0;
  499         int                     s;
  501         if (sc->sc_dying)
  502                 return;
  504         if (!(ifp->if_flags & IFF_RUNNING))
  505                 return;
  507         if (status != USBD_NORMAL_COMPLETION) {
  508                 if (status == USBD_NOT_STARTED || status == USBD_CANCELLED)
  509                         return;
sc->sc_rx_errs++;
  511                 if (usbd_ratecheck(&sc->sc_rx_notice)) {
printf("%s: %u usb errors on rx: %s\n",
sc->sc_dev.dv_xname, sc->sc_rx_errs,
usbd_errstr(status));
sc->sc_rx_errs = 0;
  516                 }
  517                 if (status == USBD_STALLED)
usbd_clear_endpoint_stall_async(sc->sc_ep[UPL_ENDPT_RX]);
  519                 goto done;
  520         }
usbd_get_xfer_status(xfer, NULL, NULL, &total_len, NULL);
DPRINTFN(9,("%s: %s: enter status=%d length=%d\n",
sc->sc_dev.dv_xname, __func__, status, total_len));
m = c->upl_mbuf;
memcpy(mtod(c->upl_mbuf, char *), c->upl_buf, total_len);
ifp->if_ipackets++;
m->m_pkthdr.len = m->m_len = total_len;
m->m_pkthdr.rcvif = ifp;
s = splnet();
  537         /* XXX ugly */
  538         if (upl_newbuf(sc, c, NULL) == ENOBUFS) {
ifp->if_ierrors++;
  540                 goto done1;
  541         }
  543 #if NBPFILTER > 0
  544         /*
  545          * Handle BPF listeners. Let the BPF user see the packet, but
  546          * don't pass it up to the ether_input() layer unless it's
  547          * a broadcast packet, multicast packet, matches our ethernet
  548          * address or the interface is in promiscuous mode.
  549          */
  550         if (ifp->if_bpf) {
bpf_mtap(ifp->if_bpf, m, BPF_DIRECTION_IN);
  552         }
  553 #endif
DPRINTFN(10,("%s: %s: deliver %d\n", sc->sc_dev.dv_xname,
__func__, m->m_len));
ether_input_mbuf(ifp, m);
done1:
splx(s);
done:
  564 #if 1
  565         /* Setup new transfer. */
usbd_setup_xfer(c->upl_xfer, sc->sc_ep[UPL_ENDPT_RX],
c, c->upl_buf, UPL_BUFSZ, USBD_SHORT_XFER_OK | USBD_NO_COPY,
USBD_NO_TIMEOUT, upl_rxeof);
usbd_transfer(c->upl_xfer);
DPRINTFN(10,("%s: %s: start rx\n", sc->sc_dev.dv_xname,
__func__));
  573 #endif
  574 }
  576 /*
  577  * A frame was downloaded to the chip. It's safe for us to clean up
  578  * the list buffers.
  579  */
  580 void
upl_txeof(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
  582 {
  583         struct upl_chain        *c = priv;
  584         struct upl_softc        *sc = c->upl_sc;
  585         struct ifnet            *ifp = &sc->sc_if;
  586         int                     s;
  588         if (sc->sc_dying)
  589                 return;
s = splnet();
DPRINTFN(10,("%s: %s: enter status=%d\n", sc->sc_dev.dv_xname,
__func__, status));
ifp->if_timer = 0;
ifp->if_flags &= ~IFF_OACTIVE;
  599         if (status != USBD_NORMAL_COMPLETION) {
  600                 if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) {
splx(s);
  602                         return;
  603                 }
ifp->if_oerrors++;
printf("%s: usb error on tx: %s\n", sc->sc_dev.dv_xname,
usbd_errstr(status));
  607                 if (status == USBD_STALLED)
usbd_clear_endpoint_stall_async(sc->sc_ep[UPL_ENDPT_TX]);
splx(s);
  610                 return;
  611         }
ifp->if_opackets++;
m_freem(c->upl_mbuf);
c->upl_mbuf = NULL;
  618         if (IFQ_IS_EMPTY(&ifp->if_snd) == 0)
upl_start(ifp);
splx(s);
  622 }
  624 int
upl_send(struct upl_softc *sc, struct mbuf *m, int idx)
  626 {
  627         int                     total_len;
  628         struct upl_chain        *c;
usbd_status             err;
c = &sc->sc_cdata.upl_tx_chain[idx];
  633         /*
  634          * Copy the mbuf data into a contiguous buffer, leaving two
  635          * bytes at the beginning to hold the frame length.
  636          */
m_copydata(m, 0, m->m_pkthdr.len, c->upl_buf);
c->upl_mbuf = m;
total_len = m->m_pkthdr.len;
DPRINTFN(10,("%s: %s: total_len=%d\n",
sc->sc_dev.dv_xname, __func__, total_len));
usbd_setup_xfer(c->upl_xfer, sc->sc_ep[UPL_ENDPT_TX],
c, c->upl_buf, total_len, USBD_NO_COPY, USBD_DEFAULT_TIMEOUT,
upl_txeof);
  649         /* Transmit */
err = usbd_transfer(c->upl_xfer);
  651         if (err != USBD_IN_PROGRESS) {
printf("%s: upl_send error=%s\n", sc->sc_dev.dv_xname,
usbd_errstr(err));
upl_stop(sc);
  655                 return (EIO);
  656         }
sc->sc_cdata.upl_tx_cnt++;
  660         return (0);
  661 }
  663 void
upl_start(struct ifnet *ifp)
  665 {
  666         struct upl_softc        *sc = ifp->if_softc;
  667         struct mbuf             *m_head = NULL;
  669         if (sc->sc_dying)
  670                 return;
DPRINTFN(10,("%s: %s: enter\n", sc->sc_dev.dv_xname,__func__));
  674         if (ifp->if_flags & IFF_OACTIVE)
  675                 return;
IFQ_POLL(&ifp->if_snd, m_head);
  678         if (m_head == NULL)
  679                 return;
  681         if (upl_send(sc, m_head, 0)) {
ifp->if_flags |= IFF_OACTIVE;
  683                 return;
  684         }
IFQ_DEQUEUE(&ifp->if_snd, m_head);
  688 #if NBPFILTER > 0
  689         /*
  690          * If there's a BPF listener, bounce a copy of this frame
  691          * to him.
  692          */
  693         if (ifp->if_bpf)
bpf_mtap(ifp->if_bpf, m_head, BPF_DIRECTION_OUT);
  695 #endif
ifp->if_flags |= IFF_OACTIVE;
  699         /*
  700          * Set a timeout in case the chip goes out to lunch.
  701          */
ifp->if_timer = 5;
  703 }
  705 void
upl_init(void *xsc)
  707 {
  708         struct upl_softc        *sc = xsc;
  709         struct ifnet            *ifp = &sc->sc_if;
  710         int                     s;
  712         if (sc->sc_dying)
  713                 return;
DPRINTFN(10,("%s: %s: enter\n", sc->sc_dev.dv_xname,__func__));
  717         if (ifp->if_flags & IFF_RUNNING)
  718                 return;
s = splnet();
  722         /* Init TX ring. */
  723         if (upl_tx_list_init(sc) == ENOBUFS) {
printf("%s: tx list init failed\n", sc->sc_dev.dv_xname);
splx(s);
  726                 return;
  727         }
  729         /* Init RX ring. */
  730         if (upl_rx_list_init(sc) == ENOBUFS) {
printf("%s: rx list init failed\n", sc->sc_dev.dv_xname);
splx(s);
  733                 return;
  734         }
  736         if (sc->sc_ep[UPL_ENDPT_RX] == NULL) {
  737                 if (upl_openpipes(sc)) {
splx(s);
  739                         return;
  740                 }
  741         }
ifp->if_flags |= IFF_RUNNING;
ifp->if_flags &= ~IFF_OACTIVE;
splx(s);
  747 }
  749 int
upl_openpipes(struct upl_softc *sc)
  751 {
  752         struct upl_chain        *c;
usbd_status             err;
  754         int                     i;
  756         /* Open RX and TX pipes. */
err = usbd_open_pipe(sc->sc_iface, sc->sc_ed[UPL_ENDPT_RX],
USBD_EXCLUSIVE_USE, &sc->sc_ep[UPL_ENDPT_RX]);
  759         if (err) {
printf("%s: open rx pipe failed: %s\n",
sc->sc_dev.dv_xname, usbd_errstr(err));
  762                 return (EIO);
  763         }
err = usbd_open_pipe(sc->sc_iface, sc->sc_ed[UPL_ENDPT_TX],
USBD_EXCLUSIVE_USE, &sc->sc_ep[UPL_ENDPT_TX]);
  766         if (err) {
printf("%s: open tx pipe failed: %s\n",
sc->sc_dev.dv_xname, usbd_errstr(err));
  769                 return (EIO);
  770         }
err = usbd_open_pipe_intr(sc->sc_iface, sc->sc_ed[UPL_ENDPT_INTR],
USBD_EXCLUSIVE_USE, &sc->sc_ep[UPL_ENDPT_INTR], sc,
  773             &sc->sc_ibuf, UPL_INTR_PKTLEN, upl_intr,
UPL_INTR_INTERVAL);
  775         if (err) {
printf("%s: open intr pipe failed: %s\n",
sc->sc_dev.dv_xname, usbd_errstr(err));
  778                 return (EIO);
  779         }
  782 #if 1
  783         /* Start up the receive pipe. */
  784         for (i = 0; i < UPL_RX_LIST_CNT; i++) {
c = &sc->sc_cdata.upl_rx_chain[i];
usbd_setup_xfer(c->upl_xfer, sc->sc_ep[UPL_ENDPT_RX],
c, c->upl_buf, UPL_BUFSZ,
USBD_SHORT_XFER_OK | USBD_NO_COPY, USBD_NO_TIMEOUT,
upl_rxeof);
usbd_transfer(c->upl_xfer);
  791         }
  792 #endif
  794         return (0);
  795 }
  797 void
upl_intr(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
  799 {
  800         struct upl_softc        *sc = priv;
  801         struct ifnet            *ifp = &sc->sc_if;
uByte                   stat;
DPRINTFN(15,("%s: %s: enter\n", sc->sc_dev.dv_xname,__func__));
  806         if (sc->sc_dying)
  807                 return;
  809         if (!(ifp->if_flags & IFF_RUNNING))
  810                 return;
  812         if (status != USBD_NORMAL_COMPLETION) {
  813                 if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) {
  814                         return;
  815                 }
sc->sc_intr_errs++;
  817                 if (usbd_ratecheck(&sc->sc_rx_notice)) {
printf("%s: %u usb errors on intr: %s\n",
sc->sc_dev.dv_xname, sc->sc_rx_errs,
usbd_errstr(status));
sc->sc_intr_errs = 0;
  822                 }
  823                 if (status == USBD_STALLED)
usbd_clear_endpoint_stall_async(sc->sc_ep[UPL_ENDPT_RX]);
  825                 return;
  826         }
stat = sc->sc_ibuf;
  830         if (stat == 0)
  831                 return;
DPRINTFN(10,("%s: %s: stat=0x%02x\n", sc->sc_dev.dv_xname,
__func__, stat));
  836 }
  838 int
upl_ioctl(struct ifnet *ifp, u_long command, caddr_t data)
  840 {
  841         struct upl_softc        *sc = ifp->if_softc;
  842         struct ifaddr           *ifa = (struct ifaddr *)data;
  843         struct ifreq            *ifr = (struct ifreq *)data;
  844         int                     s, error = 0;
  846         if (sc->sc_dying)
  847                 return (EIO);
DPRINTFN(5,("%s: %s: cmd=0x%08lx\n",
sc->sc_dev.dv_xname, __func__, command));
s = splnet();
  854         switch(command) {
  855         case SIOCSIFADDR:
ifp->if_flags |= IFF_UP;
upl_init(sc);
  859                 switch (ifa->ifa_addr->sa_family) {
  860 #ifdef INET
  861                 case AF_INET:
  862                         break;
  863 #endif /* INET */
  864                 }
  865                 break;
  867         case SIOCSIFMTU:
  868                 if (ifr->ifr_mtu > UPL_BUFSZ)
error = EINVAL;
  870                 else
ifp->if_mtu = ifr->ifr_mtu;
  872                 break;
  874         case SIOCSIFFLAGS:
  875                 if (ifp->if_flags & IFF_UP) {
  876                         if (!(ifp->if_flags & IFF_RUNNING))
upl_init(sc);
  878                 } else {
  879                         if (ifp->if_flags & IFF_RUNNING)
upl_stop(sc);
  881                 }
error = 0;
  883                 break;
  884         default:
error = EINVAL;
  886                 break;
  887         }
splx(s);
  891         return (error);
  892 }
  894 void
upl_watchdog(struct ifnet *ifp)
  896 {
  897         struct upl_softc        *sc = ifp->if_softc;
DPRINTFN(5,("%s: %s: enter\n", sc->sc_dev.dv_xname,__func__));
  901         if (sc->sc_dying)
  902                 return;
ifp->if_oerrors++;
printf("%s: watchdog timeout\n", sc->sc_dev.dv_xname);
upl_stop(sc);
upl_init(sc);
  910         if (IFQ_IS_EMPTY(&ifp->if_snd) == 0)
upl_start(ifp);
  912 }
  914 /*
  915  * Stop the adapter and free any mbufs allocated to the
  916  * RX and TX lists.
  917  */
  918 void
upl_stop(struct upl_softc *sc)
  920 {
usbd_status             err;
  922         struct ifnet            *ifp;
  923         int                     i;
DPRINTFN(10,("%s: %s: enter\n", sc->sc_dev.dv_xname,__func__));
ifp = &sc->sc_if;
ifp->if_timer = 0;
ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
  931         /* Stop transfers. */
  932         if (sc->sc_ep[UPL_ENDPT_RX] != NULL) {
err = usbd_abort_pipe(sc->sc_ep[UPL_ENDPT_RX]);
  934                 if (err) {
printf("%s: abort rx pipe failed: %s\n",
sc->sc_dev.dv_xname, usbd_errstr(err));
  937                 }
err = usbd_close_pipe(sc->sc_ep[UPL_ENDPT_RX]);
  939                 if (err) {
printf("%s: close rx pipe failed: %s\n",
sc->sc_dev.dv_xname, usbd_errstr(err));
  942                 }
sc->sc_ep[UPL_ENDPT_RX] = NULL;
  944         }
  946         if (sc->sc_ep[UPL_ENDPT_TX] != NULL) {
err = usbd_abort_pipe(sc->sc_ep[UPL_ENDPT_TX]);
  948                 if (err) {
printf("%s: abort tx pipe failed: %s\n",
sc->sc_dev.dv_xname, usbd_errstr(err));
  951                 }
err = usbd_close_pipe(sc->sc_ep[UPL_ENDPT_TX]);
  953                 if (err) {
printf("%s: close tx pipe failed: %s\n",
sc->sc_dev.dv_xname, usbd_errstr(err));
  956                 }
sc->sc_ep[UPL_ENDPT_TX] = NULL;
  958         }
  960         if (sc->sc_ep[UPL_ENDPT_INTR] != NULL) {
err = usbd_abort_pipe(sc->sc_ep[UPL_ENDPT_INTR]);
  962                 if (err) {
printf("%s: abort intr pipe failed: %s\n",
sc->sc_dev.dv_xname, usbd_errstr(err));
  965                 }
err = usbd_close_pipe(sc->sc_ep[UPL_ENDPT_INTR]);
  967                 if (err) {
printf("%s: close intr pipe failed: %s\n",
sc->sc_dev.dv_xname, usbd_errstr(err));
  970                 }
sc->sc_ep[UPL_ENDPT_INTR] = NULL;
  972         }
  974         /* Free RX resources. */
  975         for (i = 0; i < UPL_RX_LIST_CNT; i++) {
  976                 if (sc->sc_cdata.upl_rx_chain[i].upl_mbuf != NULL) {
m_freem(sc->sc_cdata.upl_rx_chain[i].upl_mbuf);
sc->sc_cdata.upl_rx_chain[i].upl_mbuf = NULL;
  979                 }
  980                 if (sc->sc_cdata.upl_rx_chain[i].upl_xfer != NULL) {
usbd_free_xfer(sc->sc_cdata.upl_rx_chain[i].upl_xfer);
sc->sc_cdata.upl_rx_chain[i].upl_xfer = NULL;
  983                 }
  984         }
  986         /* Free TX resources. */
  987         for (i = 0; i < UPL_TX_LIST_CNT; i++) {
  988                 if (sc->sc_cdata.upl_tx_chain[i].upl_mbuf != NULL) {
m_freem(sc->sc_cdata.upl_tx_chain[i].upl_mbuf);
sc->sc_cdata.upl_tx_chain[i].upl_mbuf = NULL;
  991                 }
  992                 if (sc->sc_cdata.upl_tx_chain[i].upl_xfer != NULL) {
usbd_free_xfer(sc->sc_cdata.upl_tx_chain[i].upl_xfer);
sc->sc_cdata.upl_tx_chain[i].upl_xfer = NULL;
  995                 }
  996         }
  997 }
  999 int
upl_output(struct ifnet *ifp, struct mbuf *m, struct sockaddr *dst,
 1001            struct rtentry *rt0)
 1002 {
 1003         int s, len, error;
DPRINTFN(10,("%s: %s: enter\n",
 1006                      ((struct upl_softc *)ifp->if_softc)->sc_dev.dv_xname,
__func__));
len = m->m_pkthdr.len;
s = splnet();
 1011         /*
 1012          * Queue message on interface, and start output if interface
 1013          * not yet active.
 1014          */
IFQ_ENQUEUE(&ifp->if_snd, m, NULL, error);
 1016         if (error) {
 1017                 /* mbuf is already freed */
splx(s);
 1019                 return (error);
 1020         }
ifp->if_obytes += len;
 1022         if ((ifp->if_flags & IFF_OACTIVE) == 0)
 1023                 (*ifp->if_start)(ifp);
splx(s);
 1026         return (0);
 1027 }
 1029 void
upl_input(struct ifnet *ifp, struct mbuf *m)
 1031 {
 1032         struct ifqueue *inq;
 1033         int s;
 1035         /* XXX Assume all traffic is IP */
schednetisr(NETISR_IP);
inq = &ipintrq;
s = splnet();
 1041         if (IF_QFULL(inq)) {
IF_DROP(inq);
splx(s);
 1044 #if 0
 1045                 if (sc->sc_flags & SC_DEBUG)
printf("%s: input queue full\n", ifp->if_xname);
 1047 #endif
ifp->if_iqdrops++;
 1049                 return;
 1050         }
IF_ENQUEUE(inq, m);
splx(s);
ifp->if_ipackets++;
ifp->if_ibytes += m->m_len;
 1055 }