Diff for /src/sys/dev/netif/kue/if_kue.c between versions 1.4 and 1.5

version 1.4, 2003/11/20 22:07:29 version 1.5, 2003/12/30 01:01:46
Line 29 Line 29
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  * THE POSSIBILITY OF SUCH DAMAGE.   * THE POSSIBILITY OF SUCH DAMAGE.
  *   *
 * $FreeBSD: src/sys/dev/usb/if_kue.c,v 1.17.2.9 2003/04/13 02:39:25 murray Exp $ *  $FreeBSD: src/sys/dev/usb/if_kue.c,v 1.17.2.9 2003/04/13 02:39:25 murray Exp $
  * $DragonFly$   * $DragonFly$
  *  
  * $FreeBSD: src/sys/dev/usb/if_kue.c,v 1.17.2.9 2003/04/13 02:39:25 murray Exp $  
  */   */
   
 /*  /*
Line 83 Line 81
   
 #include <net/bpf.h>  #include <net/bpf.h>
   
 #include <machine/clock.h>      /* for DELAY */  
 #include <sys/bus.h>  #include <sys/bus.h>
   #include <machine/bus.h>
   #if __FreeBSD_version < 500000
   #include <machine/clock.h>
   #endif
   
 #include <bus/usb/usb.h>  #include <bus/usb/usb.h>
 #include <bus/usb/usbdi.h>  #include <bus/usb/usbdi.h>
Line 96 Line 97
 #include "if_kuereg.h"  #include "if_kuereg.h"
 #include <bus/usb/kue_fw.h>  #include <bus/usb/kue_fw.h>
   
   MODULE_DEPEND(kue, usb, 1, 1, 1);
   MODULE_DEPEND(kue, ether, 1, 1, 1);
   
 /*  /*
  * Various supported device vendors/products.   * Various supported device vendors/products.
  */   */
Line 116  Static struct kue_type kue_devs[] = { Line 120  Static struct kue_type kue_devs[] = {
         { USB_VENDOR_KLSI, USB_PRODUCT_KLSI_DUH3E10BT },          { USB_VENDOR_KLSI, USB_PRODUCT_KLSI_DUH3E10BT },
         { USB_VENDOR_KLSI, USB_PRODUCT_KLSI_DUH3E10BTN },          { USB_VENDOR_KLSI, USB_PRODUCT_KLSI_DUH3E10BTN },
         { USB_VENDOR_PERACOM, USB_PRODUCT_PERACOM_ENET3 },          { USB_VENDOR_PERACOM, USB_PRODUCT_PERACOM_ENET3 },
           { USB_VENDOR_IODATA, USB_PRODUCT_IODATA_USBETT },
           { USB_VENDOR_ABOCOM, USB_PRODUCT_ABOCOM_URE450 },
         { 0, 0 }          { 0, 0 }
 };  };
   
 Static struct usb_qdat kue_qdat;  Static struct usb_qdat kue_qdat;
   
Static int kue_match(device_t);Static int kue_match(device_ptr_t);
Static int kue_attach(device_t);Static int kue_attach(device_ptr_t);
Static int kue_detach(device_t);Static int kue_detach(device_ptr_t);
Static void kue_shutdown(device_t);Static void kue_shutdown(device_ptr_t);
 Static int kue_tx_list_init(struct kue_softc *);  Static int kue_tx_list_init(struct kue_softc *);
 Static int kue_rx_list_init(struct kue_softc *);  Static int kue_rx_list_init(struct kue_softc *);
 Static int kue_newbuf(struct kue_softc *, struct kue_chain *, struct mbuf *);  Static int kue_newbuf(struct kue_softc *, struct kue_chain *, struct mbuf *);
