root/dev/usb/if_cue.c

DEFINITIONS

1. cue_csr_read_1
2. cue_csr_read_2
3. cue_csr_write_1
4. cue_csr_write_2
5. cue_mem
6. cue_getmac
7. cue_setmulti
8. cue_reset
9. cue_match
10. cue_attach
11. cue_detach
12. cue_activate
13. cue_newbuf
14. cue_rx_list_init
15. cue_tx_list_init
16. cue_rxeof
17. cue_txeof
18. cue_tick
19. cue_tick_task
20. cue_send
21. cue_start
22. cue_init
23. cue_open_pipes
24. cue_ioctl
25. cue_watchdog
26. cue_stop

    1 /*      $OpenBSD: if_cue.c,v 1.45 2007/06/14 10:11:15 mbalmer Exp $ */
    2 /*      $NetBSD: if_cue.c,v 1.40 2002/07/11 21:14:26 augustss Exp $     */
    3 /*
    4  * Copyright (c) 1997, 1998, 1999, 2000
    5  *      Bill Paul <wpaul@ee.columbia.edu>.  All rights reserved.
    6  *
    7  * Redistribution and use in source and binary forms, with or without
    8  * modification, are permitted provided that the following conditions
    9  * are met:
   10  * 1. Redistributions of source code must retain the above copyright
   11  *    notice, this list of conditions and the following disclaimer.
   12  * 2. Redistributions in binary form must reproduce the above copyright
   13  *    notice, this list of conditions and the following disclaimer in the
   14  *    documentation and/or other materials provided with the distribution.
   15  * 3. All advertising materials mentioning features or use of this software
   16  *    must display the following acknowledgement:
   17  *      This product includes software developed by Bill Paul.
   18  * 4. Neither the name of the author nor the names of any co-contributors
   19  *    may be used to endorse or promote products derived from this software
   20  *    without specific prior written permission.
   21  *
   22  * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND
   23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   25  * ARE DISCLAIMED.  IN NO EVENT SHALL Bill Paul OR THE VOICES IN HIS HEAD
   26  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   27  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   28  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   29  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   30  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   31  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
   32  * THE POSSIBILITY OF SUCH DAMAGE.
   33  *
   34  * $FreeBSD: src/sys/dev/usb/if_cue.c,v 1.4 2000/01/16 22:45:06 wpaul Exp $
   35  */
   37 /*
   38  * CATC USB-EL1210A USB to ethernet driver. Used in the CATC Netmate
   39  * adapters and others.
   40  *
   41  * Written by Bill Paul <wpaul@ee.columbia.edu>
   42  * Electrical Engineering Department
   43  * Columbia University, New York City
   44  */
   46 /*
   47  * The CATC USB-EL1210A provides USB ethernet support at 10Mbps. The
   48  * RX filter uses a 512-bit multicast hash table, single perfect entry
   49  * for the station address, and promiscuous mode. Unlike the ADMtek
   50  * and KLSI chips, the CATC ASIC supports read and write combining
   51  * mode where multiple packets can be transferred using a single bulk
   52  * transaction, which helps performance a great deal.
   53  */
   55 /*
   56  * Ported to NetBSD and somewhat rewritten by Lennart Augustsson.
   57  */
   59 #include "bpfilter.h"
   61 #include <sys/param.h>
   62 #include <sys/systm.h>
   63 #include <sys/sockio.h>
   64 #include <sys/mbuf.h>
   65 #include <sys/malloc.h>
   66 #include <sys/kernel.h>
   67 #include <sys/socket.h>
   68 #include <sys/timeout.h>
   69 #include <sys/device.h>
   71 #include <net/if.h>
   72 #include <net/if_dl.h>
   74 #if NBPFILTER > 0
   75 #include <net/bpf.h>
   76 #endif
   78 #ifdef INET
   79 #include <netinet/in.h>
   80 #include <netinet/in_systm.h>
   81 #include <netinet/in_var.h>
   82 #include <netinet/ip.h>
   83 #include <netinet/if_ether.h>
   84 #endif
   86 #include <dev/usb/usb.h>
   87 #include <dev/usb/usbdi.h>
   88 #include <dev/usb/usbdi_util.h>
   89 #include <dev/usb/usbdevs.h>
   91 #include <dev/usb/if_cuereg.h>
   93 #ifdef CUE_DEBUG
   94 #define DPRINTF(x)      do { if (cuedebug) printf x; } while (0)
   95 #define DPRINTFN(n,x)   do { if (cuedebug >= (n)) printf x; } while (0)
   96 int     cuedebug = 0;
   97 #else
   98 #define DPRINTF(x)
   99 #define DPRINTFN(n,x)
  100 #endif
  102 /*
  103  * Various supported device vendors/products.
  104  */
  105 struct usb_devno cue_devs[] = {
  106         { USB_VENDOR_CATC, USB_PRODUCT_CATC_NETMATE },
  107         { USB_VENDOR_CATC, USB_PRODUCT_CATC_NETMATE2 },
  108         { USB_VENDOR_SMARTBRIDGES, USB_PRODUCT_SMARTBRIDGES_SMARTLINK },
  109         /* Belkin F5U111 adapter covered by NETMATE entry */
  110 };
  111 #define cue_lookup(v, p) (usb_lookup(cue_devs, v, p))
  113 int cue_match(struct device *, void *, void *); 
  114 void cue_attach(struct device *, struct device *, void *); 
  115 int cue_detach(struct device *, int); 
  116 int cue_activate(struct device *, enum devact); 
  118 struct cfdriver cue_cd = { 
NULL, "cue", DV_IFNET 
  120 }; 
  122 const struct cfattach cue_ca = { 
  123         sizeof(struct cue_softc), 
cue_match, 
cue_attach, 
cue_detach, 
cue_activate, 
  128 };
  130 int cue_open_pipes(struct cue_softc *);
  131 int cue_tx_list_init(struct cue_softc *);
  132 int cue_rx_list_init(struct cue_softc *);
  133 int cue_newbuf(struct cue_softc *, struct cue_chain *, struct mbuf *);
  134 int cue_send(struct cue_softc *, struct mbuf *, int);
  135 void cue_rxeof(usbd_xfer_handle, usbd_private_handle, usbd_status);
  136 void cue_txeof(usbd_xfer_handle, usbd_private_handle, usbd_status);
  137 void cue_tick(void *);
  138 void cue_tick_task(void *);
  139 void cue_start(struct ifnet *);
  140 int cue_ioctl(struct ifnet *, u_long, caddr_t);
  141 void cue_init(void *);
  142 void cue_stop(struct cue_softc *);
  143 void cue_watchdog(struct ifnet *);
  145 void cue_setmulti(struct cue_softc *);
  146 void cue_reset(struct cue_softc *);
  148 int cue_csr_read_1(struct cue_softc *, int);
  149 int cue_csr_write_1(struct cue_softc *, int, int);
  150 int cue_csr_read_2(struct cue_softc *, int);
  151 #if 0
  152 int cue_csr_write_2(struct cue_softc *, int, int);
  153 #endif
  154 int cue_mem(struct cue_softc *, int, int, void *, int);
  155 int cue_getmac(struct cue_softc *, void *);
  157 #define CUE_SETBIT(sc, reg, x)                          \
