Diff for /src/sys/bus/usb/usbdi_util.c between versions 1.4 and 1.5

version 1.4, 2003/08/07 21:16:47 version 1.5, 2003/12/30 01:01:44
Line 1 Line 1
/*        $NetBSD: usbdi_util.c,v 1.24 1999/11/17 23:00:50 augustss Exp $ *//*
/*        $FreeBSD: src/sys/dev/usb/usbdi_util.c,v 1.15.2.5 2002/11/06 14:03:37 joe Exp $  */ * $NetBSD: usbdi_util.c,v 1.24 1999/11/17 23:00:50 augustss Exp $
/*        $DragonFly$     */ * $NetBSD: usbdi_util.c,v 1.36 2001/11/13 06:24:57 lukem Exp $
  * $FreeBSD: src/sys/dev/usb/usbdi_util.c,v 1.31 2003/08/24 17:55:55 obrien Exp $
  * $DragonFly$
  */
   
 /*  /*
  * Copyright (c) 1998 The NetBSD Foundation, Inc.   * Copyright (c) 1998 The NetBSD Foundation, Inc.
Line 70  usbd_get_desc(usbd_device_handle dev, in Line 73  usbd_get_desc(usbd_device_handle dev, in
 {  {
         usb_device_request_t req;          usb_device_request_t req;
   
           DPRINTFN(3,("usbd_get_desc: type=%d, index=%d, len=%d\n",
                       type, index, len));
   
         req.bmRequestType = UT_READ_DEVICE;          req.bmRequestType = UT_READ_DEVICE;
         req.bRequest = UR_GET_DESCRIPTOR;          req.bRequest = UR_GET_DESCRIPTOR;
         USETW2(req.wValue, type, index);          USETW2(req.wValue, type, index);
Line 79  usbd_get_desc(usbd_device_handle dev, in Line 85  usbd_get_desc(usbd_device_handle dev, in
 }  }
   
 usbd_status  usbd_status
usbd_get_config_desc(usbd_device_handle dev, int conf,usbd_get_config_desc(usbd_device_handle dev, int confidx,
                      usb_config_descriptor_t *d)                       usb_config_descriptor_t *d)
 {  {
         usbd_status err;          usbd_status err;
   
        DPRINTFN(3,("usbd_get_config_desc: conf=%d\n", conf));        DPRINTFN(3,("usbd_get_config_desc: confidx=%d\n", confidx));
        err = usbd_get_desc(dev, UDESC_CONFIG, conf        err = usbd_get_desc(dev, UDESC_CONFIG, confidx,
                          USB_CONFIG_DESCRIPTOR_SIZE, d);                            USB_CONFIG_DESCRIPTOR_SIZE, d);
         if (err)          if (err)
                 return (err);                  return (err);
         if (d->bDescriptorType != UDESC_CONFIG) {          if (d->bDescriptorType != UDESC_CONFIG) {
                DPRINTFN(-1,("usbd_get_config_desc: conf %d, bad desc %d\n",                DPRINTFN(-1,("usbd_get_config_desc: confidx=%d, bad desc "
                             conf, d->bDescriptorType));                             "len=%d type=%d\n",
                              confidx, d->bLength, d->bDescriptorType));
                 return (USBD_INVAL);                  return (USBD_INVAL);
         }          }
         return (USBD_NORMAL_COMPLETION);          return (USBD_NORMAL_COMPLETION);
Line 108  usbd_status Line 115  usbd_status
 usbd_get_device_desc(usbd_device_handle dev, usb_device_descriptor_t *d)  usbd_get_device_desc(usbd_device_handle dev, usb_device_descriptor_t *d)
 {  {
         DPRINTFN(3,("usbd_get_device_desc:\n"));          DPRINTFN(3,("usbd_get_device_desc:\n"));
        return (usbd_get_desc(dev, UDESC_DEVICE,         return (usbd_get_desc(dev, UDESC_DEVICE,
                              0, USB_DEVICE_DESCRIPTOR_SIZE, d));                               0, USB_DEVICE_DESCRIPTOR_SIZE, d));
 }  }
   
Line 123  usbd_get_device_status(usbd_device_handl Line 130  usbd_get_device_status(usbd_device_handl
         USETW(req.wIndex, 0);          USETW(req.wIndex, 0);
         USETW(req.wLength, sizeof(usb_status_t));          USETW(req.wLength, sizeof(usb_status_t));
         return (usbd_do_request(dev, &req, st));          return (usbd_do_request(dev, &req, st));
}       }
   
 usbd_status  usbd_status
 usbd_get_hub_status(usbd_device_handle dev, usb_hub_status_t *st)  usbd_get_hub_status(usbd_device_handle dev, usb_hub_status_t *st)
Line 136  usbd_get_hub_status(usbd_device_handle d Line 143  usbd_get_hub_status(usbd_device_handle d
         USETW(req.wIndex, 0);          USETW(req.wIndex, 0);
         USETW(req.wLength, sizeof(usb_hub_status_t));          USETW(req.wLength, sizeof(usb_hub_status_t));
         return (usbd_do_request(dev, &req, st));          return (usbd_do_request(dev, &req, st));
}       }
   
 usbd_status  usbd_status
 usbd_set_address(usbd_device_handle dev, int addr)  usbd_set_address(usbd_device_handle dev, int addr)
Line 223  usbd_set_protocol(usbd_interface_handle Line 230  usbd_set_protocol(usbd_interface_handle
         usb_interface_descriptor_t *id = usbd_get_interface_descriptor(iface);          usb_interface_descriptor_t *id = usbd_get_interface_descriptor(iface);
         usbd_device_handle dev;          usbd_device_handle dev;
         usb_device_request_t req;          usb_device_request_t req;
         usbd_status err;  
   
         DPRINTFN(4, ("usbd_set_protocol: iface=%p, report=%d, endpt=%d\n",          DPRINTFN(4, ("usbd_set_protocol: iface=%p, report=%d, endpt=%d\n",
                      iface, report, id->bInterfaceNumber));                       iface, report, id->bInterfaceNumber));
         if (id == NULL)          if (id == NULL)
                 return (USBD_IOERROR);                  return (USBD_IOERROR);
        err = usbd_interface2device_handle(iface, &dev);        usbd_interface2device_handle(iface, &dev);
        if (err) 
                return (err); 
         req.bmRequestType = UT_WRITE_CLASS_INTERFACE;          req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
         req.bRequest = UR_SET_PROTOCOL;          req.bRequest = UR_SET_PROTOCOL;
         USETW(req.wValue, report);          USETW(req.wValue, report);
Line 247  usbd_set_report(usbd_interface_handle if Line 251  usbd_set_report(usbd_interface_handle if
         usb_interface_descriptor_t *ifd = usbd_get_interface_descriptor(iface);          usb_interface_descriptor_t *ifd = usbd_get_interface_descriptor(iface);
         usbd_device_handle dev;          usbd_device_handle dev;
         usb_device_request_t req;          usb_device_request_t req;
         usbd_status err;  
   
         DPRINTFN(4, ("usbd_set_report: len=%d\n", len));          DPRINTFN(4, ("usbd_set_report: len=%d\n", len));
         if (ifd == NULL)          if (ifd == NULL)
                 return (USBD_IOERROR);                  return (USBD_IOERROR);
        err = usbd_interface2device_handle(iface, &dev);        usbd_interface2device_handle(iface, &dev);
        if (err) 
                return (err); 
         req.bmRequestType = UT_WRITE_CLASS_INTERFACE;          req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
         req.bRequest = UR_SET_REPORT;          req.bRequest = UR_SET_REPORT;
         USETW2(req.wValue, type, id);          USETW2(req.wValue, type, id);
Line 270  usbd_set_report_async(usbd_interface_han Line 271  usbd_set_report_async(usbd_interface_han
         usb_interface_descriptor_t *ifd = usbd_get_interface_descriptor(iface);          usb_interface_descriptor_t *ifd = usbd_get_interface_descriptor(iface);
         usbd_device_handle dev;          usbd_device_handle dev;
         usb_device_request_t req;          usb_device_request_t req;
         usbd_status err;  
   
         DPRINTFN(4, ("usbd_set_report_async: len=%d\n", len));          DPRINTFN(4, ("usbd_set_report_async: len=%d\n", len));
         if (ifd == NULL)          if (ifd == NULL)
                 return (USBD_IOERROR);                  return (USBD_IOERROR);
        err = usbd_interface2device_handle(iface, &dev);        usbd_interface2device_handle(iface, &dev);
        if (err) 
                return (err); 
         req.bmRequestType = UT_WRITE_CLASS_INTERFACE;          req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
         req.bRequest = UR_SET_REPORT;          req.bRequest = UR_SET_REPORT;
         USETW2(req.wValue, type, id);          USETW2(req.wValue, type, id);
Line 293  usbd_get_report(usbd_interface_handle if Line 291  usbd_get_report(usbd_interface_handle if
         usb_interface_descriptor_t *ifd = usbd_get_interface_descriptor(iface);          usb_interface_descriptor_t *ifd = usbd_get_interface_descriptor(iface);
         usbd_device_handle dev;          usbd_device_handle dev;
         usb_device_request_t req;          usb_device_request_t req;
         usbd_status err;  
   
         DPRINTFN(4, ("usbd_set_report: len=%d\n", len));          DPRINTFN(4, ("usbd_set_report: len=%d\n", len));
        if (id == NULL)        if (id == 0)
                 return (USBD_IOERROR);                  return (USBD_IOERROR);
        err = usbd_interface2device_handle(iface, &dev);        usbd_interface2device_handle(iface, &dev);
        if (err) 
                return (err); 
         req.bmRequestType = UT_READ_CLASS_INTERFACE;          req.bmRequestType = UT_READ_CLASS_INTERFACE;
         req.bRequest = UR_GET_REPORT;          req.bRequest = UR_GET_REPORT;
         USETW2(req.wValue, type, id);          USETW2(req.wValue, type, id);
Line 315  usbd_set_idle(usbd_interface_handle ifac Line 310  usbd_set_idle(usbd_interface_handle ifac
         usb_interface_descriptor_t *ifd = usbd_get_interface_descriptor(iface);          usb_interface_descriptor_t *ifd = usbd_get_interface_descriptor(iface);
         usbd_device_handle dev;          usbd_device_handle dev;
         usb_device_request_t req;          usb_device_request_t req;
         usbd_status err;  
   
         DPRINTFN(4, ("usbd_set_idle: %d %d\n", duration, id));          DPRINTFN(4, ("usbd_set_idle: %d %d\n", duration, id));
         if (ifd == NULL)          if (ifd == NULL)
                 return (USBD_IOERROR);                  return (USBD_IOERROR);
        err = usbd_interface2device_handle(iface, &dev);        usbd_interface2device_handle(iface, &dev);
        if (err) 
                return (err); 
         req.bmRequestType = UT_WRITE_CLASS_INTERFACE;          req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
         req.bRequest = UR_SET_IDLE;          req.bRequest = UR_SET_IDLE;
         USETW2(req.wValue, duration, id);          USETW2(req.wValue, duration, id);
Line 332  usbd_set_idle(usbd_interface_handle ifac Line 324  usbd_set_idle(usbd_interface_handle ifac
 }  }
   
 usbd_status  usbd_status
usbd_get_report_descriptor(usbd_device_handle dev, int ifcno, int repid,usbd_get_report_descriptor(usbd_device_handle dev, int ifcno,
                            int size, void *d)                             int size, void *d)
 {  {
         usb_device_request_t req;          usb_device_request_t req;
   
         req.bmRequestType = UT_READ_INTERFACE;          req.bmRequestType = UT_READ_INTERFACE;
         req.bRequest = UR_GET_DESCRIPTOR;          req.bRequest = UR_GET_DESCRIPTOR;
        USETW2(req.wValue, UDESC_REPORT, repid);        USETW2(req.wValue, UDESC_REPORT, 0); /* report id should be 0 */
         USETW(req.wIndex, ifcno);          USETW(req.wIndex, ifcno);
         USETW(req.wLength, size);          USETW(req.wLength, size);
         return (usbd_do_request(dev, &req, d));          return (usbd_do_request(dev, &req, d));