Line 167  Static driver_t kue_driver = { Line 173  Static driver_t kue_driver = {
 Static devclass_t kue_devclass;  Static devclass_t kue_devclass;
   
 DECLARE_DUMMY_MODULE(if_kue);  DECLARE_DUMMY_MODULE(if_kue);
DRIVER_MODULE(if_kue, uhub, kue_driver, kue_devclass, usbd_driver_load, 0);DRIVER_MODULE(kue, uhub, kue_driver, kue_devclass, usbd_driver_load, 0);
   
 /*  /*
  * We have a custom do_request function which is almost like the   * We have a custom do_request function which is almost like the
Line 184  kue_do_request(usbd_device_handle dev, u Line 190  kue_do_request(usbd_device_handle dev, u
   
         xfer = usbd_alloc_xfer(dev);          xfer = usbd_alloc_xfer(dev);
         usbd_setup_default_xfer(xfer, dev, 0, 500000, req,          usbd_setup_default_xfer(xfer, dev, 0, 500000, req,
            data, UGETW(req->wLength), USBD_SHORT_XFER_OK|USBD_NO_TSLEEP, 0);            data, UGETW(req->wLength), USBD_SHORT_XFER_OK, 0);
         err = usbd_sync_transfer(xfer);          err = usbd_sync_transfer(xfer);
         usbd_free_xfer(xfer);          usbd_free_xfer(xfer);
         return(err);          return(err);
Line 196  kue_setword(struct kue_softc *sc, u_int8 Line 202  kue_setword(struct kue_softc *sc, u_int8
         usbd_device_handle      dev;          usbd_device_handle      dev;
         usb_device_request_t    req;          usb_device_request_t    req;
         usbd_status             err;          usbd_status             err;
         int                     s;  
   
        if (sc->kue_gone)        if (sc->kue_dying)
                 return(USBD_NORMAL_COMPLETION);                  return(USBD_NORMAL_COMPLETION);
   
         dev = sc->kue_udev;          dev = sc->kue_udev;
   
        s = splusb();        KUE_LOCK(sc);
   
         req.bmRequestType = UT_WRITE_VENDOR_DEVICE;          req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
   
Line 214  kue_setword(struct kue_softc *sc, u_int8 Line 219  kue_setword(struct kue_softc *sc, u_int8
   
         err = kue_do_request(dev, &req, NULL);          err = kue_do_request(dev, &req, NULL);
   
        splx(s);        KUE_UNLOCK(sc);
   
         return(err);          return(err);
 }  }
Line 226  kue_ctl(struct kue_softc *sc, int rw, u_ Line 231  kue_ctl(struct kue_softc *sc, int rw, u_
         usbd_device_handle      dev;          usbd_device_handle      dev;
         usb_device_request_t    req;          usb_device_request_t    req;
         usbd_status             err;          usbd_status             err;
         int                     s;  
   
         dev = sc->kue_udev;          dev = sc->kue_udev;
   
        if (sc->kue_gone)        if (sc->kue_dying)
                 return(USBD_NORMAL_COMPLETION);                  return(USBD_NORMAL_COMPLETION);
   
        s = splusb();        KUE_LOCK(sc);
   
         if (rw == KUE_CTL_WRITE)          if (rw == KUE_CTL_WRITE)
                 req.bmRequestType = UT_WRITE_VENDOR_DEVICE;                  req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
Line 247  kue_ctl(struct kue_softc *sc, int rw, u_ Line 251  kue_ctl(struct kue_softc *sc, int rw, u_
   
         err = kue_do_request(dev, &req, data);          err = kue_do_request(dev, &req, data);
   
        splx(s);        KUE_UNLOCK(sc);
   
         return(err);          return(err);
 }  }
Line 327  kue_setmulti(struct kue_softc *sc) Line 331  kue_setmulti(struct kue_softc *sc)
   
         sc->kue_rxfilt &= ~KUE_RXFILT_ALLMULTI;          sc->kue_rxfilt &= ~KUE_RXFILT_ALLMULTI;
   
        for (ifma = ifp->if_multiaddrs.lh_first; ifma != NULL;#if __FreeBSD_version >= 500000
            ifma = ifma->ifma_link.le_next) {        TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link)
 #else
         LIST_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link)
 #endif
         {
                 if (ifma->ifma_addr->sa_family != AF_LINK)                  if (ifma->ifma_addr->sa_family != AF_LINK)
                         continue;                          continue;
                 /*                  /*
Line 363  kue_setmulti(struct kue_softc *sc) Line 371  kue_setmulti(struct kue_softc *sc)
 Static void  Static void
 kue_reset(struct kue_softc *sc)  kue_reset(struct kue_softc *sc)
 {  {
        if (usbd_set_config_no(sc->kue_udev, KUE_CONFIG_NO, 0)) {        if (usbd_set_config_no(sc->kue_udev, KUE_CONFIG_NO, 0) ||
             usbd_device2interface_handle(sc->kue_udev, KUE_IFACE_IDX,
             &sc->kue_iface)) {
                 printf("kue%d: getting interface handle failed\n",                  printf("kue%d: getting interface handle failed\n",
                     sc->kue_unit);                      sc->kue_unit);
         }          }
Line 404  USB_ATTACH(kue) Line 414  USB_ATTACH(kue)
 {  {
         USB_ATTACH_START(kue, sc, uaa);          USB_ATTACH_START(kue, sc, uaa);
         char                    devinfo[1024];          char                    devinfo[1024];
         int                     s;  
         struct ifnet            *ifp;          struct ifnet            *ifp;
         usbd_status             err;          usbd_status             err;
         usb_interface_descriptor_t      *id;          usb_interface_descriptor_t      *id;
         usb_endpoint_descriptor_t       *ed;          usb_endpoint_descriptor_t       *ed;
         int                     i;          int                     i;
   
         s = splimp();  
   
         bzero(sc, sizeof(struct kue_softc));          bzero(sc, sizeof(struct kue_softc));
         sc->kue_iface = uaa->iface;          sc->kue_iface = uaa->iface;
         sc->kue_udev = uaa->device;          sc->kue_udev = uaa->device;
Line 430  USB_ATTACH(kue) Line 437  USB_ATTACH(kue)
                 if (!ed) {                  if (!ed) {
                         printf("kue%d: couldn't get ep %d\n",                          printf("kue%d: couldn't get ep %d\n",
                             sc->kue_unit, i);                              sc->kue_unit, i);
                         splx(s);  
                         USB_ATTACH_ERROR_RETURN;                          USB_ATTACH_ERROR_RETURN;
                 }                  }
                 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&                  if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
                    (ed->bmAttributes & UE_XFERTYPE) == UE_BULK) {                    UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
                         sc->kue_ed[KUE_ENDPT_RX] = ed->bEndpointAddress;                          sc->kue_ed[KUE_ENDPT_RX] = ed->bEndpointAddress;
                 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&                  } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
                    (ed->bmAttributes & UE_XFERTYPE) == UE_BULK) {                           UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
                         sc->kue_ed[KUE_ENDPT_TX] = ed->bEndpointAddress;                          sc->kue_ed[KUE_ENDPT_TX] = ed->bEndpointAddress;
                 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&                  } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
                    (ed->bmAttributes & UE_XFERTYPE) == UE_INTERRUPT) {                           UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
                         sc->kue_ed[KUE_ENDPT_INTR] = ed->bEndpointAddress;                          sc->kue_ed[KUE_ENDPT_INTR] = ed->bEndpointAddress;
                 }                  }
         }          }
   
   #if __FreeBSD_version >= 500000
           mtx_init(&sc->kue_mtx, device_get_nameunit(self), MTX_NETWORK_LOCK,
               MTX_DEF | MTX_RECURSE);
   #endif
           KUE_LOCK(sc);
   
         /* Load the firmware into the NIC. */          /* Load the firmware into the NIC. */
         if (kue_load_fw(sc)) {          if (kue_load_fw(sc)) {
                splx(s);                KUE_UNLOCK(sc);
 #if __FreeBSD_version >= 500000
                 mtx_destroy(&sc->kue_mtx);
 #endif
                 USB_ATTACH_ERROR_RETURN;                  USB_ATTACH_ERROR_RETURN;
         }          }
   
Line 472  USB_ATTACH(kue) Line 487  USB_ATTACH(kue)
   
         ifp = &sc->arpcom.ac_if;          ifp = &sc->arpcom.ac_if;
         ifp->if_softc = sc;          ifp->if_softc = sc;
        ifp->if_unit = sc->kue_unit;        if_initname(ifp, "kue", sc->kue_unit);
        ifp->if_name = "kue"; 
         ifp->if_mtu = ETHERMTU;          ifp->if_mtu = ETHERMTU;
         ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;          ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
         ifp->if_ioctl = kue_ioctl;          ifp->if_ioctl = kue_ioctl;
Line 490  USB_ATTACH(kue) Line 504  USB_ATTACH(kue)
         /*          /*
          * Call MI attach routine.           * Call MI attach routine.
          */           */
   #if __FreeBSD_version >= 500000
           ether_ifattach(ifp, sc->kue_desc.kue_macaddr);
   #else
         ether_ifattach(ifp, ETHER_BPF_SUPPORTED);          ether_ifattach(ifp, ETHER_BPF_SUPPORTED);
   #endif
         usb_register_netisr();          usb_register_netisr();
        sc->kue_gone = 0;        sc->kue_dying = 0;
 
         KUE_UNLOCK(sc);
   
         splx(s);  
         USB_ATTACH_SUCCESS_RETURN;          USB_ATTACH_SUCCESS_RETURN;
 }  }
   