cue_csr_write_1(sc, reg, cue_csr_read_1(sc, reg) | (x))
  160 #define CUE_CLRBIT(sc, reg, x)                          \
cue_csr_write_1(sc, reg, cue_csr_read_1(sc, reg) & ~(x))
  163 int
cue_csr_read_1(struct cue_softc *sc, int reg)
  165 {
usb_device_request_t    req;
usbd_status             err;
u_int8_t                val = 0;
  170         if (sc->cue_dying)
  171                 return (0);
req.bmRequestType = UT_READ_VENDOR_DEVICE;
req.bRequest = CUE_CMD_READREG;
USETW(req.wValue, 0);
USETW(req.wIndex, reg);
USETW(req.wLength, 1);
err = usbd_do_request(sc->cue_udev, &req, &val);
  181         if (err) {
DPRINTF(("%s: cue_csr_read_1: reg=0x%x err=%s\n",
sc->cue_dev.dv_xname, reg, usbd_errstr(err)));
  184                 return (0);
  185         }
DPRINTFN(10,("%s: cue_csr_read_1 reg=0x%x val=0x%x\n",
sc->cue_dev.dv_xname, reg, val));
  190         return (val);
  191 }
  193 int
cue_csr_read_2(struct cue_softc *sc, int reg)
  195 {
usb_device_request_t    req;
usbd_status             err;
uWord                   val;
  200         if (sc->cue_dying)
  201                 return (0);
req.bmRequestType = UT_READ_VENDOR_DEVICE;
req.bRequest = CUE_CMD_READREG;
USETW(req.wValue, 0);
USETW(req.wIndex, reg);
USETW(req.wLength, 2);
err = usbd_do_request(sc->cue_udev, &req, &val);
DPRINTFN(10,("%s: cue_csr_read_2 reg=0x%x val=0x%x\n",
sc->cue_dev.dv_xname, reg, UGETW(val)));
  214         if (err) {
DPRINTF(("%s: cue_csr_read_2: reg=0x%x err=%s\n",
sc->cue_dev.dv_xname, reg, usbd_errstr(err)));
  217                 return (0);
  218         }
  220         return (UGETW(val));
  221 }
  223 int
cue_csr_write_1(struct cue_softc *sc, int reg, int val)
  225 {
usb_device_request_t    req;
usbd_status             err;
  229         if (sc->cue_dying)
  230                 return (0);
DPRINTFN(10,("%s: cue_csr_write_1 reg=0x%x val=0x%x\n",
sc->cue_dev.dv_xname, reg, val));
req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req.bRequest = CUE_CMD_WRITEREG;
USETW(req.wValue, val);
USETW(req.wIndex, reg);
USETW(req.wLength, 0);
err = usbd_do_request(sc->cue_udev, &req, NULL);
  243         if (err) {
DPRINTF(("%s: cue_csr_write_1: reg=0x%x err=%s\n",
sc->cue_dev.dv_xname, reg, usbd_errstr(err)));
  246                 return (-1);
  247         }
DPRINTFN(20,("%s: cue_csr_write_1, after reg=0x%x val=0x%x\n",
sc->cue_dev.dv_xname, reg, cue_csr_read_1(sc, reg)));
  252         return (0);
  253 }
  255 #if 0
  256 int
cue_csr_write_2(struct cue_softc *sc, int reg, int aval)
  258 {
usb_device_request_t    req;
usbd_status             err;
uWord                   val;
  262         int                     s;
  264         if (sc->cue_dying)
  265                 return (0);
DPRINTFN(10,("%s: cue_csr_write_2 reg=0x%x val=0x%x\n",
sc->cue_dev.dv_xname, reg, aval));
USETW(val, aval);
req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req.bRequest = CUE_CMD_WRITEREG;
USETW(req.wValue, val);
USETW(req.wIndex, reg);
USETW(req.wLength, 0);
err = usbd_do_request(sc->cue_udev, &req, NULL);
  279         if (err) {
DPRINTF(("%s: cue_csr_write_2: reg=0x%x err=%s\n",
sc->cue_dev.dv_xname, reg, usbd_errstr(err)));
  282                 return (-1);
  283         }
  285         return (0);
  286 }
  287 #endif
  289 int
