[BACK]Return to if_kue.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / sys / dev / usb

Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.

Diff for /src/sys/dev/usb/if_kue.c between version 1.81 and 1.81.4.8

version 1.81, 2014/08/10 16:44:36 version 1.81.4.8, 2015/12/28 09:26:33
Line 81  __KERNEL_RCSID(0, "$NetBSD$");
Line 81  __KERNEL_RCSID(0, "$NetBSD$");
 #include <sys/systm.h>  #include <sys/systm.h>
 #include <sys/sockio.h>  #include <sys/sockio.h>
 #include <sys/mbuf.h>  #include <sys/mbuf.h>
 #include <sys/malloc.h>  #include <sys/kmem.h>
 #include <sys/kernel.h>  #include <sys/kernel.h>
 #include <sys/socket.h>  #include <sys/socket.h>
 #include <sys/device.h>  #include <sys/device.h>
 #include <sys/proc.h>  #include <sys/proc.h>
 #include <sys/rnd.h>  #include <sys/rndsource.h>
   
 #include <net/if.h>  #include <net/if.h>
 #include <net/if_arp.h>  #include <net/if_arp.h>
Line 168  static int kue_tx_list_init(struct kue_s
Line 168  static int kue_tx_list_init(struct kue_s
 static int kue_rx_list_init(struct kue_softc *);  static int kue_rx_list_init(struct kue_softc *);
 static int kue_send(struct kue_softc *, struct mbuf *, int);  static int kue_send(struct kue_softc *, struct mbuf *, int);
 static int kue_open_pipes(struct kue_softc *);  static int kue_open_pipes(struct kue_softc *);
 static void kue_rxeof(usbd_xfer_handle, usbd_private_handle, usbd_status);  static void kue_rxeof(struct usbd_xfer *, void *, usbd_status);
 static void kue_txeof(usbd_xfer_handle, usbd_private_handle, usbd_status);  static void kue_txeof(struct usbd_xfer *, void *, usbd_status);
 static void kue_start(struct ifnet *);  static void kue_start(struct ifnet *);
 static int kue_ioctl(struct ifnet *, u_long, void *);  static int kue_ioctl(struct ifnet *, u_long, void *);
 static void kue_init(void *);  static void kue_init(void *);
Line 197  kue_setword(struct kue_softc *sc, uint8_
Line 197  kue_setword(struct kue_softc *sc, uint8_
         USETW(req.wIndex, 0);          USETW(req.wIndex, 0);
         USETW(req.wLength, 0);          USETW(req.wLength, 0);
   
         return (usbd_do_request(sc->kue_udev, &req, NULL));          return usbd_do_request(sc->kue_udev, &req, NULL);
 }  }
   
 static usbd_status  static usbd_status
Line 219  kue_ctl(struct kue_softc *sc, int rw, ui
Line 219  kue_ctl(struct kue_softc *sc, int rw, ui
         USETW(req.wIndex, 0);          USETW(req.wIndex, 0);
         USETW(req.wLength, len);          USETW(req.wLength, len);
   
         return (usbd_do_request(sc->kue_udev, &req, data));          return usbd_do_request(sc->kue_udev, &req, data);
 }  }
   
 static int  static int
Line 245  kue_load_fw(struct kue_softc *sc)
Line 245  kue_load_fw(struct kue_softc *sc)
          * running.           * running.
          */           */
         if (usbd_get_device_desc(sc->kue_udev, &dd))          if (usbd_get_device_desc(sc->kue_udev, &dd))
                 return (EIO);                  return EIO;
         if (UGETW(dd.bcdDevice) == KUE_WARM_REV) {          if (UGETW(dd.bcdDevice) == KUE_WARM_REV) {
                 printf("%s: warm boot, no firmware download\n",                  printf("%s: warm boot, no firmware download\n",
                        device_xname(sc->kue_dev));                         device_xname(sc->kue_dev));
                 return (0);                  return 0;
         }          }
   
         printf("%s: cold boot, downloading firmware\n",          printf("%s: cold boot, downloading firmware\n",
Line 264  kue_load_fw(struct kue_softc *sc)
Line 264  kue_load_fw(struct kue_softc *sc)
         if (err) {          if (err) {
                 printf("%s: failed to load code segment: %s\n",                  printf("%s: failed to load code segment: %s\n",
                     device_xname(sc->kue_dev), usbd_errstr(err));                      device_xname(sc->kue_dev), usbd_errstr(err));
                         return (EIO);                          return EIO;
         }          }
   
         /* Load fixup segment */          /* Load fixup segment */
Line 276  kue_load_fw(struct kue_softc *sc)
Line 276  kue_load_fw(struct kue_softc *sc)
         if (err) {          if (err) {
                 printf("%s: failed to load fixup segment: %s\n",                  printf("%s: failed to load fixup segment: %s\n",
                     device_xname(sc->kue_dev), usbd_errstr(err));                      device_xname(sc->kue_dev), usbd_errstr(err));
                         return (EIO);                          return EIO;
         }          }
   
         /* Send trigger command. */          /* Send trigger command. */
Line 288  kue_load_fw(struct kue_softc *sc)
Line 288  kue_load_fw(struct kue_softc *sc)
         if (err) {          if (err) {
                 printf("%s: failed to load trigger segment: %s\n",                  printf("%s: failed to load trigger segment: %s\n",
                     device_xname(sc->kue_dev), usbd_errstr(err));                      device_xname(sc->kue_dev), usbd_errstr(err));
                         return (EIO);                          return EIO;
         }          }
   
         usbd_delay_ms(sc->kue_udev, 10);          usbd_delay_ms(sc->kue_udev, 10);
Line 308  kue_load_fw(struct kue_softc *sc)
Line 308  kue_load_fw(struct kue_softc *sc)
         /* Reset the adapter. */          /* Reset the adapter. */
         kue_reset(sc);          kue_reset(sc);
   
         return (0);          return 0;
 }  }
   
 static void  static void
Line 383  kue_match(device_t parent, cfdata_t matc
Line 383  kue_match(device_t parent, cfdata_t matc
   
         DPRINTFN(25,("kue_match: enter\n"));          DPRINTFN(25,("kue_match: enter\n"));
   
         return (kue_lookup(uaa->vendor, uaa->product) != NULL ?          return kue_lookup(uaa->uaa_vendor, uaa->uaa_product) != NULL ?
                 UMATCH_VENDOR_PRODUCT : UMATCH_NONE);                  UMATCH_VENDOR_PRODUCT : UMATCH_NONE;
 }  }
   
 /*  /*
Line 399  kue_attach(device_t parent, device_t sel
Line 399  kue_attach(device_t parent, device_t sel
         char                    *devinfop;          char                    *devinfop;
         int                     s;          int                     s;
         struct ifnet            *ifp;          struct ifnet            *ifp;
         usbd_device_handle      dev = uaa->device;          struct usbd_device *    dev = uaa->uaa_device;
         usbd_interface_handle   iface;          struct usbd_interface * iface;
         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;
Line 425  kue_attach(device_t parent, device_t sel
Line 425  kue_attach(device_t parent, device_t sel
         }          }
   
         sc->kue_udev = dev;          sc->kue_udev = dev;
         sc->kue_product = uaa->product;          sc->kue_product = uaa->uaa_product;
         sc->kue_vendor = uaa->vendor;          sc->kue_vendor = uaa->uaa_vendor;
   
         /* Load the firmware into the NIC. */          /* Load the firmware into the NIC. */
         if (kue_load_fw(sc)) {          if (kue_load_fw(sc)) {
Line 475  kue_attach(device_t parent, device_t sel
Line 475  kue_attach(device_t parent, device_t sel
                 return;                  return;
         }          }
   
         sc->kue_mcfilters = malloc(KUE_MCFILTCNT(sc) * ETHER_ADDR_LEN,          sc->kue_mcfilters = kmem_alloc(KUE_MCFILTCNT(sc) * ETHER_ADDR_LEN,
             M_USBDEV, M_NOWAIT);              KM_SLEEP);
         if (sc->kue_mcfilters == NULL) {          if (sc->kue_mcfilters == NULL) {
                 aprint_error_dev(self,                  aprint_error_dev(self,
                     "no memory for multicast filter buffer\n");                      "no memory for multicast filter buffer\n");
Line 528  kue_detach(device_t self, int flags)
Line 528  kue_detach(device_t self, int flags)
         s = splusb();           /* XXX why? */          s = splusb();           /* XXX why? */
   
         if (sc->kue_mcfilters != NULL) {          if (sc->kue_mcfilters != NULL) {
                 free(sc->kue_mcfilters, M_USBDEV);                  kmem_free(sc->kue_mcfilters,
                       KUE_MCFILTCNT(sc) * ETHER_ADDR_LEN);
                 sc->kue_mcfilters = NULL;                  sc->kue_mcfilters = NULL;
         }          }
   
         if (!sc->kue_attached) {          if (!sc->kue_attached) {
                 /* Detached before attached finished, so just bail out. */                  /* Detached before attached finished, so just bail out. */
                 splx(s);                  splx(s);
                 return (0);                  return 0;
         }          }
   
         if (ifp->if_flags & IFF_RUNNING)          if (ifp->if_flags & IFF_RUNNING)
Line 556  kue_detach(device_t self, int flags)
Line 557  kue_detach(device_t self, int flags)
         sc->kue_attached = false;          sc->kue_attached = false;
         splx(s);          splx(s);
   
         return (0);          return 0;
 }  }
   
 int  int
Line 592  kue_rx_list_init(struct kue_softc *sc)
Line 593  kue_rx_list_init(struct kue_softc *sc)
                 c->kue_sc = sc;                  c->kue_sc = sc;
                 c->kue_idx = i;                  c->kue_idx = i;
                 if (c->kue_xfer == NULL) {                  if (c->kue_xfer == NULL) {
                         c->kue_xfer = usbd_alloc_xfer(sc->kue_udev);                          int error = usbd_create_xfer(sc->kue_ep[KUE_ENDPT_RX],
                         if (c->kue_xfer == NULL)                              KUE_BUFSZ, USBD_SHORT_XFER_OK, 0, &c->kue_xfer);
                                 return (ENOBUFS);                          if (error)
                         c->kue_buf = usbd_alloc_buffer(c->kue_xfer, KUE_BUFSZ);                                  return error;
                         if (c->kue_buf == NULL)                          c->kue_buf = usbd_get_buffer(c->kue_xfer);
                                 return (ENOBUFS); /* XXX free xfer */  
                 }                  }
         }          }
   
         return (0);          return 0;
 }  }
   
 static int  static int