Line 503  kue_detach(device_ptr_t dev) Line 522  kue_detach(device_ptr_t dev)
 {  {
         struct kue_softc        *sc;          struct kue_softc        *sc;
         struct ifnet            *ifp;          struct ifnet            *ifp;
         int                     s;  
   
         s = splusb();  
   
         sc = device_get_softc(dev);          sc = device_get_softc(dev);
           KUE_LOCK(sc);
         ifp = &sc->arpcom.ac_if;          ifp = &sc->arpcom.ac_if;
   
        sc->kue_gone = 1;        sc->kue_dying = 1;
   
         if (ifp != NULL)          if (ifp != NULL)
   #if __FreeBSD_version >= 500000
                   ether_ifdetach(ifp);
   #else
                 ether_ifdetach(ifp, ETHER_BPF_SUPPORTED);                  ether_ifdetach(ifp, ETHER_BPF_SUPPORTED);
   #endif
   
         if (sc->kue_ep[KUE_ENDPT_TX] != NULL)          if (sc->kue_ep[KUE_ENDPT_TX] != NULL)
                 usbd_abort_pipe(sc->kue_ep[KUE_ENDPT_TX]);                  usbd_abort_pipe(sc->kue_ep[KUE_ENDPT_TX]);
Line 525  kue_detach(device_ptr_t dev) Line 546  kue_detach(device_ptr_t dev)
         if (sc->kue_mcfilters != NULL)          if (sc->kue_mcfilters != NULL)
                 free(sc->kue_mcfilters, M_USBDEV);                  free(sc->kue_mcfilters, M_USBDEV);
   
        splx(s);        KUE_UNLOCK(sc);
 #if __FreeBSD_version >= 500000
         mtx_destroy(&sc->kue_mtx);
 #endif
   
         return(0);          return(0);
 }  }