cue_mem(struct cue_softc *sc, int cmd, int addr, void *buf, int len)
  291 {
usb_device_request_t    req;
usbd_status             err;
DPRINTFN(10,("%s: cue_mem cmd=0x%x addr=0x%x len=%d\n",
sc->cue_dev.dv_xname, cmd, addr, len));
  298         if (cmd == CUE_CMD_READSRAM)
req.bmRequestType = UT_READ_VENDOR_DEVICE;
  300         else
req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req.bRequest = cmd;
USETW(req.wValue, 0);
USETW(req.wIndex, addr);
USETW(req.wLength, len);
err = usbd_do_request(sc->cue_udev, &req, buf);
  309         if (err) {
DPRINTF(("%s: cue_csr_mem: addr=0x%x err=%s\n",
sc->cue_dev.dv_xname, addr, usbd_errstr(err)));
  312                 return (-1);
  313         }
  315         return (0);
  316 }
  318 int
cue_getmac(struct cue_softc *sc, void *buf)
  320 {
usb_device_request_t    req;
usbd_status             err;
DPRINTFN(10,("%s: cue_getmac\n", sc->cue_dev.dv_xname));
req.bmRequestType = UT_READ_VENDOR_DEVICE;
req.bRequest = CUE_CMD_GET_MACADDR;
USETW(req.wValue, 0);
USETW(req.wIndex, 0);
USETW(req.wLength, ETHER_ADDR_LEN);
err = usbd_do_request(sc->cue_udev, &req, buf);
  334         if (err) {
printf("%s: read MAC address failed\n",
sc->cue_dev.dv_xname);
  337                 return (-1);
  338         }
  340         return (0);
  341 }
  343 #define CUE_BITS        9
  345 void
cue_setmulti(struct cue_softc *sc)
  347 {
  348         struct ifnet            *ifp;
  349         struct ether_multi      *enm;
  350         struct ether_multistep  step;
u_int32_t               h, i;
ifp = GET_IFP(sc);
DPRINTFN(2,("%s: cue_setmulti if_flags=0x%x\n",
sc->cue_dev.dv_xname, ifp->if_flags));
  358         if (ifp->if_flags & IFF_PROMISC) {
allmulti:
ifp->if_flags |= IFF_ALLMULTI;
  361                 for (i = 0; i < CUE_MCAST_TABLE_LEN; i++)
sc->cue_mctab[i] = 0xFF;
cue_mem(sc, CUE_CMD_WRITESRAM, CUE_MCAST_TABLE_ADDR,
  364                     &sc->cue_mctab, CUE_MCAST_TABLE_LEN);
  365                 return;
  366         }
  368         /* first, zot all the existing hash bits */
  369         for (i = 0; i < CUE_MCAST_TABLE_LEN; i++)
sc->cue_mctab[i] = 0;
  372         /* now program new ones */
ETHER_FIRST_MULTI(step, &sc->arpcom, enm);
  374         while (enm != NULL) {
  375                 if (memcmp(enm->enm_addrlo,
enm->enm_addrhi, ETHER_ADDR_LEN) != 0)
  377                         goto allmulti;
h = ether_crc32_le(enm->enm_addrlo, ETHER_ADDR_LEN) &
  380                     ((1 << CUE_BITS) - 1);
sc->cue_mctab[h >> 3] |= 1 << (h & 0x7);
ETHER_NEXT_MULTI(step, enm);
  383         }
ifp->if_flags &= ~IFF_ALLMULTI;
  387         /*
  388          * Also include the broadcast address in the filter
  389          * so we can receive broadcast frames.
  390          */
  391         if (ifp->if_flags & IFF_BROADCAST) {
h = ether_crc32_le(etherbroadcastaddr, ETHER_ADDR_LEN) &
  393                     ((1 << CUE_BITS) - 1);
sc->cue_mctab[h >> 3] |= 1 << (h & 0x7);
  395         }
cue_mem(sc, CUE_CMD_WRITESRAM, CUE_MCAST_TABLE_ADDR,
  398             &sc->cue_mctab, CUE_MCAST_TABLE_LEN);
  399 }
  401 void
cue_reset(struct cue_softc *sc)
  403 {
usb_device_request_t    req;
usbd_status             err;
DPRINTFN(2,("%s: cue_reset\n", sc->cue_dev.dv_xname));
  409         if (sc->cue_dying)
  410                 return;
req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req.bRequest = CUE_CMD_RESET;
USETW(req.wValue, 0);
USETW(req.wIndex, 0);
USETW(req.wLength, 0);
err = usbd_do_request(sc->cue_udev, &req, NULL);
  420         if (err)
printf("%s: reset failed\n", sc->cue_dev.dv_xname);
  423         /* Wait a little while for the chip to get its brains in order. */
usbd_delay_ms(sc->cue_udev, 1);
  425 }
  427 /*
  428  * Probe for a CATC chip.
  429  */
  430 int
cue_match(struct device *parent, void *match, void *aux)
  432 {
  433         struct usb_attach_arg   *uaa = aux;
  435         if (uaa->iface != NULL)
  436                 return (UMATCH_NONE);
  438         return (cue_lookup(uaa->vendor, uaa->product) != NULL ?
UMATCH_VENDOR_PRODUCT : UMATCH_NONE);
  440 }
  442 /*
  443  * Attach the interface. Allocate softc structures, do ifmedia
  444  * setup and ethernet/BPF attach.
  445  */
  446 void