Line 619  kue_tx_list_init(struct kue_softc *sc)
Line 619  kue_tx_list_init(struct kue_softc *sc)
                 c->kue_sc = sc;                  c->kue_sc = sc;
                 c->kue_idx = i;                  c->kue_idx = i;
                 if (c->kue_xfer == NULL) {                  if (c->kue_xfer == NULL) {
                         c->kue_xfer = usbd_alloc_xfer(sc->kue_udev);                          int error = usbd_create_xfer(sc->kue_ep[KUE_ENDPT_TX],
                         if (c->kue_xfer == NULL)                              KUE_BUFSZ, 0, 0, &c->kue_xfer);
                                 return (ENOBUFS);                          if (error)
                         c->kue_buf = usbd_alloc_buffer(c->kue_xfer, KUE_BUFSZ);                                  return error;
                         if (c->kue_buf == NULL)                          c->kue_buf = usbd_get_buffer(c->kue_xfer);
                                 return (ENOBUFS);  
                 }                  }
         }          }
   
         return (0);          return 0;
 }  }
   
 /*  /*
Line 636  kue_tx_list_init(struct kue_softc *sc)
Line 635  kue_tx_list_init(struct kue_softc *sc)
  * the higher level protocols.   * the higher level protocols.
  */   */
 static void  static void
 kue_rxeof(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)  kue_rxeof(struct usbd_xfer *xfer, void *priv, usbd_status status)
 {  {
         struct kue_chain        *c = priv;          struct kue_chain        *c = priv;
         struct kue_softc        *sc = c->kue_sc;          struct kue_softc        *sc = c->kue_sc;
Line 730  kue_rxeof(usbd_xfer_handle xfer, usbd_pr
Line 729  kue_rxeof(usbd_xfer_handle xfer, usbd_pr
  done:   done:
   
         /* Setup new transfer. */          /* Setup new transfer. */
         usbd_setup_xfer(c->kue_xfer, sc->kue_ep[KUE_ENDPT_RX],          usbd_setup_xfer(c->kue_xfer, c, c->kue_buf, KUE_BUFSZ,
             c, c->kue_buf, KUE_BUFSZ, USBD_SHORT_XFER_OK | USBD_NO_COPY,              USBD_SHORT_XFER_OK, USBD_NO_TIMEOUT, kue_rxeof);
             USBD_NO_TIMEOUT, kue_rxeof);  
         usbd_transfer(c->kue_xfer);          usbd_transfer(c->kue_xfer);
   
         DPRINTFN(10,("%s: %s: start rx\n", device_xname(sc->kue_dev),          DPRINTFN(10,("%s: %s: start rx\n", device_xname(sc->kue_dev),
Line 745  kue_rxeof(usbd_xfer_handle xfer, usbd_pr
Line 743  kue_rxeof(usbd_xfer_handle xfer, usbd_pr
  */   */
   
 static void  static void
 kue_txeof(usbd_xfer_handle xfer, usbd_private_handle priv,  kue_txeof(struct usbd_xfer *xfer, void *priv,
     usbd_status status)      usbd_status status)
 {  {
         struct kue_chain        *c = priv;          struct kue_chain        *c = priv;
Line 809  kue_send(struct kue_softc *sc, struct mb
Line 807  kue_send(struct kue_softc *sc, struct mb
         total_len = 2 + m->m_pkthdr.len;          total_len = 2 + m->m_pkthdr.len;
         total_len = roundup2(total_len, 64);          total_len = roundup2(total_len, 64);
   
         usbd_setup_xfer(c->kue_xfer, sc->kue_ep[KUE_ENDPT_TX],          usbd_setup_xfer(c->kue_xfer, c, c->kue_buf, total_len, 0,
             c, c->kue_buf, total_len, USBD_NO_COPY, USBD_DEFAULT_TIMEOUT,              USBD_DEFAULT_TIMEOUT, kue_txeof);
             kue_txeof);  
   
         /* Transmit */          /* Transmit */
         err = usbd_transfer(c->kue_xfer);          err = usbd_transfer(c->kue_xfer);
Line 819  kue_send(struct kue_softc *sc, struct mb
Line 816  kue_send(struct kue_softc *sc, struct mb
                 printf("%s: kue_send error=%s\n", device_xname(sc->kue_dev),                  printf("%s: kue_send error=%s\n", device_xname(sc->kue_dev),
                        usbd_errstr(err));                         usbd_errstr(err));
                 kue_stop(sc);                  kue_stop(sc);
                 return (EIO);                  return EIO;
         }          }
   
         sc->kue_cdata.kue_tx_cnt++;          sc->kue_cdata.kue_tx_cnt++;
   
         return (0);          return 0;
 }  }
   
 static void  static void
Line 904  kue_init(void *xsc)
Line 901  kue_init(void *xsc)
 #endif  #endif
         kue_setword(sc, KUE_CMD_SET_URB_SIZE, 64);          kue_setword(sc, KUE_CMD_SET_URB_SIZE, 64);
   
           /* Load the multicast filter. */
           kue_setmulti(sc);
   
           if (sc->kue_ep[KUE_ENDPT_RX] == NULL) {
                   if (kue_open_pipes(sc)) {
                           splx(s);
                           return;
                   }
           }
         /* Init TX ring. */          /* Init TX ring. */
         if (kue_tx_list_init(sc) == ENOBUFS) {          if (kue_tx_list_init(sc)) {
                 printf("%s: tx list init failed\n", device_xname(sc->kue_dev));                  printf("%s: tx list init failed\n", device_xname(sc->kue_dev));
                 splx(s);                  splx(s);
                 return;                  return;
         }          }
   
         /* Init RX ring. */          /* Init RX ring. */
         if (kue_rx_list_init(sc) == ENOBUFS) {          if (kue_rx_list_init(sc)) {
                 printf("%s: rx list init failed\n", device_xname(sc->kue_dev));                  printf("%s: rx list init failed\n", device_xname(sc->kue_dev));
                 splx(s);                  splx(s);
                 return;                  return;
         }          }
   
         /* Load the multicast filter. */          /* Start up the receive pipe. */
         kue_setmulti(sc);          for (size_t i = 0; i < KUE_RX_LIST_CNT; i++) {
                   struct kue_chain *c = &sc->kue_cdata.kue_rx_chain[i];
         if (sc->kue_ep[KUE_ENDPT_RX] == NULL) {                  usbd_setup_xfer(c->kue_xfer, c, c->kue_buf, KUE_BUFSZ,
                 if (kue_open_pipes(sc)) {                      USBD_SHORT_XFER_OK, USBD_NO_TIMEOUT, kue_rxeof);
                         splx(s);                  DPRINTFN(5,("%s: %s: start read\n", device_xname(sc->kue_dev),
                         return;                              __func__));
                 }                  usbd_transfer(c->kue_xfer);
         }          }
   
         ifp->if_flags |= IFF_RUNNING;          ifp->if_flags |= IFF_RUNNING;
Line 938  static int
Line 944  static int
 kue_open_pipes(struct kue_softc *sc)  kue_open_pipes(struct kue_softc *sc)
 {  {
         usbd_status             err;          usbd_status             err;
         struct kue_chain        *c;  
         int                     i;  
   
         DPRINTFN(5,("%s: %s: enter\n", device_xname(sc->kue_dev),__func__));          DPRINTFN(5,("%s: %s: enter\n", device_xname(sc->kue_dev),__func__));
   
Line 949  kue_open_pipes(struct kue_softc *sc)
Line 953  kue_open_pipes(struct kue_softc *sc)
         if (err) {          if (err) {
                 printf("%s: open rx pipe failed: %s\n",                  printf("%s: open rx pipe failed: %s\n",
                     device_xname(sc->kue_dev), usbd_errstr(err));                      device_xname(sc->kue_dev), usbd_errstr(err));
                 return (EIO);                  return EIO;
         }          }
   
         err = usbd_open_pipe(sc->kue_iface, sc->kue_ed[KUE_ENDPT_TX],          err = usbd_open_pipe(sc->kue_iface, sc->kue_ed[KUE_ENDPT_TX],
Line 957  kue_open_pipes(struct kue_softc *sc)
Line 961  kue_open_pipes(struct kue_softc *sc)
         if (err) {          if (err) {
                 printf("%s: open tx pipe failed: %s\n",                  printf("%s: open tx pipe failed: %s\n",
                     device_xname(sc->kue_dev), usbd_errstr(err));                      device_xname(sc->kue_dev), usbd_errstr(err));
                 return (EIO);                  return EIO;
         }          }
   
         /* Start up the receive pipe. */          return 0;
         for (i = 0; i < KUE_RX_LIST_CNT; i++) {  
                 c = &sc->kue_cdata.kue_rx_chain[i];  
                 usbd_setup_xfer(c->kue_xfer, sc->kue_ep[KUE_ENDPT_RX],  
                     c, c->kue_buf, KUE_BUFSZ,  
                     USBD_SHORT_XFER_OK | USBD_NO_COPY, USBD_NO_TIMEOUT,  
                     kue_rxeof);  
                 DPRINTFN(5,("%s: %s: start read\n", device_xname(sc->kue_dev),  
                             __func__));  
                 usbd_transfer(c->kue_xfer);  
         }  
   
         return (0);  
 }  }
   
 static int  static int
Line 986  kue_ioctl(struct ifnet *ifp, u_long comm
Line 978  kue_ioctl(struct ifnet *ifp, u_long comm
         DPRINTFN(5,("%s: %s: enter\n", device_xname(sc->kue_dev),__func__));          DPRINTFN(5,("%s: %s: enter\n", device_xname(sc->kue_dev),__func__));
   
         if (sc->kue_dying)          if (sc->kue_dying)
                 return (EIO);                  return EIO;
   
         s = splnet();          s = splnet();
   
Line 1052  kue_ioctl(struct ifnet *ifp, u_long comm
Line 1044  kue_ioctl(struct ifnet *ifp, u_long comm
   
         splx(s);          splx(s);
   
         return (error);          return error;
 }  }
   
 static void  static void
Line 1104  kue_stop(struct kue_softc *sc)
Line 1096  kue_stop(struct kue_softc *sc)
                         printf("%s: abort rx pipe failed: %s\n",                          printf("%s: abort rx pipe failed: %s\n",
                             device_xname(sc->kue_dev), usbd_errstr(err));                              device_xname(sc->kue_dev), usbd_errstr(err));
                 }                  }
                 err = usbd_close_pipe(sc->kue_ep[KUE_ENDPT_RX]);  
                 if (err) {  
                         printf("%s: close rx pipe failed: %s\n",  
                             device_xname(sc->kue_dev), usbd_errstr(err));  
                 }  
                 sc->kue_ep[KUE_ENDPT_RX] = NULL;  
         }          }
   
         if (sc->kue_ep[KUE_ENDPT_TX] != NULL) {          if (sc->kue_ep[KUE_ENDPT_TX] != NULL) {
Line 1118  kue_stop(struct kue_softc *sc)
Line 1104  kue_stop(struct kue_softc *sc)
                         printf("%s: abort tx pipe failed: %s\n",                          printf("%s: abort tx pipe failed: %s\n",
                             device_xname(sc->kue_dev), usbd_errstr(err));                              device_xname(sc->kue_dev), usbd_errstr(err));
                 }                  }
                 err = usbd_close_pipe(sc->kue_ep[KUE_ENDPT_TX]);  
                 if (err) {  
                         printf("%s: close tx pipe failed: %s\n",  
                             device_xname(sc->kue_dev), usbd_errstr(err));  
                 }  
                 sc->kue_ep[KUE_ENDPT_TX] = NULL;  
         }          }
   
         if (sc->kue_ep[KUE_ENDPT_INTR] != NULL) {          if (sc->kue_ep[KUE_ENDPT_INTR] != NULL) {
Line 1132  kue_stop(struct kue_softc *sc)
Line 1112  kue_stop(struct kue_softc *sc)
                         printf("%s: abort intr pipe failed: %s\n",                          printf("%s: abort intr pipe failed: %s\n",
                             device_xname(sc->kue_dev), usbd_errstr(err));                              device_xname(sc->kue_dev), usbd_errstr(err));
                 }                  }
                 err = usbd_close_pipe(sc->kue_ep[KUE_ENDPT_INTR]);  
                 if (err) {  
                         printf("%s: close intr pipe failed: %s\n",  
                             device_xname(sc->kue_dev), usbd_errstr(err));  
                 }  
                 sc->kue_ep[KUE_ENDPT_INTR] = NULL;  
         }          }
   
         /* Free RX resources. */          /* Free RX resources. */
         for (i = 0; i < KUE_RX_LIST_CNT; i++) {          for (i = 0; i < KUE_RX_LIST_CNT; i++) {
                 if (sc->kue_cdata.kue_rx_chain[i].kue_xfer != NULL) {                  if (sc->kue_cdata.kue_rx_chain[i].kue_xfer != NULL) {
                         usbd_free_xfer(sc->kue_cdata.kue_rx_chain[i].kue_xfer);                          usbd_destroy_xfer(sc->kue_cdata.kue_rx_chain[i].kue_xfer);
                         sc->kue_cdata.kue_rx_chain[i].kue_xfer = NULL;                          sc->kue_cdata.kue_rx_chain[i].kue_xfer = NULL;
                 }                  }
         }          }
Line 1151  kue_stop(struct kue_softc *sc)
Line 1125  kue_stop(struct kue_softc *sc)
         /* Free TX resources. */          /* Free TX resources. */
         for (i = 0; i < KUE_TX_LIST_CNT; i++) {          for (i = 0; i < KUE_TX_LIST_CNT; i++) {
                 if (sc->kue_cdata.kue_tx_chain[i].kue_xfer != NULL) {                  if (sc->kue_cdata.kue_tx_chain[i].kue_xfer != NULL) {
                         usbd_free_xfer(sc->kue_cdata.kue_tx_chain[i].kue_xfer);                          usbd_destroy_xfer(sc->kue_cdata.kue_tx_chain[i].kue_xfer);
                         sc->kue_cdata.kue_tx_chain[i].kue_xfer = NULL;                          sc->kue_cdata.kue_tx_chain[i].kue_xfer = NULL;
                 }                  }
         }          }
   
           /* Close pipes. */
           if (sc->kue_ep[KUE_ENDPT_RX] != NULL) {
                   err = usbd_close_pipe(sc->kue_ep[KUE_ENDPT_RX]);
                   if (err) {
                           printf("%s: close rx pipe failed: %s\n",
                               device_xname(sc->kue_dev), usbd_errstr(err));
                   }
                   sc->kue_ep[KUE_ENDPT_RX] = NULL;
           }
   
           if (sc->kue_ep[KUE_ENDPT_TX] != NULL) {
                   err = usbd_close_pipe(sc->kue_ep[KUE_ENDPT_TX]);
                   if (err) {
                           printf("%s: close tx pipe failed: %s\n",
                               device_xname(sc->kue_dev), usbd_errstr(err));
                   }
                   sc->kue_ep[KUE_ENDPT_TX] = NULL;
           }
   
           if (sc->kue_ep[KUE_ENDPT_INTR] != NULL) {
                   err = usbd_close_pipe(sc->kue_ep[KUE_ENDPT_INTR]);
                   if (err) {
                           printf("%s: close intr pipe failed: %s\n",
                               device_xname(sc->kue_dev), usbd_errstr(err));
                   }
                   sc->kue_ep[KUE_ENDPT_INTR] = NULL;
           }
   
         ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);          ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
 }  }
Legend:
Removed from v.1.81  
changed lines
  Added in v.1.81.4.8
CVSweb <webmaster@jp.NetBSD.org>