Line 622  kue_rxstart(struct ifnet *ifp) Line 646  kue_rxstart(struct ifnet *ifp)
         struct kue_chain        *c;          struct kue_chain        *c;
   
         sc = ifp->if_softc;          sc = ifp->if_softc;
           KUE_LOCK(sc);
         c = &sc->kue_cdata.kue_rx_chain[sc->kue_cdata.kue_rx_prod];          c = &sc->kue_cdata.kue_rx_chain[sc->kue_cdata.kue_rx_prod];
   
         if (kue_newbuf(sc, c, NULL) == ENOBUFS) {          if (kue_newbuf(sc, c, NULL) == ENOBUFS) {
Line 635  kue_rxstart(struct ifnet *ifp) Line 660  kue_rxstart(struct ifnet *ifp)
             USBD_NO_TIMEOUT, kue_rxeof);              USBD_NO_TIMEOUT, kue_rxeof);
         usbd_transfer(c->kue_xfer);          usbd_transfer(c->kue_xfer);
   
           KUE_UNLOCK(sc);
   
         return;          return;
 }  }
   
Line 654  Static void kue_rxeof(usbd_xfer_handle x Line 681  Static void kue_rxeof(usbd_xfer_handle x
   
         c = priv;          c = priv;
         sc = c->kue_sc;          sc = c->kue_sc;
           KUE_LOCK(sc);
         ifp = &sc->arpcom.ac_if;          ifp = &sc->arpcom.ac_if;
   
        if (!(ifp->if_flags & IFF_RUNNING))        if (!(ifp->if_flags & IFF_RUNNING)) {
                 KUE_UNLOCK(sc);
                 return;                  return;
           }
   
         if (status != USBD_NORMAL_COMPLETION) {          if (status != USBD_NORMAL_COMPLETION) {
                if (status == USBD_NOT_STARTED || status == USBD_CANCELLED)                if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) {
                         KUE_UNLOCK(sc);
                         return;                          return;
                printf("kue%d: usb error on rx: %s\n", sc->kue_unit,                }
                    usbd_errstr(status));                if (usbd_ratecheck(&sc->kue_rx_notice))
                         printf("kue%d: usb error on rx: %s\n", sc->kue_unit,
                             usbd_errstr(status));
                 if (status == USBD_STALLED)                  if (status == USBD_STALLED)
                         usbd_clear_endpoint_stall(sc->kue_ep[KUE_ENDPT_RX]);                          usbd_clear_endpoint_stall(sc->kue_ep[KUE_ENDPT_RX]);
                 goto done;                  goto done;
Line 691  Static void kue_rxeof(usbd_xfer_handle x Line 724  Static void kue_rxeof(usbd_xfer_handle x
   
         /* Put the packet on the special USB input queue. */          /* Put the packet on the special USB input queue. */
         usb_ether_input(m);          usb_ether_input(m);
           KUE_UNLOCK(sc);
   
         return;          return;
 done:  done:
Line 700  done: Line 734  done:
             c, mtod(c->kue_mbuf, char *), KUE_BUFSZ, USBD_SHORT_XFER_OK,              c, mtod(c->kue_mbuf, char *), KUE_BUFSZ, USBD_SHORT_XFER_OK,
             USBD_NO_TIMEOUT, kue_rxeof);              USBD_NO_TIMEOUT, kue_rxeof);
         usbd_transfer(c->kue_xfer);          usbd_transfer(c->kue_xfer);
           KUE_UNLOCK(sc);
   
         return;          return;
 }  }
Line 716  kue_txeof(usbd_xfer_handle xfer, usbd_pr Line 751  kue_txeof(usbd_xfer_handle xfer, usbd_pr
         struct kue_chain        *c;          struct kue_chain        *c;
         struct ifnet            *ifp;          struct ifnet            *ifp;
         usbd_status             err;          usbd_status             err;
         int                     s;  
   
         s = splimp();  
   
         c = priv;          c = priv;
         sc = c->kue_sc;          sc = c->kue_sc;
           KUE_LOCK(sc);
   
         ifp = &sc->arpcom.ac_if;          ifp = &sc->arpcom.ac_if;
         ifp->if_timer = 0;          ifp->if_timer = 0;
         ifp->if_flags &= ~IFF_OACTIVE;          ifp->if_flags &= ~IFF_OACTIVE;
   
         if (status != USBD_NORMAL_COMPLETION) {          if (status != USBD_NORMAL_COMPLETION) {
                 if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) {                  if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) {
                        splx(s);                        KUE_UNLOCK(sc);
                         return;                          return;
                 }                  }
                 printf("kue%d: usb error on tx: %s\n", sc->kue_unit,                  printf("kue%d: usb error on tx: %s\n", sc->kue_unit,
                     usbd_errstr(status));                      usbd_errstr(status));
                 if (status == USBD_STALLED)                  if (status == USBD_STALLED)
                         usbd_clear_endpoint_stall(sc->kue_ep[KUE_ENDPT_TX]);                          usbd_clear_endpoint_stall(sc->kue_ep[KUE_ENDPT_TX]);
                splx(s);                KUE_UNLOCK(sc);
                 return;                  return;
         }          }
   
Line 752  kue_txeof(usbd_xfer_handle xfer, usbd_pr Line 786  kue_txeof(usbd_xfer_handle xfer, usbd_pr
         else          else
                 ifp->if_opackets++;                  ifp->if_opackets++;
   
        splx(s);        KUE_UNLOCK(sc);
   
         return;          return;
 }  }
Line 802  kue_start(struct ifnet *ifp) Line 836  kue_start(struct ifnet *ifp)
         struct mbuf             *m_head = NULL;          struct mbuf             *m_head = NULL;
   
         sc = ifp->if_softc;          sc = ifp->if_softc;
           KUE_LOCK(sc);
   
        if (ifp->if_flags & IFF_OACTIVE)        if (ifp->if_flags & IFF_OACTIVE) {
                 KUE_UNLOCK(sc);
                 return;                  return;
           }
   
         IF_DEQUEUE(&ifp->if_snd, m_head);          IF_DEQUEUE(&ifp->if_snd, m_head);
        if (m_head == NULL)        if (m_head == NULL) {
                 KUE_UNLOCK(sc);
                 return;                  return;
           }
   
         if (kue_encap(sc, m_head, 0)) {          if (kue_encap(sc, m_head, 0)) {
                 IF_PREPEND(&ifp->if_snd, m_head);                  IF_PREPEND(&ifp->if_snd, m_head);
                 ifp->if_flags |= IFF_OACTIVE;                  ifp->if_flags |= IFF_OACTIVE;
                   KUE_UNLOCK(sc);
                 return;                  return;
         }          }
   
Line 820  kue_start(struct ifnet *ifp) Line 860  kue_start(struct ifnet *ifp)
          * If there's a BPF listener, bounce a copy of this frame           * If there's a BPF listener, bounce a copy of this frame
          * to him.           * to him.
          */           */
        if (ifp->if_bpf)        BPF_MTAP(ifp, m_head);
                bpf_mtap(ifp, m_head); 
   
         ifp->if_flags |= IFF_OACTIVE;          ifp->if_flags |= IFF_OACTIVE;
   
Line 829  kue_start(struct ifnet *ifp) Line 868  kue_start(struct ifnet *ifp)
          * Set a timeout in case the chip goes out to lunch.           * Set a timeout in case the chip goes out to lunch.
          */           */
         ifp->if_timer = 5;          ifp->if_timer = 5;
           KUE_UNLOCK(sc);
   
         return;          return;
 }  }