cue_attach(struct device *parent, struct device *self, void *aux)
  448 {
  449         struct cue_softc        *sc = (struct cue_softc *)self;
  450         struct usb_attach_arg   *uaa = aux;
  451         char                    *devinfop;
  452         int                     s;
u_char                  eaddr[ETHER_ADDR_LEN];
usbd_device_handle      dev = uaa->device;
usbd_interface_handle   iface;
usbd_status             err;
  457         struct ifnet            *ifp;
usb_interface_descriptor_t      *id;
usb_endpoint_descriptor_t       *ed;
  460         int                     i;
DPRINTFN(5,(" : cue_attach: sc=%p, dev=%p", sc, dev));
devinfop = usbd_devinfo_alloc(dev, 0);
printf("\n%s: %s\n", sc->cue_dev.dv_xname, devinfop);
usbd_devinfo_free(devinfop);
err = usbd_set_config_no(dev, CUE_CONFIG_NO, 1);
  469         if (err) {
printf("%s: setting config no failed\n",
sc->cue_dev.dv_xname);
  472                 return;
  473         }
sc->cue_udev = dev;
sc->cue_product = uaa->product;
sc->cue_vendor = uaa->vendor;
usb_init_task(&sc->cue_tick_task, cue_tick_task, sc);
usb_init_task(&sc->cue_stop_task, (void (*)(void *))cue_stop, sc);
err = usbd_device2interface_handle(dev, CUE_IFACE_IDX, &iface);
  483         if (err) {
printf("%s: getting interface handle failed\n",
sc->cue_dev.dv_xname);
  486                 return;
  487         }
sc->cue_iface = iface;
id = usbd_get_interface_descriptor(iface);
  492         /* Find endpoints. */
  493         for (i = 0; i < id->bNumEndpoints; i++) {
ed = usbd_interface2endpoint_descriptor(iface, i);
  495                 if (ed == NULL) {
printf("%s: couldn't get ep %d\n",
sc->cue_dev.dv_xname, i);
  498                         return;
  499                 }
  500                 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
sc->cue_ed[CUE_ENDPT_RX] = ed->bEndpointAddress;
  503                 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
sc->cue_ed[CUE_ENDPT_TX] = ed->bEndpointAddress;
  506                 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
sc->cue_ed[CUE_ENDPT_INTR] = ed->bEndpointAddress;
  509                 }
  510         }
  512 #if 0
  513         /* Reset the adapter. */
cue_reset(sc);
  515 #endif
  516         /*
  517          * Get station address.
  518          */
cue_getmac(sc, &eaddr);
s = splnet();
  523         /*
  524          * A CATC chip was detected. Inform the world.
  525          */
printf("%s: address %s\n", sc->cue_dev.dv_xname,
ether_sprintf(eaddr));
bcopy(eaddr, (char *)&sc->arpcom.ac_enaddr, ETHER_ADDR_LEN);
  531         /* Initialize interface info.*/
ifp = GET_IFP(sc);
ifp->if_softc = sc;
ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
ifp->if_ioctl = cue_ioctl;
ifp->if_start = cue_start;
ifp->if_watchdog = cue_watchdog;
strlcpy(ifp->if_xname, sc->cue_dev.dv_xname, IFNAMSIZ);
IFQ_SET_READY(&ifp->if_snd);
  542         /* Attach the interface. */
if_attach(ifp);
ether_ifattach(ifp);
timeout_set(&sc->cue_stat_ch, NULL, NULL);
sc->cue_attached = 1;
splx(s);
usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->cue_udev,
  552             &sc->cue_dev);
  553 }
  555 int
cue_detach(struct device *self, int flags)
  557 {
  558         struct cue_softc        *sc = (struct cue_softc *)self;
  559         struct ifnet            *ifp = GET_IFP(sc);
  560         int                     s;
DPRINTFN(2,("%s: %s: enter\n", sc->cue_dev.dv_xname, __func__));
timeout_del(&sc->cue_stat_ch);
  565         /*
  566          * Remove any pending task.  It cannot be executing because it run
  567          * in the same thread as detach.
  568          */
usb_rem_task(sc->cue_udev, &sc->cue_tick_task);
usb_rem_task(sc->cue_udev, &sc->cue_stop_task);
  572         if (!sc->cue_attached) {
  573                 /* Detached before attached finished, so just bail out. */
  574                 return (0);
  575         }
s = splusb();
  579         if (ifp->if_flags & IFF_RUNNING)
cue_stop(sc);
ether_ifdetach(ifp);
if_detach(ifp);
  586 #ifdef DIAGNOSTIC
  587         if (sc->cue_ep[CUE_ENDPT_TX] != NULL ||
sc->cue_ep[CUE_ENDPT_RX] != NULL ||
sc->cue_ep[CUE_ENDPT_INTR] != NULL)
printf("%s: detach has active endpoints\n",
sc->cue_dev.dv_xname);
  592 #endif
sc->cue_attached = 0;
splx(s);
usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->cue_udev,
  598             &sc->cue_dev);
  600         return (0);
  601 }
  603 int
cue_activate(struct device *self, enum devact act)
  605 {
  606         struct cue_softc *sc = (struct cue_softc *)self;
DPRINTFN(2,("%s: %s: enter\n", sc->cue_dev.dv_xname, __func__));
  610         switch (act) {
  611         case DVACT_ACTIVATE:
  612                 break;
  614         case DVACT_DEACTIVATE:
sc->cue_dying = 1;
  616                 break;
  617         }
  618         return (0);
  619 }
  621 /*
  622  * Initialize an RX descriptor and attach an MBUF cluster.
  623  */
  624 int
cue_newbuf(struct cue_softc *sc, struct cue_chain *c, struct mbuf *m)
  626 {
  627         struct mbuf             *m_new = NULL;
  629         if (m == NULL) {
MGETHDR(m_new, M_DONTWAIT, MT_DATA);
  631                 if (m_new == NULL) {
printf("%s: no memory for rx list "
  633                             "-- packet dropped!\n", sc->cue_dev.dv_xname);
  634                         return (ENOBUFS);
  635                 }
MCLGET(m_new, M_DONTWAIT);
  638                 if (!(m_new->m_flags & M_EXT)) {
printf("%s: no memory for rx list "
  640                             "-- packet dropped!\n", sc->cue_dev.dv_xname);
m_freem(m_new);
  642                         return (ENOBUFS);
  643                 }
m_new->m_len = m_new->m_pkthdr.len = MCLBYTES;
  645         } else {
m_new = m;
m_new->m_len = m_new->m_pkthdr.len = MCLBYTES;
m_new->m_data = m_new->m_ext.ext_buf;
  649         }
m_adj(m_new, ETHER_ALIGN);
c->cue_mbuf = m_new;
  654         return (0);
  655 }
  657 int
