usb_ethersubr.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10

    1 /*-
    2  * Copyright (c) 1997, 1998, 1999, 2000
    3  *      Bill Paul <wpaul@ee.columbia.edu>.  All rights reserved.
    4  *
    5  * Redistribution and use in source and binary forms, with or without
    6  * modification, are permitted provided that the following conditions
    7  * are met:
    8  * 1. Redistributions of source code must retain the above copyright
    9  *    notice, this list of conditions and the following disclaimer.
   10  * 2. Redistributions in binary form must reproduce the above copyright
   11  *    notice, this list of conditions and the following disclaimer in the
   12  *    documentation and/or other materials provided with the distribution.
   13  * 3. All advertising materials mentioning features or use of this software
   14  *    must display the following acknowledgement:
   15  *      This product includes software developed by Bill Paul.
   16  * 4. Neither the name of the author nor the names of any co-contributors
   17  *    may be used to endorse or promote products derived from this software
   18  *    without specific prior written permission.
   19  *
   20  * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND
   21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   23  * ARE DISCLAIMED.  IN NO EVENT SHALL Bill Paul OR THE VOICES IN HIS HEAD
   24  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   25  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   26  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   27  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   28  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   29  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
   30  * THE POSSIBILITY OF SUCH DAMAGE.
   31  */
   32 
   33 #include <sys/cdefs.h>
   34 __FBSDID("$FreeBSD: releng/7.3/sys/dev/usb/usb_ethersubr.c 165901 2007-01-08 23:21:06Z alfred $");
   35 
   36 /*
   37  * Callbacks in the USB code operate at splusb() (actually splbio()
   38  * in FreeBSD). However adding packets to the input queues has to be
   39  * done at splimp(). It is conceivable that this arrangement could
   40  * trigger a condition where the splimp() is ignored and the input
   41  * queues could get trampled in spite of our best effors to prevent
   42  * it. To work around this, we implement a special input queue for
   43  * USB ethernet adapter drivers. Rather than passing the frames directly
   44  * to ether_input(), we pass them here, then schedule a soft interrupt
   45  * to hand them to ether_input() later, outside of the USB interrupt
   46  * context.
   47  *
   48  * It's questional as to whether this code should be expanded to
   49  * handle other kinds of devices, or handle USB transfer callbacks
   50  * in general. Right now, I need USB network interfaces to work
   51  * properly.
   52  */
   53 
   54 #include <sys/param.h>
   55 #include <sys/systm.h>
   56 #include <sys/sockio.h>
   57 #include <sys/mbuf.h>
   58 #include <sys/malloc.h>
   59 #include <sys/socket.h>
   60 #include <sys/taskqueue.h>
   61 
   62 #include <net/if.h>
   63 #include <net/if_types.h>
   64 #include <net/if_arp.h>
   65 #include <net/ethernet.h>
   66 #include <net/netisr.h>
   67 #include <net/bpf.h>
   68 
   69 #include <dev/usb/usb.h>
   70 #include <dev/usb/usb_ethersubr.h>
   71 
   72 static struct ifqueue usbq_rx;
   73 static struct ifqueue usbq_tx;
   74 static int mtx_inited = 0;
   75 
   76 static void usbintr             (void);
   77 
   78 static void
   79 usbintr(void)
   80 {
   81         struct mbuf             *m;
   82         struct usb_qdat         *q;
   83         struct ifnet            *ifp;
   84 
   85         /* Check the RX queue */
   86         while(1) {
   87                 IF_DEQUEUE(&usbq_rx, m);
   88                 if (m == NULL)
   89                         break;
   90                 q = (struct usb_qdat *)m->m_pkthdr.rcvif;
   91                 ifp = q->ifp;
   92                 m->m_pkthdr.rcvif = ifp;
   93                 (*ifp->if_input)(ifp, m);
   94 
   95                 /* Re-arm the receiver */
   96                 (*q->if_rxstart)(ifp);
   97                 if (ifp->if_snd.ifq_head != NULL)
   98                         (*ifp->if_start)(ifp);
   99         }
  100 
  101         /* Check the TX queue */
  102         while(1) {
  103                 IF_DEQUEUE(&usbq_tx, m);
  104                 if (m == NULL)
  105                         break;
  106                 ifp = m->m_pkthdr.rcvif;
  107                 m_freem(m);
  108                 if (ifp->if_snd.ifq_head != NULL)
  109                         (*ifp->if_start)(ifp);
  110         }
  111 
  112         return;
  113 }
  114 
  115 void
  116 usb_register_netisr(void)
  117 {
  118         if (mtx_inited)
  119                 return;
  120         netisr_register(NETISR_USB, (netisr_t *)usbintr, NULL, 0);
  121         mtx_init(&usbq_tx.ifq_mtx, "usbq_tx_mtx", NULL, MTX_DEF);
  122         mtx_init(&usbq_rx.ifq_mtx, "usbq_rx_mtx", NULL, MTX_DEF);
  123         mtx_inited++;
  124         return;
  125 }
  126 
  127 /*
  128  * Must be called at splusb() (actually splbio()). This should be
  129  * the case when called from a transfer callback routine.
  130  */
  131 void
  132 usb_ether_input(m)
  133         struct mbuf             *m;
  134 {
  135         IF_ENQUEUE(&usbq_rx, m);
  136         schednetisr(NETISR_USB);
  137 
  138         return;
  139 }
  140 
  141 void
  142 usb_tx_done(m)
  143         struct mbuf             *m;
  144 {
  145         IF_ENQUEUE(&usbq_tx, m);
  146         schednetisr(NETISR_USB);
  147 
  148         return;
  149 }
  150 
  151 struct mbuf *
  152 usb_ether_newbuf(void)
  153 {
  154         struct mbuf *m_new;
  155 
  156         m_new = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR);
  157         if (m_new == NULL)
  158                 return (NULL);
  159         m_new->m_len = m_new->m_pkthdr.len = MCLBYTES;
  160 
  161         m_adj(m_new, ETHER_ALIGN);
  162         return (m_new);
  163 }
  164 
  165 int
  166 usb_ether_rx_list_init(void *sc, struct ue_cdata *cd,
  167     usbd_device_handle ue_udev)
  168 {
  169         struct ue_chain *c;
  170         int i;
  171 
  172         for (i = 0; i < UE_RX_LIST_CNT; i++) {
  173                 c = &cd->ue_rx_chain[i];
  174                 c->ue_sc = sc;
  175                 c->ue_idx = i;
  176                 c->ue_mbuf = usb_ether_newbuf();
  177                 if (c->ue_mbuf == NULL)
  178                         return (ENOBUFS);
  179                 if (c->ue_xfer == NULL) {
  180                         c->ue_xfer = usbd_alloc_xfer(ue_udev);
  181                         if (c->ue_xfer == NULL)
  182                                 return (ENOBUFS);
  183                         c->ue_buf = usbd_alloc_buffer(c->ue_xfer, UE_BUFSZ);
  184                         if (c->ue_buf == NULL)
  185                                 return (ENOBUFS);
  186                 }
  187         }
  188 
  189         return (0);
  190 }
  191 
  192 int
  193 usb_ether_tx_list_init(void *sc, struct ue_cdata *cd,
  194     usbd_device_handle ue_udev)
  195 {
  196         struct ue_chain *c;
  197         int i;
  198 
  199         for (i = 0; i < UE_TX_LIST_CNT; i++) {
  200                 c = &cd->ue_tx_chain[i];
  201                 c->ue_sc = sc;
  202                 c->ue_idx = i;
  203                 c->ue_mbuf = NULL;
  204                 if (c->ue_xfer == NULL) {
  205                         c->ue_xfer = usbd_alloc_xfer(ue_udev);
  206                         if (c->ue_xfer == NULL)
  207                                 return (ENOBUFS);
  208                         c->ue_buf = usbd_alloc_buffer(c->ue_xfer, UE_BUFSZ);
  209                         if (c->ue_buf == NULL)
  210                                 return (ENOBUFS);
  211                 }
  212         }
  213 
  214         return (0);
  215 }
  216 
  217 void
  218 usb_ether_rx_list_free(struct ue_cdata *cd)
  219 {
  220         int i;
  221 
  222         for (i = 0; i < UE_RX_LIST_CNT; i++) {
  223                 if (cd->ue_rx_chain[i].ue_mbuf != NULL) {
  224                         m_freem(cd->ue_rx_chain[i].ue_mbuf);
  225                         cd->ue_rx_chain[i].ue_mbuf = NULL;
  226                 }
  227                 if (cd->ue_rx_chain[i].ue_xfer != NULL) {
  228                         usbd_free_xfer(cd->ue_rx_chain[i].ue_xfer);
  229                         cd->ue_rx_chain[i].ue_xfer = NULL;
  230                 }
  231         }
  232 }
  233 
  234 void
  235 usb_ether_tx_list_free(struct ue_cdata *cd)
  236 {
  237         int i;
  238 
  239         for (i = 0; i < UE_RX_LIST_CNT; i++) {
  240                 if (cd->ue_tx_chain[i].ue_mbuf != NULL) {
  241                         m_freem(cd->ue_tx_chain[i].ue_mbuf);
  242                         cd->ue_tx_chain[i].ue_mbuf = NULL;
  243                 }
  244                 if (cd->ue_tx_chain[i].ue_xfer != NULL) {
  245                         usbd_free_xfer(cd->ue_tx_chain[i].ue_xfer);
  246                         cd->ue_tx_chain[i].ue_xfer = NULL;
  247                 }
  248         }
  249 }
  250 
  251 void
  252 usb_ether_task_init(device_t dev, int flags, struct usb_taskqueue *tq)
  253 {
  254 
  255         /* nothing for now. */
  256 }
  257 
  258 void
  259 usb_ether_task_enqueue(struct usb_taskqueue *tq, struct task *task)
  260 {
  261 
  262         taskqueue_enqueue(taskqueue_thread, task);
  263 }
  264 
  265 void
  266 usb_ether_task_drain(struct usb_taskqueue *tq, struct task *task)
  267 {
  268 
  269         taskqueue_drain(taskqueue_thread, task);
  270 }
  271 
  272 void
  273 usb_ether_task_destroy(struct usb_taskqueue *tq)
  274 {
  275 
  276         /* nothing for now */
  277 
  278 }

Cache object: b46fb834ced70f045bdf892d0b5ee2d3

[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.

FreeBSD/Linux Kernel Cross Reference sys/dev/usb/usb_ethersubr.c

FreeBSD/Linux Kernel Cross Reference
sys/dev/usb/usb_ethersubr.c