Line 840  kue_init(void *xsc) Line 880  kue_init(void *xsc)
         struct ifnet            *ifp = &sc->arpcom.ac_if;          struct ifnet            *ifp = &sc->arpcom.ac_if;
         struct kue_chain        *c;          struct kue_chain        *c;
         usbd_status             err;          usbd_status             err;
        int                     i, s;        int                     i;
   
        if (ifp->if_flags & IFF_RUNNING)        KUE_LOCK(sc);
                return; 
   
        s = splimp();        if (ifp->if_flags & IFF_RUNNING) {
                 KUE_UNLOCK(sc);
                 return;
         }
   
         /* Set MAC address */          /* Set MAC address */
         kue_ctl(sc, KUE_CTL_WRITE, KUE_CMD_SET_MAC,          kue_ctl(sc, KUE_CTL_WRITE, KUE_CMD_SET_MAC,
Line 872  kue_init(void *xsc) Line 914  kue_init(void *xsc)
         /* Init TX ring. */          /* Init TX ring. */
         if (kue_tx_list_init(sc) == ENOBUFS) {          if (kue_tx_list_init(sc) == ENOBUFS) {
                 printf("kue%d: tx list init failed\n", sc->kue_unit);                  printf("kue%d: tx list init failed\n", sc->kue_unit);
                splx(s);                KUE_UNLOCK(sc);
                 return;                  return;
         }          }
   
         /* Init RX ring. */          /* Init RX ring. */
         if (kue_rx_list_init(sc) == ENOBUFS) {          if (kue_rx_list_init(sc) == ENOBUFS) {
                 printf("kue%d: rx list init failed\n", sc->kue_unit);                  printf("kue%d: rx list init failed\n", sc->kue_unit);
                splx(s);                KUE_UNLOCK(sc);
                 return;                  return;
         }          }
   
Line 892  kue_init(void *xsc) Line 934  kue_init(void *xsc)
         if (err) {          if (err) {
                 printf("kue%d: open rx pipe failed: %s\n",                  printf("kue%d: open rx pipe failed: %s\n",
                     sc->kue_unit, usbd_errstr(err));                      sc->kue_unit, usbd_errstr(err));
                splx(s);                KUE_UNLOCK(sc);
                 return;                  return;
         }          }
   
Line 901  kue_init(void *xsc) Line 943  kue_init(void *xsc)
         if (err) {          if (err) {
                 printf("kue%d: open tx pipe failed: %s\n",                  printf("kue%d: open tx pipe failed: %s\n",
                     sc->kue_unit, usbd_errstr(err));                      sc->kue_unit, usbd_errstr(err));
                splx(s);                KUE_UNLOCK(sc);
                 return;                  return;
         }          }
   
Line 917  kue_init(void *xsc) Line 959  kue_init(void *xsc)
         ifp->if_flags |= IFF_RUNNING;          ifp->if_flags |= IFF_RUNNING;
         ifp->if_flags &= ~IFF_OACTIVE;          ifp->if_flags &= ~IFF_OACTIVE;
   
        (void)splx(s);        KUE_UNLOCK(sc);
   
         return;          return;
 }  }