cue_rx_list_init(struct cue_softc *sc)
  659 {
  660         struct cue_cdata        *cd;
  661         struct cue_chain        *c;
  662         int                     i;
cd = &sc->cue_cdata;
  665         for (i = 0; i < CUE_RX_LIST_CNT; i++) {
c = &cd->cue_rx_chain[i];
c->cue_sc = sc;
c->cue_idx = i;
  669                 if (cue_newbuf(sc, c, NULL) == ENOBUFS)
  670                         return (ENOBUFS);
  671                 if (c->cue_xfer == NULL) {
c->cue_xfer = usbd_alloc_xfer(sc->cue_udev);
  673                         if (c->cue_xfer == NULL)
  674                                 return (ENOBUFS);
c->cue_buf = usbd_alloc_buffer(c->cue_xfer, CUE_BUFSZ);
  676                         if (c->cue_buf == NULL) {
usbd_free_xfer(c->cue_xfer);
  678                                 return (ENOBUFS);
  679                         }
  680                 }
  681         }
  683         return (0);
  684 }
  686 int
cue_tx_list_init(struct cue_softc *sc)
  688 {
  689         struct cue_cdata        *cd;
  690         struct cue_chain        *c;
  691         int                     i;
cd = &sc->cue_cdata;
  694         for (i = 0; i < CUE_TX_LIST_CNT; i++) {
c = &cd->cue_tx_chain[i];
c->cue_sc = sc;
c->cue_idx = i;
c->cue_mbuf = NULL;
  699                 if (c->cue_xfer == NULL) {
c->cue_xfer = usbd_alloc_xfer(sc->cue_udev);
  701                         if (c->cue_xfer == NULL)
  702                                 return (ENOBUFS);
c->cue_buf = usbd_alloc_buffer(c->cue_xfer, CUE_BUFSZ);
  704                         if (c->cue_buf == NULL) {
usbd_free_xfer(c->cue_xfer);
  706                                 return (ENOBUFS);
  707                         }
  708                 }
  709         }
  711         return (0);
  712 }
  714 /*
  715  * A frame has been uploaded: pass the resulting mbuf chain up to
  716  * the higher level protocols.
  717  */
  718 void