Line 353  usbd_get_hid_descriptor(usbd_interface_h Line 345  usbd_get_hid_descriptor(usbd_interface_h
         usb_config_descriptor_t *cdesc;          usb_config_descriptor_t *cdesc;
         usb_hid_descriptor_t *hd;          usb_hid_descriptor_t *hd;
         char *p, *end;          char *p, *end;
         usbd_status err;  
   
         if (idesc == NULL)          if (idesc == NULL)
                 return (0);                  return (0);
        err = usbd_interface2device_handle(ifc, &dev);        usbd_interface2device_handle(ifc, &dev);
        if (err) 
                return (0); 
         cdesc = usbd_get_config_descriptor(dev);          cdesc = usbd_get_config_descriptor(dev);
   
         p = (char *)idesc + idesc->bLength;          p = (char *)idesc + idesc->bLength;
Line 376  usbd_get_hid_descriptor(usbd_interface_h Line 365  usbd_get_hid_descriptor(usbd_interface_h
 }  }
   
 usbd_status  usbd_status
usbd_alloc_report_desc(usbd_interface_handle ifc, void **descp, int *sizep,usbd_read_report_desc(usbd_interface_handle ifc, void **descp, int *sizep,
                       struct malloc_type *mem)                      usb_malloc_type mem)
 {  {
         usb_interface_descriptor_t *id;          usb_interface_descriptor_t *id;
         usb_hid_descriptor_t *hid;          usb_hid_descriptor_t *hid;
         usbd_device_handle dev;          usbd_device_handle dev;
         usbd_status err;          usbd_status err;
   
        err = usbd_interface2device_handle(ifc, &dev);        usbd_interface2device_handle(ifc, &dev);
        if (err) 
                return (err); 
         id = usbd_get_interface_descriptor(ifc);          id = usbd_get_interface_descriptor(ifc);
         if (id == NULL)          if (id == NULL)
                 return (USBD_INVAL);                  return (USBD_INVAL);
Line 397  usbd_alloc_report_desc(usbd_interface_ha Line 384  usbd_alloc_report_desc(usbd_interface_ha
         *descp = malloc(*sizep, mem, M_NOWAIT);          *descp = malloc(*sizep, mem, M_NOWAIT);
         if (*descp == NULL)          if (*descp == NULL)
                 return (USBD_NOMEM);                  return (USBD_NOMEM);
        /* XXX should not use 0 Report ID */        err = usbd_get_report_descriptor(dev, id->bInterfaceNumber,
        err = usbd_get_report_descriptor(dev, id->bInterfaceNumber, 0,                                          *sizep, *descp);
                                       *sizep, *descp); 
         if (err) {          if (err) {
                 free(*descp, mem);                  free(*descp, mem);
                 *descp = NULL;                  *descp = NULL;
Line 408  usbd_alloc_report_desc(usbd_interface_ha Line 394  usbd_alloc_report_desc(usbd_interface_ha
         return (USBD_NORMAL_COMPLETION);          return (USBD_NORMAL_COMPLETION);
 }  }
   
usbd_status usbd_status
 usbd_get_config(usbd_device_handle dev, u_int8_t *conf)  usbd_get_config(usbd_device_handle dev, u_int8_t *conf)
 {  {
         usb_device_request_t req;          usb_device_request_t req;
Line 421  usbd_get_config(usbd_device_handle dev, Line 407  usbd_get_config(usbd_device_handle dev,
         return (usbd_do_request(dev, &req, conf));          return (usbd_do_request(dev, &req, conf));
 }  }
   
Static voidStatic void usbd_bulk_transfer_cb(usbd_xfer_handle xfer,
usbd_bulk_transfer_cb(usbd_xfer_handle xfer,                                   usbd_private_handle priv, usbd_status status);
                      usbd_private_handle priv, usbd_status status); 
 Static void  Static void
 usbd_bulk_transfer_cb(usbd_xfer_handle xfer, usbd_private_handle priv,  usbd_bulk_transfer_cb(usbd_xfer_handle xfer, usbd_private_handle priv,
                       usbd_status status)                        usbd_status status)
Line 455  usbd_bulk_transfer(usbd_xfer_handle xfer Line 440  usbd_bulk_transfer(usbd_xfer_handle xfer
                 usbd_abort_pipe(pipe);                  usbd_abort_pipe(pipe);
                 return (USBD_INTERRUPTED);                  return (USBD_INTERRUPTED);
         }          }
        usbd_get_xfer_status(xfer, 0, 0, size, &err);        usbd_get_xfer_status(xfer, NULL, NULL, size, &err);
         DPRINTFN(1,("usbd_bulk_transfer: transferred %d\n", *size));          DPRINTFN(1,("usbd_bulk_transfer: transferred %d\n", *size));
         if (err) {          if (err) {
                 DPRINTF(("usbd_bulk_transfer: error=%d\n", err));                  DPRINTF(("usbd_bulk_transfer: error=%d\n", err));
Line 464  usbd_bulk_transfer(usbd_xfer_handle xfer Line 449  usbd_bulk_transfer(usbd_xfer_handle xfer
         return (err);          return (err);
 }  }
   
   Static void usbd_intr_transfer_cb(usbd_xfer_handle xfer,
                                     usbd_private_handle priv, usbd_status status);
   Static void
   usbd_intr_transfer_cb(usbd_xfer_handle xfer, usbd_private_handle priv,
                         usbd_status status)
   {
           wakeup(xfer);
   }
   
   usbd_status
   usbd_intr_transfer(usbd_xfer_handle xfer, usbd_pipe_handle pipe,
                      u_int16_t flags, u_int32_t timeout, void *buf,
                      u_int32_t *size, char *lbl)
   {
           usbd_status err;
           int s, error;
   
           usbd_setup_xfer(xfer, pipe, 0, buf, *size,
                           flags, timeout, usbd_intr_transfer_cb);
           DPRINTFN(1, ("usbd_intr_transfer: start transfer %d bytes\n", *size));
           s = splusb();           /* don't want callback until tsleep() */
           err = usbd_transfer(xfer);
           if (err != USBD_IN_PROGRESS) {
                   splx(s);
                   return (err);
           }
           error = tsleep(xfer, PCATCH, lbl, 0);
           splx(s);
           if (error) {
                   DPRINTF(("usbd_intr_transfer: tsleep=%d\n", error));
                   usbd_abort_pipe(pipe);
                   return (USBD_INTERRUPTED);
           }
           usbd_get_xfer_status(xfer, NULL, NULL, size, &err);
           DPRINTFN(1,("usbd_intr_transfer: transferred %d\n", *size));
           if (err) {
                   DPRINTF(("usbd_intr_transfer: error=%d\n", err));
                   usbd_clear_endpoint_stall(pipe);
           }
           return (err);
   }
   
 void  void
 usb_detach_wait(device_ptr_t dv)  usb_detach_wait(device_ptr_t dv)
 {  {
Line 472  usb_detach_wait(device_ptr_t dv) Line 499  usb_detach_wait(device_ptr_t dv)
                 printf("usb_detach_wait: %s didn't detach\n",                  printf("usb_detach_wait: %s didn't detach\n",
                         USBDEVPTRNAME(dv));                          USBDEVPTRNAME(dv));
         DPRINTF(("usb_detach_wait: %s done\n", USBDEVPTRNAME(dv)));          DPRINTF(("usb_detach_wait: %s done\n", USBDEVPTRNAME(dv)));
}       }
   
 void  void
 usb_detach_wakeup(device_ptr_t dv)  usb_detach_wakeup(device_ptr_t dv)
 {  {
         DPRINTF(("usb_detach_wakeup: for %s\n", USBDEVPTRNAME(dv)));          DPRINTF(("usb_detach_wakeup: for %s\n", USBDEVPTRNAME(dv)));
         wakeup(dv);          wakeup(dv);
}       }

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