[BACK]Return to usbdi.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/usbdi.c between version 1.72.2.1 and 1.73

version 1.72.2.1, 2000/06/22 17:08:47 version 1.73, 2000/05/31 16:14:42
Line 76  extern int usbdebug;
Line 76  extern int usbdebug;
 #define DPRINTFN(n,x)  #define DPRINTFN(n,x)
 #endif  #endif
   
 Static usbd_status usbd_ar_pipe(usbd_pipe_handle pipe);  Static usbd_status usbd_ar_pipe  __P((usbd_pipe_handle pipe));
 Static void usbd_do_request_async_cb  Static void usbd_do_request_async_cb
 (usbd_xfer_handle, usbd_private_handle, usbd_status);      __P((usbd_xfer_handle, usbd_private_handle, usbd_status));
 Static void usbd_start_next(usbd_pipe_handle pipe);  Static void usbd_start_next __P((usbd_pipe_handle pipe));
 Static usbd_status usbd_open_pipe_ival  Static usbd_status usbd_open_pipe_ival
 (usbd_interface_handle, u_int8_t, u_int8_t, usbd_pipe_handle *, int);      __P((usbd_interface_handle, u_int8_t, u_int8_t, usbd_pipe_handle *, int));
   
 Static int usbd_nbuses = 0;  Static int usbd_nbuses = 0;
   
 void  void
 usbd_init(void)  usbd_init()
 {  {
         usbd_nbuses++;          usbd_nbuses++;
 }  }
   
 void  void
 usbd_finish(void)  usbd_finish()
 {  {
         --usbd_nbuses;          --usbd_nbuses;
 }  }
   
 static __inline int  Static __inline int usbd_xfer_isread __P((usbd_xfer_handle xfer));
 usbd_xfer_isread(usbd_xfer_handle xfer)  Static __inline int
   usbd_xfer_isread(xfer)
           usbd_xfer_handle xfer;
 {  {
         if (xfer->rqflags & URQ_REQUEST)          if (xfer->rqflags & URQ_REQUEST)
                 return (xfer->request.bmRequestType & UT_READ);                  return (xfer->request.bmRequestType & UT_READ);
Line 108  usbd_xfer_isread(usbd_xfer_handle xfer)
Line 110  usbd_xfer_isread(usbd_xfer_handle xfer)
 }  }
   
 #ifdef USB_DEBUG  #ifdef USB_DEBUG
 void usbd_dump_queue(usbd_pipe_handle pipe);  void usbd_dump_queue __P((usbd_pipe_handle));
   
 void  void
 usbd_dump_queue(usbd_pipe_handle pipe)  usbd_dump_queue(pipe)
           usbd_pipe_handle pipe;
 {  {
         usbd_xfer_handle xfer;          usbd_xfer_handle xfer;
   
Line 124  usbd_dump_queue(usbd_pipe_handle pipe)
Line 128  usbd_dump_queue(usbd_pipe_handle pipe)
 #endif  #endif
   
 usbd_status  usbd_status
 usbd_open_pipe(usbd_interface_handle iface, u_int8_t address,  usbd_open_pipe(iface, address, flags, pipe)
                u_int8_t flags, usbd_pipe_handle *pipe)          usbd_interface_handle iface;
           u_int8_t address;
           u_int8_t flags;
           usbd_pipe_handle *pipe;
 {  {
         return (usbd_open_pipe_ival(iface, address, flags, pipe,          return (usbd_open_pipe_ival(iface, address, flags, pipe,
                                     USBD_DEFAULT_INTERVAL));                                      USBD_DEFAULT_INTERVAL));
 }  }
   
 usbd_status  usbd_status
 usbd_open_pipe_ival(usbd_interface_handle iface, u_int8_t address,  usbd_open_pipe_ival(iface, address, flags, pipe, ival)
                     u_int8_t flags, usbd_pipe_handle *pipe, int ival)          usbd_interface_handle iface;
           u_int8_t address;
           u_int8_t flags;
           usbd_pipe_handle *pipe;
           int ival;
 {  {
         usbd_pipe_handle p;          usbd_pipe_handle p;
         struct usbd_endpoint *ep;          struct usbd_endpoint *ep;
Line 163  usbd_open_pipe_ival(usbd_interface_handl
Line 174  usbd_open_pipe_ival(usbd_interface_handl
 }  }
   
 usbd_status  usbd_status
 usbd_open_pipe_intr(usbd_interface_handle iface, u_int8_t address,  usbd_open_pipe_intr(iface, address, flags, pipe, priv, buffer, len, cb, ival)
                     u_int8_t flags, usbd_pipe_handle *pipe,          usbd_interface_handle iface;
                     usbd_private_handle priv, void *buffer, u_int32_t len,          u_int8_t address;
                     usbd_callback cb, int ival)          u_int8_t flags;
           usbd_pipe_handle *pipe;
           usbd_private_handle priv;
           void *buffer;
           u_int32_t len;
           usbd_callback cb;
           int ival;
 {  {
         usbd_status err;          usbd_status err;
         usbd_xfer_handle xfer;          usbd_xfer_handle xfer;
Line 204  usbd_open_pipe_intr(usbd_interface_handl
Line 221  usbd_open_pipe_intr(usbd_interface_handl
 }  }
   
 usbd_status  usbd_status
 usbd_close_pipe(usbd_pipe_handle pipe)  usbd_close_pipe(pipe)
           usbd_pipe_handle pipe;
 {  {
 #ifdef DIAGNOSTIC  #ifdef DIAGNOSTIC
         if (pipe == NULL) {          if (pipe == NULL) {
Line 233  usbd_close_pipe(usbd_pipe_handle pipe)
Line 251  usbd_close_pipe(usbd_pipe_handle pipe)
 }  }
   
 usbd_status  usbd_status
 usbd_transfer(usbd_xfer_handle xfer)  usbd_transfer(xfer)
           usbd_xfer_handle xfer;
 {  {
         usbd_pipe_handle pipe = xfer->pipe;          usbd_pipe_handle pipe = xfer->pipe;
         usb_dma_t *dmap = &xfer->dmabuf;          usb_dma_t *dmap = &xfer->dmabuf;
Line 320  usbd_transfer(usbd_xfer_handle xfer)
Line 339  usbd_transfer(usbd_xfer_handle xfer)
   
 /* Like usbd_transfer(), but waits for completion. */  /* Like usbd_transfer(), but waits for completion. */
 usbd_status  usbd_status
 usbd_sync_transfer(usbd_xfer_handle xfer)  usbd_sync_transfer(xfer)
           usbd_xfer_handle xfer;
 {  {
         xfer->flags |= USBD_SYNCHRONOUS;          xfer->flags |= USBD_SYNCHRONOUS;
         return (usbd_transfer(xfer));          return (usbd_transfer(xfer));
 }  }
   
 void *  void *
 usbd_alloc_buffer(usbd_xfer_handle xfer, u_int32_t size)  usbd_alloc_buffer(xfer, size)
           usbd_xfer_handle xfer;
           u_int32_t size;
 {  {
         struct usbd_bus *bus = xfer->device->bus;          struct usbd_bus *bus = xfer->device->bus;
         usbd_status err;          usbd_status err;
Line 340  usbd_alloc_buffer(usbd_xfer_handle xfer,
Line 362  usbd_alloc_buffer(usbd_xfer_handle xfer,
 }  }
   
 void  void
 usbd_free_buffer(usbd_xfer_handle xfer)  usbd_free_buffer(xfer)
           usbd_xfer_handle xfer;
 {  {
 #ifdef DIAGNOSTIC  #ifdef DIAGNOSTIC
         if (!(xfer->rqflags & (URQ_DEV_DMABUF | URQ_AUTO_DMABUF))) {          if (!(xfer->rqflags & (URQ_DEV_DMABUF | URQ_AUTO_DMABUF))) {
Line 353  usbd_free_buffer(usbd_xfer_handle xfer)
Line 376  usbd_free_buffer(usbd_xfer_handle xfer)
 }  }
   
 void *  void *
 usbd_get_buffer(usbd_xfer_handle xfer)  usbd_get_buffer(xfer)
           usbd_xfer_handle xfer;
 {  {
         if (!(xfer->rqflags & URQ_DEV_DMABUF))          if (!(xfer->rqflags & URQ_DEV_DMABUF))
                 return (0);                  return (0);
Line 361  usbd_get_buffer(usbd_xfer_handle xfer)
Line 385  usbd_get_buffer(usbd_xfer_handle xfer)
 }  }
   
 usbd_xfer_handle  usbd_xfer_handle
 usbd_alloc_xfer(usbd_device_handle dev)  usbd_alloc_xfer(dev)
           usbd_device_handle dev;
 {  {
         usbd_xfer_handle xfer;          usbd_xfer_handle xfer;
   
Line 375  usbd_alloc_xfer(usbd_device_handle dev)
Line 400  usbd_alloc_xfer(usbd_device_handle dev)
 }  }
   
 usbd_status  usbd_status
 usbd_free_xfer(usbd_xfer_handle xfer)  usbd_free_xfer(xfer)
           usbd_xfer_handle xfer;
 {  {
         DPRINTFN(5,("usbd_free_xfer: %p\n", xfer));          DPRINTFN(5,("usbd_free_xfer: %p\n", xfer));
         if (xfer->rqflags & (URQ_DEV_DMABUF | URQ_AUTO_DMABUF))          if (xfer->rqflags & (URQ_DEV_DMABUF | URQ_AUTO_DMABUF))
Line 391  usbd_free_xfer(usbd_xfer_handle xfer)
Line 417  usbd_free_xfer(usbd_xfer_handle xfer)
 }  }
   
 void  void
 usbd_setup_xfer(usbd_xfer_handle xfer, usbd_pipe_handle pipe,  usbd_setup_xfer(xfer, pipe, priv, buffer, length, flags, timeout, callback)
                 usbd_private_handle priv, void *buffer, u_int32_t length,          usbd_xfer_handle xfer;
                 u_int16_t flags, u_int32_t timeout,          usbd_pipe_handle pipe;
                 usbd_callback callback)          usbd_private_handle priv;
           void *buffer;
           u_int32_t length;
           u_int16_t flags;
           u_int32_t timeout;
           void (*callback) __P((usbd_xfer_handle,
                                 usbd_private_handle,
                                 usbd_status));
 {  {
         xfer->pipe = pipe;          xfer->pipe = pipe;
         xfer->priv = priv;          xfer->priv = priv;
Line 410  usbd_setup_xfer(usbd_xfer_handle xfer, u
Line 443  usbd_setup_xfer(usbd_xfer_handle xfer, u
 }  }
   
 void  void
 usbd_setup_default_xfer(usbd_xfer_handle xfer, usbd_device_handle dev,  usbd_setup_default_xfer(xfer, dev, priv, timeout, req, buffer,
                         usbd_private_handle priv, u_int32_t timeout,                             length, flags, callback)
                         usb_device_request_t *req, void *buffer,          usbd_xfer_handle xfer;
                         u_int32_t length, u_int16_t flags,          usbd_device_handle dev;
                         usbd_callback callback)          usbd_private_handle priv;
           u_int32_t timeout;
           usb_device_request_t *req;
           void *buffer;
           u_int32_t length;
           u_int16_t flags;
           void (*callback) __P((usbd_xfer_handle,
                                 usbd_private_handle,
                                 usbd_status));
 {  {
         xfer->pipe = dev->default_pipe;          xfer->pipe = dev->default_pipe;
         xfer->priv = priv;          xfer->priv = priv;
Line 431  usbd_setup_default_xfer(usbd_xfer_handle
Line 472  usbd_setup_default_xfer(usbd_xfer_handle
 }  }
   
 void  void
 usbd_setup_isoc_xfer(usbd_xfer_handle xfer, usbd_pipe_handle pipe,  usbd_setup_isoc_xfer(xfer, pipe, priv, frlengths, nframes, flags, callback)
                      usbd_private_handle priv, u_int16_t *frlengths,          usbd_xfer_handle xfer;
                      u_int32_t nframes, u_int16_t flags, usbd_callback callback)          usbd_pipe_handle pipe;
           usbd_private_handle priv;
           u_int16_t *frlengths;
           u_int32_t nframes;
           u_int16_t flags;
           usbd_callback callback;
 {  {
         xfer->pipe = pipe;          xfer->pipe = pipe;
         xfer->priv = priv;          xfer->priv = priv;
Line 450  usbd_setup_isoc_xfer(usbd_xfer_handle xf
Line 496  usbd_setup_isoc_xfer(usbd_xfer_handle xf
 }  }
   
 void  void
 usbd_get_xfer_status(usbd_xfer_handle xfer, usbd_private_handle *priv,  usbd_get_xfer_status(xfer, priv, buffer, count, status)
                      void **buffer, u_int32_t *count, usbd_status *status)          usbd_xfer_handle xfer;
           usbd_private_handle *priv;
           void **buffer;
           u_int32_t *count;
           usbd_status *status;
 {  {
         if (priv != NULL)          if (priv != NULL)
                 *priv = xfer->priv;                  *priv = xfer->priv;
Line 464  usbd_get_xfer_status(usbd_xfer_handle xf
Line 514  usbd_get_xfer_status(usbd_xfer_handle xf
 }  }
   
 usb_config_descriptor_t *  usb_config_descriptor_t *
 usbd_get_config_descriptor(usbd_device_handle dev)  usbd_get_config_descriptor(dev)
           usbd_device_handle dev;
 {  {
 #ifdef DIAGNOSTIC  #ifdef DIAGNOSTIC
         if (dev == NULL) {          if (dev == NULL) {
Line 476  usbd_get_config_descriptor(usbd_device_h
Line 527  usbd_get_config_descriptor(usbd_device_h
 }  }
   
 usb_interface_descriptor_t *  usb_interface_descriptor_t *
 usbd_get_interface_descriptor(usbd_interface_handle iface)  usbd_get_interface_descriptor(iface)
           usbd_interface_handle iface;
 {  {
 #ifdef DIAGNOSTIC  #ifdef DIAGNOSTIC
         if (iface == NULL) {          if (iface == NULL) {
Line 488  usbd_get_interface_descriptor(usbd_inter
Line 540  usbd_get_interface_descriptor(usbd_inter
 }  }
   
 usb_device_descriptor_t *  usb_device_descriptor_t *
 usbd_get_device_descriptor(usbd_device_handle dev)  usbd_get_device_descriptor(dev)
           usbd_device_handle dev;
 {  {
         return (&dev->ddesc);          return (&dev->ddesc);
 }  }
   
 usb_endpoint_descriptor_t *  usb_endpoint_descriptor_t *
 usbd_interface2endpoint_descriptor(usbd_interface_handle iface, u_int8_t index)  usbd_interface2endpoint_descriptor(iface, index)
           usbd_interface_handle iface;
           u_int8_t index;
 {  {
         if (index >= iface->idesc->bNumEndpoints)          if (index >= iface->idesc->bNumEndpoints)
                 return (0);                  return (0);
Line 502  usbd_interface2endpoint_descriptor(usbd_
Line 557  usbd_interface2endpoint_descriptor(usbd_
 }  }
   
 usbd_status  usbd_status
 usbd_abort_pipe(usbd_pipe_handle pipe)  usbd_abort_pipe(pipe)
           usbd_pipe_handle pipe;
 {  {
         usbd_status err;          usbd_status err;
         int s;          int s;
Line 520  usbd_abort_pipe(usbd_pipe_handle pipe)
Line 576  usbd_abort_pipe(usbd_pipe_handle pipe)
 }  }
   
 usbd_status  usbd_status
 usbd_clear_endpoint_stall(usbd_pipe_handle pipe)  usbd_clear_endpoint_stall(pipe)
           usbd_pipe_handle pipe;
 {  {
         usbd_device_handle dev = pipe->device;          usbd_device_handle dev = pipe->device;
         usb_device_request_t req;          usb_device_request_t req;
Line 551  XXX should we do this?
Line 608  XXX should we do this?
 }  }
   
 usbd_status  usbd_status
 usbd_clear_endpoint_stall_async(usbd_pipe_handle pipe)  usbd_clear_endpoint_stall_async(pipe)
           usbd_pipe_handle pipe;
 {  {
         usbd_device_handle dev = pipe->device;          usbd_device_handle dev = pipe->device;
         usb_device_request_t req;          usb_device_request_t req;
Line 570  usbd_clear_endpoint_stall_async(usbd_pip
Line 628  usbd_clear_endpoint_stall_async(usbd_pip
   
 void usbd_clear_endpoint_toggle(usbd_pipe_handle pipe); /* XXXXX */  void usbd_clear_endpoint_toggle(usbd_pipe_handle pipe); /* XXXXX */
 void  void
 usbd_clear_endpoint_toggle(usbd_pipe_handle pipe)  usbd_clear_endpoint_toggle(pipe)
           usbd_pipe_handle pipe;
 {  {
         pipe->methods->cleartoggle(pipe);          pipe->methods->cleartoggle(pipe);
 }  }
   
 usbd_status  usbd_status
 usbd_endpoint_count(usbd_interface_handle iface, u_int8_t *count)  usbd_endpoint_count(iface, count)
           usbd_interface_handle iface;
           u_int8_t *count;
 {  {
 #ifdef DIAGNOSTIC  #ifdef DIAGNOSTIC
         if (iface == NULL || iface->idesc == NULL) {          if (iface == NULL || iface->idesc == NULL) {
Line 589  usbd_endpoint_count(usbd_interface_handl
Line 650  usbd_endpoint_count(usbd_interface_handl
 }  }
   
 usbd_status  usbd_status
 usbd_interface_count(usbd_device_handle dev, u_int8_t *count)  usbd_interface_count(dev, count)
           usbd_device_handle dev;
           u_int8_t *count;
 {  {
         if (dev->cdesc == NULL)          if (dev->cdesc == NULL)
                 return (USBD_NOT_CONFIGURED);                  return (USBD_NOT_CONFIGURED);
Line 598  usbd_interface_count(usbd_device_handle 
Line 661  usbd_interface_count(usbd_device_handle 
 }  }
   
 usbd_status  usbd_status
 usbd_interface2device_handle(usbd_interface_handle iface,  usbd_interface2device_handle(iface, dev)
                              usbd_device_handle *dev)          usbd_interface_handle iface;
           usbd_device_handle *dev;
 {  {
         *dev = iface->device;          *dev = iface->device;
         return (USBD_NORMAL_COMPLETION);          return (USBD_NORMAL_COMPLETION);
 }  }
   
 usbd_status  usbd_status
 usbd_device2interface_handle(usbd_device_handle dev,  usbd_device2interface_handle(dev, ifaceno, iface)
                              u_int8_t ifaceno, usbd_interface_handle *iface)          usbd_device_handle dev;
           u_int8_t ifaceno;
           usbd_interface_handle *iface;
 {  {
         if (dev->cdesc == NULL)          if (dev->cdesc == NULL)
                 return (USBD_NOT_CONFIGURED);                  return (USBD_NOT_CONFIGURED);
Line 618  usbd_device2interface_handle(usbd_device
Line 684  usbd_device2interface_handle(usbd_device
 }  }
   
 usbd_device_handle  usbd_device_handle
 usbd_pipe2device_handle(usbd_pipe_handle pipe)  usbd_pipe2device_handle(pipe)
           usbd_pipe_handle pipe;
 {  {
         return (pipe->device);          return (pipe->device);
 }  }
   
 /* XXXX use altno */  /* XXXX use altno */
 usbd_status  usbd_status
 usbd_set_interface(usbd_interface_handle iface, int altidx)  usbd_set_interface(iface, altidx)
           usbd_interface_handle iface;
           int altidx;
 {  {
         usb_device_request_t req;          usb_device_request_t req;
         usbd_status err;          usbd_status err;
Line 634  usbd_set_interface(usbd_interface_handle
Line 703  usbd_set_interface(usbd_interface_handle
         if (LIST_FIRST(&iface->pipes) != 0)          if (LIST_FIRST(&iface->pipes) != 0)
                 return (USBD_IN_USE);                  return (USBD_IN_USE);
   
         endpoints = iface->endpoints;  
         err = usbd_fill_iface_data(iface->device, iface->index, altidx);          err = usbd_fill_iface_data(iface->device, iface->index, altidx);
         if (err)          if (err)
                 return (err);                  return (err);
   
         /* new setting works, we can free old endpoints */          /* new setting work, we can free old endpoints */
         if (endpoints != NULL)          if (endpoints != NULL)
                 free(endpoints, M_USB);                  free(endpoints, M_USB);
   
Line 659  usbd_set_interface(usbd_interface_handle
Line 727  usbd_set_interface(usbd_interface_handle
 }  }
   
 int  int
 usbd_get_no_alts(usb_config_descriptor_t *cdesc, int ifaceno)  usbd_get_no_alts(cdesc, ifaceno)
           usb_config_descriptor_t *cdesc;
           int ifaceno;
 {  {
         char *p = (char *)cdesc;          char *p = (char *)cdesc;
         char *end = p + UGETW(cdesc->wTotalLength);          char *end = p + UGETW(cdesc->wTotalLength);
Line 677  usbd_get_no_alts(usb_config_descriptor_t
Line 747  usbd_get_no_alts(usb_config_descriptor_t
 }  }
   
 int  int
 usbd_get_interface_altindex(usbd_interface_handle iface)  usbd_get_interface_altindex(iface)
           usbd_interface_handle iface;
 {  {
         return (iface->altindex);          return (iface->altindex);
 }  }
   
 usbd_status  usbd_status
 usbd_get_interface(usbd_interface_handle iface, u_int8_t *aiface)  usbd_get_interface(iface, aiface)
           usbd_interface_handle iface;
           u_int8_t *aiface;
 {  {
         usb_device_request_t req;          usb_device_request_t req;
   
Line 699  usbd_get_interface(usbd_interface_handle
Line 772  usbd_get_interface(usbd_interface_handle
   
 /* Dequeue all pipe operations, called at splusb(). */  /* Dequeue all pipe operations, called at splusb(). */
 Static usbd_status  Static usbd_status
 usbd_ar_pipe(usbd_pipe_handle pipe)  usbd_ar_pipe(pipe)
           usbd_pipe_handle pipe;
 {  {
         usbd_xfer_handle xfer;          usbd_xfer_handle xfer;
   
Line 725  usbd_ar_pipe(usbd_pipe_handle pipe)
Line 799  usbd_ar_pipe(usbd_pipe_handle pipe)
   
 /* Called at splusb() */  /* Called at splusb() */
 void  void
 usb_transfer_complete(usbd_xfer_handle xfer)  usb_transfer_complete(xfer)
           usbd_xfer_handle xfer;
 {  {
         usbd_pipe_handle pipe = xfer->pipe;          usbd_pipe_handle pipe = xfer->pipe;
         usb_dma_t *dmap = &xfer->dmabuf;          usb_dma_t *dmap = &xfer->dmabuf;
Line 820  usb_transfer_complete(usbd_xfer_handle x
Line 895  usb_transfer_complete(usbd_xfer_handle x
 }  }
   
 usbd_status  usbd_status
 usb_insert_transfer(usbd_xfer_handle xfer)  usb_insert_transfer(xfer)
           usbd_xfer_handle xfer;
 {  {
         usbd_pipe_handle pipe = xfer->pipe;          usbd_pipe_handle pipe = xfer->pipe;
         usbd_status err;          usbd_status err;
Line 842  usb_insert_transfer(usbd_xfer_handle xfe
Line 918  usb_insert_transfer(usbd_xfer_handle xfe
   
 /* Called at splusb() */  /* Called at splusb() */
 void  void
 usbd_start_next(usbd_pipe_handle pipe)  usbd_start_next(pipe)
           usbd_pipe_handle pipe;
 {  {
         usbd_xfer_handle xfer;          usbd_xfer_handle xfer;
         usbd_status err;          usbd_status err;
Line 876  usbd_start_next(usbd_pipe_handle pipe)
Line 953  usbd_start_next(usbd_pipe_handle pipe)
 }  }
   
 usbd_status  usbd_status
 usbd_do_request(usbd_device_handle dev, usb_device_request_t *req, void *data)  usbd_do_request(dev, req, data)
           usbd_device_handle dev;
           usb_device_request_t *req;
           void *data;
 {  {
         return (usbd_do_request_flags(dev, req, data, 0, 0));          return (usbd_do_request_flags(dev, req, data, 0, 0));
 }  }
   
 usbd_status  usbd_status
 usbd_do_request_flags(usbd_device_handle dev, usb_device_request_t *req,  usbd_do_request_flags(dev, req, data, flags, actlen)
                       void *data, u_int16_t flags, int *actlen)          usbd_device_handle dev;
           usb_device_request_t *req;
           void *data;
           u_int16_t flags;
           int *actlen;
 {  {
         usbd_xfer_handle xfer;          usbd_xfer_handle xfer;
         usbd_status err;          usbd_status err;
Line 961  usbd_do_request_flags(usbd_device_handle
Line 1045  usbd_do_request_flags(usbd_device_handle
 }  }
   
 void  void
 usbd_do_request_async_cb(usbd_xfer_handle xfer, usbd_private_handle priv,  usbd_do_request_async_cb(xfer, priv, status)
                          usbd_status status)          usbd_xfer_handle xfer;
           usbd_private_handle priv;
           usbd_status status;
 {  {
 #if defined(USB_DEBUG) || defined(DIAGNOSTIC)  #if defined(USB_DEBUG) || defined(DIAGNOSTIC)
         if (xfer->actlen > xfer->length)          if (xfer->actlen > xfer->length)
Line 983  usbd_do_request_async_cb(usbd_xfer_handl
Line 1069  usbd_do_request_async_cb(usbd_xfer_handl
  * Can be used from interrupt context.   * Can be used from interrupt context.
  */   */
 usbd_status  usbd_status
 usbd_do_request_async(usbd_device_handle dev, usb_device_request_t *req,  usbd_do_request_async(dev, req, data)
                       void *data)          usbd_device_handle dev;
           usb_device_request_t *req;
           void *data;
 {  {
         usbd_xfer_handle xfer;          usbd_xfer_handle xfer;
         usbd_status err;          usbd_status err;
Line 1003  usbd_do_request_async(usbd_device_handle
Line 1091  usbd_do_request_async(usbd_device_handle
 }  }
   
 struct usbd_quirks *  struct usbd_quirks *
 usbd_get_quirks(usbd_device_handle dev)  usbd_get_quirks(dev)
           usbd_device_handle dev;
 {  {
         return (dev->quirks);          return (dev->quirks);
 }  }
Line 1014  usbd_get_quirks(usbd_device_handle dev)
Line 1103  usbd_get_quirks(usbd_device_handle dev)
  * Called from keyboard driver when in polling mode.   * Called from keyboard driver when in polling mode.
  */   */
 void  void
 usbd_dopoll(usbd_interface_handle iface)  usbd_dopoll(iface)
           usbd_interface_handle iface;
 {  {
         iface->device->bus->methods->do_poll(iface->device->bus);          iface->device->bus->methods->do_poll(iface->device->bus);
 }  }
   
 void  void
 usbd_set_polling(usbd_device_handle dev, int on)  usbd_set_polling(dev, on)
           usbd_device_handle dev;
           int on;
 {  {
         if (on)          if (on)
                 dev->bus->use_polling++;                  dev->bus->use_polling++;
Line 1030  usbd_set_polling(usbd_device_handle dev,
Line 1122  usbd_set_polling(usbd_device_handle dev,
   
   
 usb_endpoint_descriptor_t *  usb_endpoint_descriptor_t *
 usbd_get_endpoint_descriptor(usbd_interface_handle iface, u_int8_t address)  usbd_get_endpoint_descriptor(iface, address)
           usbd_interface_handle iface;
           u_int8_t address;
 {  {
         struct usbd_endpoint *ep;          struct usbd_endpoint *ep;
         int i;          int i;
Line 1050  usbd_get_endpoint_descriptor(usbd_interf
Line 1144  usbd_get_endpoint_descriptor(usbd_interf
  * this can generate a large number of messages.   * this can generate a large number of messages.
  */   */
 int  int
 usbd_ratecheck(struct timeval *last)  usbd_ratecheck(last)
           struct timeval *last;
 {  {
         static struct timeval errinterval = { 0, 250000 }; /* 0.25 s*/          static struct timeval errinterval = { 0, 250000 }; /* 0.25 s*/
   
Legend:
Removed from v.1.72.2.1  
changed lines
  Added in v.1.73
CVSweb <webmaster@jp.NetBSD.org>