cue_rxeof(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
  720 {
  721         struct cue_chain        *c = priv;
  722         struct cue_softc        *sc = c->cue_sc;
  723         struct ifnet            *ifp = GET_IFP(sc);
  724         struct mbuf             *m;
  725         int                     total_len = 0;
u_int16_t               len;
  727         int                     s;
DPRINTFN(10,("%s: %s: enter status=%d\n", sc->cue_dev.dv_xname,
__func__, status));
  732         if (sc->cue_dying)
  733                 return;
  735         if (!(ifp->if_flags & IFF_RUNNING))
  736                 return;
  738         if (status != USBD_NORMAL_COMPLETION) {
  739                 if (status == USBD_NOT_STARTED || status == USBD_CANCELLED)
  740                         return;
sc->cue_rx_errs++;
  742                 if (usbd_ratecheck(&sc->cue_rx_notice)) {
printf("%s: %u usb errors on rx: %s\n",
sc->cue_dev.dv_xname, sc->cue_rx_errs,
usbd_errstr(status));
sc->cue_rx_errs = 0;
  747                 }
  748                 if (status == USBD_STALLED)
usbd_clear_endpoint_stall_async(sc->cue_ep[CUE_ENDPT_RX]);
  750                 goto done;
  751         }
usbd_get_xfer_status(xfer, NULL, NULL, &total_len, NULL);
memcpy(mtod(c->cue_mbuf, char *), c->cue_buf, total_len);
m = c->cue_mbuf;
len = UGETW(mtod(m, u_int8_t *));
  760         /* No errors; receive the packet. */
total_len = len;
  763         if (len < sizeof(struct ether_header)) {
ifp->if_ierrors++;
  765                 goto done;
  766         }
ifp->if_ipackets++;
m_adj(m, sizeof(u_int16_t));
m->m_pkthdr.len = m->m_len = total_len;
m->m_pkthdr.rcvif = ifp;
s = splnet();
  776         /* XXX ugly */
  777         if (cue_newbuf(sc, c, NULL) == ENOBUFS) {
ifp->if_ierrors++;
  779                 goto done1;
  780         }
  782 #if NBPFILTER > 0
  783         /*
  784          * Handle BPF listeners. Let the BPF user see the packet, but
  785          * don't pass it up to the ether_input() layer unless it's
  786          * a broadcast packet, multicast packet, matches our ethernet
  787          * address or the interface is in promiscuous mode.
  788          */
  789         if (ifp->if_bpf)
bpf_mtap(ifp->if_bpf, m, BPF_DIRECTION_IN);
  791 #endif
DPRINTFN(10,("%s: %s: deliver %d\n", sc->cue_dev.dv_xname,
__func__, m->m_len));
ether_input_mbuf(ifp, m);
done1:
splx(s);
done:
  800         /* Setup new transfer. */
usbd_setup_xfer(c->cue_xfer, sc->cue_ep[CUE_ENDPT_RX],
c, c->cue_buf, CUE_BUFSZ, USBD_SHORT_XFER_OK | USBD_NO_COPY,
USBD_NO_TIMEOUT, cue_rxeof);
usbd_transfer(c->cue_xfer);
DPRINTFN(10,("%s: %s: start rx\n", sc->cue_dev.dv_xname,
__func__));
  808 }
  810 /*
  811  * A frame was downloaded to the chip. It's safe for us to clean up
  812  * the list buffers.
  813  */
  814 void
cue_txeof(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
  816 {
  817         struct cue_chain        *c = priv;
  818         struct cue_softc        *sc = c->cue_sc;
  819         struct ifnet            *ifp = GET_IFP(sc);
  820         int                     s;
  822         if (sc->cue_dying)
  823                 return;
s = splnet();
DPRINTFN(10,("%s: %s: enter status=%d\n", sc->cue_dev.dv_xname,
__func__, status));
ifp->if_timer = 0;
ifp->if_flags &= ~IFF_OACTIVE;
  833         if (status != USBD_NORMAL_COMPLETION) {
  834                 if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) {
splx(s);
  836                         return;
  837                 }
ifp->if_oerrors++;
printf("%s: usb error on tx: %s\n", sc->cue_dev.dv_xname,
usbd_errstr(status));
  841                 if (status == USBD_STALLED)
usbd_clear_endpoint_stall_async(sc->cue_ep[CUE_ENDPT_TX]);
splx(s);
  844                 return;
  845         }
ifp->if_opackets++;
m_freem(c->cue_mbuf);
c->cue_mbuf = NULL;
  852         if (IFQ_IS_EMPTY(&ifp->if_snd) == 0)
cue_start(ifp);
splx(s);
  856 }
  858 void
cue_tick(void *xsc)
  860 {
  861         struct cue_softc        *sc = xsc;
  863         if (sc == NULL)
  864                 return;
  866         if (sc->cue_dying)
  867                 return;
DPRINTFN(2,("%s: %s: enter\n", sc->cue_dev.dv_xname, __func__));
  871         /* Perform statistics update in process context. */
usb_add_task(sc->cue_udev, &sc->cue_tick_task);
  873 }
  875 void
cue_tick_task(void *xsc)
  877 {
  878         struct cue_softc        *sc = xsc;
  879         struct ifnet            *ifp;
  881         if (sc->cue_dying)
  882                 return;
DPRINTFN(2,("%s: %s: enter\n", sc->cue_dev.dv_xname, __func__));
ifp = GET_IFP(sc);
ifp->if_collisions += cue_csr_read_2(sc, CUE_TX_SINGLECOLL);
ifp->if_collisions += cue_csr_read_2(sc, CUE_TX_MULTICOLL);
ifp->if_collisions += cue_csr_read_2(sc, CUE_TX_EXCESSCOLL);
  892         if (cue_csr_read_2(sc, CUE_RX_FRAMEERR))
ifp->if_ierrors++;
  894 }
  896 int
cue_send(struct cue_softc *sc, struct mbuf *m, int idx)
  898 {
  899         int                     total_len;
  900         struct cue_chain        *c;
usbd_status             err;
c = &sc->cue_cdata.cue_tx_chain[idx];
  905         /*
  906          * Copy the mbuf data into a contiguous buffer, leaving two
  907          * bytes at the beginning to hold the frame length.
  908          */
m_copydata(m, 0, m->m_pkthdr.len, c->cue_buf + 2);
c->cue_mbuf = m;
total_len = m->m_pkthdr.len + 2;
DPRINTFN(10,("%s: %s: total_len=%d\n",
sc->cue_dev.dv_xname, __func__, total_len));
  917         /* The first two bytes are the frame length */
c->cue_buf[0] = (u_int8_t)m->m_pkthdr.len;
c->cue_buf[1] = (u_int8_t)(m->m_pkthdr.len >> 8);
  921         /* XXX 10000 */
usbd_setup_xfer(c->cue_xfer, sc->cue_ep[CUE_ENDPT_TX],
c, c->cue_buf, total_len, USBD_NO_COPY, 10000, cue_txeof);
  925         /* Transmit */
err = usbd_transfer(c->cue_xfer);
  927         if (err != USBD_IN_PROGRESS) {
printf("%s: cue_send error=%s\n", sc->cue_dev.dv_xname,
usbd_errstr(err));
  930                 /* Stop the interface from process context. */
usb_add_task(sc->cue_udev, &sc->cue_stop_task);
  932                 return (EIO);
  933         }
sc->cue_cdata.cue_tx_cnt++;
  937         return (0);
  938 }
  940 void
cue_start(struct ifnet *ifp)
  942 {
  943         struct cue_softc        *sc = ifp->if_softc;
  944         struct mbuf             *m_head = NULL;
  946         if (sc->cue_dying)
  947                 return;
DPRINTFN(10,("%s: %s: enter\n", sc->cue_dev.dv_xname,__func__));
  951         if (ifp->if_flags & IFF_OACTIVE)
  952                 return;
IFQ_POLL(&ifp->if_snd, m_head);
  955         if (m_head == NULL)
  956                 return;
  958         if (cue_send(sc, m_head, 0)) {
ifp->if_flags |= IFF_OACTIVE;
  960                 return;
  961         }
IFQ_DEQUEUE(&ifp->if_snd, m_head);
  965 #if NBPFILTER > 0
  966         /*
  967          * If there's a BPF listener, bounce a copy of this frame
  968          * to him.
  969          */
  970         if (ifp->if_bpf)
bpf_mtap(ifp->if_bpf, m_head, BPF_DIRECTION_OUT);
  972 #endif
ifp->if_flags |= IFF_OACTIVE;
  976         /*
  977          * Set a timeout in case the chip goes out to lunch.
  978          */
ifp->if_timer = 5;
  980 }
  982 void
cue_init(void *xsc)
  984 {
  985         struct cue_softc        *sc = xsc;
  986         struct ifnet            *ifp = GET_IFP(sc);
  987         int                     i, s, ctl;
u_char                  *eaddr;
  990         if (sc->cue_dying)
  991                 return;
DPRINTFN(10,("%s: %s: enter\n", sc->cue_dev.dv_xname,__func__));
  995         if (ifp->if_flags & IFF_RUNNING)
  996                 return;
s = splnet();
 1000         /*
 1001          * Cancel pending I/O and free all RX/TX buffers.
 1002          */
 1003 #if 1
cue_reset(sc);
 1005 #endif
 1007         /* Set advanced operation modes. */
cue_csr_write_1(sc, CUE_ADVANCED_OPMODES,
CUE_AOP_EMBED_RXLEN | 0x03); /* 1 wait state */
eaddr = sc->arpcom.ac_enaddr;
 1012         /* Set MAC address */
 1013         for (i = 0; i < ETHER_ADDR_LEN; i++)
cue_csr_write_1(sc, CUE_PAR0 - i, eaddr[i]);
 1016         /* Enable RX logic. */
ctl = CUE_ETHCTL_RX_ON | CUE_ETHCTL_MCAST_ON;
 1018         if (ifp->if_flags & IFF_PROMISC)
ctl |= CUE_ETHCTL_PROMISC;
cue_csr_write_1(sc, CUE_ETHCTL, ctl);
 1022         /* Init TX ring. */
 1023         if (cue_tx_list_init(sc) == ENOBUFS) {
printf("%s: tx list init failed\n", sc->cue_dev.dv_xname);
splx(s);
 1026                 return;
 1027         }
 1029         /* Init RX ring. */
 1030         if (cue_rx_list_init(sc) == ENOBUFS) {
printf("%s: rx list init failed\n", sc->cue_dev.dv_xname);
splx(s);
 1033                 return;
 1034         }
 1036         /* Load the multicast filter. */
cue_setmulti(sc);
 1039         /*
 1040          * Set the number of RX and TX buffers that we want
 1041          * to reserve inside the ASIC.
 1042          */
cue_csr_write_1(sc, CUE_RX_BUFPKTS, CUE_RX_FRAMES);
cue_csr_write_1(sc, CUE_TX_BUFPKTS, CUE_TX_FRAMES);
 1046         /* Set advanced operation modes. */
cue_csr_write_1(sc, CUE_ADVANCED_OPMODES,
CUE_AOP_EMBED_RXLEN | 0x01); /* 1 wait state */
 1050         /* Program the LED operation. */
cue_csr_write_1(sc, CUE_LEDCTL, CUE_LEDCTL_FOLLOW_LINK);
 1053         if (sc->cue_ep[CUE_ENDPT_RX] == NULL) {
 1054                 if (cue_open_pipes(sc)) {
splx(s);
 1056                         return;
 1057                 }
 1058         }
ifp->if_flags |= IFF_RUNNING;
ifp->if_flags &= ~IFF_OACTIVE;
splx(s);
timeout_del(&sc->cue_stat_ch);
timeout_set(&sc->cue_stat_ch, cue_tick, sc);
timeout_add(&sc->cue_stat_ch, hz);
 1068 }
 1070 int
cue_open_pipes(struct cue_softc *sc)
 1072 {
 1073         struct cue_chain        *c;
usbd_status             err;
 1075         int                     i;
 1077         /* Open RX and TX pipes. */
err = usbd_open_pipe(sc->cue_iface, sc->cue_ed[CUE_ENDPT_RX],
USBD_EXCLUSIVE_USE, &sc->cue_ep[CUE_ENDPT_RX]);
 1080         if (err) {
printf("%s: open rx pipe failed: %s\n",
sc->cue_dev.dv_xname, usbd_errstr(err));
 1083                 return (EIO);
 1084         }
err = usbd_open_pipe(sc->cue_iface, sc->cue_ed[CUE_ENDPT_TX],
USBD_EXCLUSIVE_USE, &sc->cue_ep[CUE_ENDPT_TX]);
 1087         if (err) {
printf("%s: open tx pipe failed: %s\n",
sc->cue_dev.dv_xname, usbd_errstr(err));
 1090                 return (EIO);
 1091         }
 1093         /* Start up the receive pipe. */
 1094         for (i = 0; i < CUE_RX_LIST_CNT; i++) {
c = &sc->cue_cdata.cue_rx_chain[i];
usbd_setup_xfer(c->cue_xfer, sc->cue_ep[CUE_ENDPT_RX],
c, c->cue_buf, CUE_BUFSZ,
USBD_SHORT_XFER_OK | USBD_NO_COPY, USBD_NO_TIMEOUT,
cue_rxeof);
usbd_transfer(c->cue_xfer);
 1101         }
 1103         return (0);
 1104 }
 1106 int
cue_ioctl(struct ifnet *ifp, u_long command, caddr_t data)
 1108 {
 1109         struct cue_softc        *sc = ifp->if_softc;
 1110         struct ifaddr           *ifa = (struct ifaddr *)data;
 1111         struct ifreq            *ifr = (struct ifreq *)data;
 1112         int                     s, error = 0;
 1114         if (sc->cue_dying)
 1115                 return (EIO);
s = splnet();
 1119         switch(command) {
 1120         case SIOCSIFADDR:
ifp->if_flags |= IFF_UP;
cue_init(sc);
 1124                 switch (ifa->ifa_addr->sa_family) {
 1125 #ifdef INET
 1126                 case AF_INET:
arp_ifinit(&sc->arpcom, ifa);
 1128                         break;
 1129 #endif /* INET */
 1130                 }
 1131                 break;
 1133         case SIOCSIFMTU:
 1134                 if (ifr->ifr_mtu > ETHERMTU)
error = EINVAL;
 1136                 else
ifp->if_mtu = ifr->ifr_mtu;
 1138                 break;
 1140         case SIOCSIFFLAGS:
 1141                 if (ifp->if_flags & IFF_UP) {
 1142                         if (ifp->if_flags & IFF_RUNNING &&
ifp->if_flags & IFF_PROMISC &&
 1144                             !(sc->cue_if_flags & IFF_PROMISC)) {
CUE_SETBIT(sc, CUE_ETHCTL, CUE_ETHCTL_PROMISC);
cue_setmulti(sc);
 1147                         } else if (ifp->if_flags & IFF_RUNNING &&
 1148                             !(ifp->if_flags & IFF_PROMISC) &&
sc->cue_if_flags & IFF_PROMISC) {
CUE_CLRBIT(sc, CUE_ETHCTL, CUE_ETHCTL_PROMISC);
cue_setmulti(sc);
 1152                         } else if (!(ifp->if_flags & IFF_RUNNING))
cue_init(sc);
 1154                 } else {
 1155                         if (ifp->if_flags & IFF_RUNNING)
cue_stop(sc);
 1157                 }
sc->cue_if_flags = ifp->if_flags;
error = 0;
 1160                 break;
 1161         case SIOCADDMULTI:
 1162         case SIOCDELMULTI:
error = (command == SIOCADDMULTI) ?
ether_addmulti(ifr, &sc->arpcom) :
ether_delmulti(ifr, &sc->arpcom);
 1167                 if (error == ENETRESET) {
 1168                         /*
 1169                          * Multicast list has changed; set the hardware
 1170                          * filter accordingly.
 1171                          */
 1172                         if (ifp->if_flags & IFF_RUNNING)
cue_setmulti(sc);
error = 0;
 1175                 }
 1176                 break;
 1177         default:
error = EINVAL;
 1179                 break;
 1180         }
splx(s);
 1184         return (error);
 1185 }
 1187 void
cue_watchdog(struct ifnet *ifp)
 1189 {
 1190         struct cue_softc        *sc = ifp->if_softc;
 1191         struct cue_chain        *c;
usbd_status             stat;
 1193         int                     s;
DPRINTFN(5,("%s: %s: enter\n", sc->cue_dev.dv_xname,__func__));
 1197         if (sc->cue_dying)
 1198                 return;
ifp->if_oerrors++;
printf("%s: watchdog timeout\n", sc->cue_dev.dv_xname);
s = splusb();
c = &sc->cue_cdata.cue_tx_chain[0];
usbd_get_xfer_status(c->cue_xfer, NULL, NULL, NULL, &stat);
cue_txeof(c->cue_xfer, c, stat);
 1208         if (IFQ_IS_EMPTY(&ifp->if_snd) == 0)
cue_start(ifp);
splx(s);
 1211 }
 1213 /*
 1214  * Stop the adapter and free any mbufs allocated to the
 1215  * RX and TX lists.
 1216  */
 1217 void
cue_stop(struct cue_softc *sc)
 1219 {
usbd_status             err;
 1221         struct ifnet            *ifp;
 1222         int                     i;
DPRINTFN(10,("%s: %s: enter\n", sc->cue_dev.dv_xname,__func__));
ifp = GET_IFP(sc);
ifp->if_timer = 0;
ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
cue_csr_write_1(sc, CUE_ETHCTL, 0);
cue_reset(sc);
timeout_del(&sc->cue_stat_ch);
 1234         /* Stop transfers. */
 1235         if (sc->cue_ep[CUE_ENDPT_RX] != NULL) {
err = usbd_abort_pipe(sc->cue_ep[CUE_ENDPT_RX]);
 1237                 if (err) {
printf("%s: abort rx pipe failed: %s\n",
sc->cue_dev.dv_xname, usbd_errstr(err));
 1240                 }
err = usbd_close_pipe(sc->cue_ep[CUE_ENDPT_RX]);
 1242                 if (err) {
printf("%s: close rx pipe failed: %s\n",
sc->cue_dev.dv_xname, usbd_errstr(err));
 1245                 }
sc->cue_ep[CUE_ENDPT_RX] = NULL;
 1247         }
 1249         if (sc->cue_ep[CUE_ENDPT_TX] != NULL) {
err = usbd_abort_pipe(sc->cue_ep[CUE_ENDPT_TX]);
 1251                 if (err) {
printf("%s: abort tx pipe failed: %s\n",
sc->cue_dev.dv_xname, usbd_errstr(err));
 1254                 }
err = usbd_close_pipe(sc->cue_ep[CUE_ENDPT_TX]);
 1256                 if (err) {
printf("%s: close tx pipe failed: %s\n",
sc->cue_dev.dv_xname, usbd_errstr(err));
 1259                 }
sc->cue_ep[CUE_ENDPT_TX] = NULL;
 1261         }
 1263         if (sc->cue_ep[CUE_ENDPT_INTR] != NULL) {
err = usbd_abort_pipe(sc->cue_ep[CUE_ENDPT_INTR]);
 1265                 if (err) {
printf("%s: abort intr pipe failed: %s\n",
sc->cue_dev.dv_xname, usbd_errstr(err));
 1268                 }
err = usbd_close_pipe(sc->cue_ep[CUE_ENDPT_INTR]);
 1270                 if (err) {
printf("%s: close intr pipe failed: %s\n",
sc->cue_dev.dv_xname, usbd_errstr(err));
 1273                 }
sc->cue_ep[CUE_ENDPT_INTR] = NULL;
 1275         }
 1277         /* Free RX resources. */
 1278         for (i = 0; i < CUE_RX_LIST_CNT; i++) {
 1279                 if (sc->cue_cdata.cue_rx_chain[i].cue_mbuf != NULL) {
m_freem(sc->cue_cdata.cue_rx_chain[i].cue_mbuf);
sc->cue_cdata.cue_rx_chain[i].cue_mbuf = NULL;
 1282                 }
 1283                 if (sc->cue_cdata.cue_rx_chain[i].cue_xfer != NULL) {
usbd_free_xfer(sc->cue_cdata.cue_rx_chain[i].cue_xfer);
sc->cue_cdata.cue_rx_chain[i].cue_xfer = NULL;
 1286                 }
 1287         }
 1289         /* Free TX resources. */
 1290         for (i = 0; i < CUE_TX_LIST_CNT; i++) {
 1291                 if (sc->cue_cdata.cue_tx_chain[i].cue_mbuf != NULL) {
m_freem(sc->cue_cdata.cue_tx_chain[i].cue_mbuf);
sc->cue_cdata.cue_tx_chain[i].cue_mbuf = NULL;
 1294                 }
 1295                 if (sc->cue_cdata.cue_tx_chain[i].cue_xfer != NULL) {
usbd_free_xfer(sc->cue_cdata.cue_tx_chain[i].cue_xfer);
sc->cue_cdata.cue_tx_chain[i].cue_xfer = NULL;
 1298                 }
 1299         }
 1300 }