Line 926  Static int Line 968  Static int
 kue_ioctl(struct ifnet *ifp, u_long command, caddr_t data)  kue_ioctl(struct ifnet *ifp, u_long command, caddr_t data)
 {  {
         struct kue_softc        *sc = ifp->if_softc;          struct kue_softc        *sc = ifp->if_softc;
        int                     s, error = 0;        int                     error = 0;
   
        s = splimp();        KUE_LOCK(sc);
   
         switch(command) {          switch(command) {
         case SIOCSIFADDR:  
         case SIOCGIFADDR:  
         case SIOCSIFMTU:  
                 error = ether_ioctl(ifp, command, data);  
                 break;  
         case SIOCSIFFLAGS:          case SIOCSIFFLAGS:
                 if (ifp->if_flags & IFF_UP) {                  if (ifp->if_flags & IFF_UP) {
                         if (ifp->if_flags & IFF_RUNNING &&                          if (ifp->if_flags & IFF_RUNNING &&
Line 965  kue_ioctl(struct ifnet *ifp, u_long comm Line 1002  kue_ioctl(struct ifnet *ifp, u_long comm
                 error = 0;                  error = 0;
                 break;                  break;
         default:          default:
                error = EINVAL;                error = ether_ioctl(ifp, command, data);
                 break;                  break;
         }          }
   
        (void)splx(s);        KUE_UNLOCK(sc);
   
         return(error);          return(error);
 }  }
Line 982  kue_watchdog(struct ifnet *ifp) Line 1019  kue_watchdog(struct ifnet *ifp)
         usbd_status             stat;          usbd_status             stat;
   
         sc = ifp->if_softc;          sc = ifp->if_softc;
        KUE_LOCK(sc);
         ifp->if_oerrors++;          ifp->if_oerrors++;
         printf("kue%d: watchdog timeout\n", sc->kue_unit);          printf("kue%d: watchdog timeout\n", sc->kue_unit);
   
Line 992  kue_watchdog(struct ifnet *ifp) Line 1029  kue_watchdog(struct ifnet *ifp)
   
         if (ifp->if_snd.ifq_head != NULL)          if (ifp->if_snd.ifq_head != NULL)
                 kue_start(ifp);                  kue_start(ifp);
           KUE_UNLOCK(sc);
   
         return;          return;
 }  }
Line 1007  kue_stop(struct kue_softc *sc) Line 1045  kue_stop(struct kue_softc *sc)
         struct ifnet            *ifp;          struct ifnet            *ifp;
         int                     i;          int                     i;
   
           KUE_LOCK(sc);
         ifp = &sc->arpcom.ac_if;          ifp = &sc->arpcom.ac_if;
         ifp->if_timer = 0;          ifp->if_timer = 0;
   
Line 1086  kue_stop(struct kue_softc *sc) Line 1125  kue_stop(struct kue_softc *sc)
         }          }
   
         ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);          ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
           KUE_UNLOCK(sc);
   
         return;          return;
 }  }

Removed from v.1.4  
changed lines
  Added in v.1.5