1 /* $OpenBSD: usbdi_util.c,v 1.45 2021/01/25 14:05:57 mglocker Exp $ */ 2 /* $NetBSD: usbdi_util.c,v 1.40 2002/07/11 21:14:36 augustss Exp $ */ 3 /* $FreeBSD: src/sys/dev/usb/usbdi_util.c,v 1.14 1999/11/17 22:33:50 n_hibma Exp $ */ 4 5 /* 6 * Copyright (c) 1998 The NetBSD Foundation, Inc. 7 * All rights reserved. 8 * 9 * This code is derived from software contributed to The NetBSD Foundation 10 * by Lennart Augustsson (lennart@augustsson.net) at 11 * Carlstedt Research & Technology. 12 * 13 * Redistribution and use in source and binary forms, with or without 14 * modification, are permitted provided that the following conditions 15 * are met: 16 * 1. Redistributions of source code must retain the above copyright 17 * notice, this list of conditions and the following disclaimer. 18 * 2. Redistributions in binary form must reproduce the above copyright 19 * notice, this list of conditions and the following disclaimer in the 20 * documentation and/or other materials provided with the distribution. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 23 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 24 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 25 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 26 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 27 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 28 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 29 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 30 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 31 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 32 * POSSIBILITY OF SUCH DAMAGE. 33 */ 34 35 #include <sys/param.h> 36 #include <sys/systm.h> 37 #include <sys/kernel.h> 38 #include <sys/device.h> 39 40 #include <machine/bus.h> 41 42 #include <dev/usb/usb.h> 43 #include <dev/usb/usbhid.h> 44 45 #include <dev/usb/usbdi.h> 46 #include <dev/usb/usbdi_util.h> 47 48 #ifdef USB_DEBUG 49 #define DPRINTF(x) do { if (usbdebug) printf x; } while (0) 50 #define DPRINTFN(n,x) do { if (usbdebug>(n)) printf x; } while (0) 51 extern int usbdebug; 52 #else 53 #define DPRINTF(x) 54 #define DPRINTFN(n,x) 55 #endif 56 57 usbd_status 58 usbd_get_desc(struct usbd_device *dev, int type, int index, int len, void *desc) 59 { 60 usb_device_request_t req; 61 62 DPRINTFN(3,("%s: type=%d, index=%d, len=%d\n", __func__, type, index, 63 len)); 64 65 req.bmRequestType = UT_READ_DEVICE; 66 req.bRequest = UR_GET_DESCRIPTOR; 67 USETW2(req.wValue, type, index); 68 USETW(req.wIndex, 0); 69 USETW(req.wLength, len); 70 return (usbd_do_request(dev, &req, desc)); 71 } 72 73 usbd_status 74 usbd_get_device_status(struct usbd_device *dev, usb_status_t *st) 75 { 76 usb_device_request_t req; 77 78 req.bmRequestType = UT_READ_DEVICE; 79 req.bRequest = UR_GET_STATUS; 80 USETW(req.wValue, 0); 81 USETW(req.wIndex, 0); 82 USETW(req.wLength, sizeof(usb_status_t)); 83 return (usbd_do_request(dev, &req, st)); 84 } 85 86 usbd_status 87 usbd_get_hub_status(struct usbd_device *dev, usb_hub_status_t *st) 88 { 89 usb_device_request_t req; 90 91 req.bmRequestType = UT_READ_CLASS_DEVICE; 92 req.bRequest = UR_GET_STATUS; 93 USETW(req.wValue, 0); 94 USETW(req.wIndex, 0); 95 USETW(req.wLength, sizeof(usb_hub_status_t)); 96 return (usbd_do_request(dev, &req, st)); 97 } 98 99 usbd_status 100 usbd_get_hub_descriptor(struct usbd_device *dev, usb_hub_descriptor_t *hd, 101 uint8_t nports) 102 { 103 usb_device_request_t req; 104 uint16_t len = USB_HUB_DESCRIPTOR_SIZE + (nports + 1) / 8; 105 106 req.bmRequestType = UT_READ_CLASS_DEVICE; 107 req.bRequest = UR_GET_DESCRIPTOR; 108 USETW2(req.wValue, UDESC_HUB, 0); 109 USETW(req.wIndex, 0); 110 USETW(req.wLength, len); 111 return (usbd_do_request(dev, &req, hd)); 112 } 113 114 usbd_status 115 usbd_get_hub_ss_descriptor(struct usbd_device *dev, usb_hub_ss_descriptor_t *hd, 116 uint8_t nports) 117 { 118 usb_device_request_t req; 119 uint16_t len = USB_HUB_SS_DESCRIPTOR_SIZE + (nports + 1) / 8; 120 121 req.bmRequestType = UT_READ_CLASS_DEVICE; 122 req.bRequest = UR_GET_DESCRIPTOR; 123 USETW2(req.wValue, UDESC_SS_HUB, 0); 124 USETW(req.wIndex, 0); 125 USETW(req.wLength, len); 126 return (usbd_do_request(dev, &req, hd)); 127 } 128 129 usbd_status 130 usbd_get_port_status(struct usbd_device *dev, int port, usb_port_status_t *ps) 131 { 132 usb_device_request_t req; 133 134 req.bmRequestType = UT_READ_CLASS_OTHER; 135 req.bRequest = UR_GET_STATUS; 136 USETW(req.wValue, 0); 137 USETW(req.wIndex, port); 138 USETW(req.wLength, sizeof *ps); 139 return (usbd_do_request(dev, &req, ps)); 140 } 141 142 usbd_status 143 usbd_clear_hub_feature(struct usbd_device *dev, int sel) 144 { 145 usb_device_request_t req; 146 147 req.bmRequestType = UT_WRITE_CLASS_DEVICE; 148 req.bRequest = UR_CLEAR_FEATURE; 149 USETW(req.wValue, sel); 150 USETW(req.wIndex, 0); 151 USETW(req.wLength, 0); 152 return (usbd_do_request(dev, &req, 0)); 153 } 154 155 usbd_status 156 usbd_set_hub_feature(struct usbd_device *dev, int sel) 157 { 158 usb_device_request_t req; 159 160 req.bmRequestType = UT_WRITE_CLASS_DEVICE; 161 req.bRequest = UR_SET_FEATURE; 162 USETW(req.wValue, sel); 163 USETW(req.wIndex, 0); 164 USETW(req.wLength, 0); 165 return (usbd_do_request(dev, &req, 0)); 166 } 167 168 usbd_status 169 usbd_set_hub_depth(struct usbd_device *dev, int depth) 170 { 171 usb_device_request_t req; 172 173 req.bmRequestType = UT_WRITE_CLASS_DEVICE; 174 req.bRequest = UR_SET_DEPTH; 175 USETW(req.wValue, depth); 176 USETW(req.wIndex, 0); 177 USETW(req.wLength, 0); 178 return usbd_do_request(dev, &req, 0); 179 } 180 181 usbd_status 182 usbd_clear_port_feature(struct usbd_device *dev, int port, int sel) 183 { 184 usb_device_request_t req; 185 186 req.bmRequestType = UT_WRITE_CLASS_OTHER; 187 req.bRequest = UR_CLEAR_FEATURE; 188 USETW(req.wValue, sel); 189 USETW(req.wIndex, port); 190 USETW(req.wLength, 0); 191 return (usbd_do_request(dev, &req, 0)); 192 } 193 194 usbd_status 195 usbd_clear_endpoint_feature(struct usbd_device *dev, int epaddr, int sel) 196 { 197 usb_device_request_t req; 198 199 req.bmRequestType = UT_WRITE_ENDPOINT; 200 req.bRequest = UR_CLEAR_FEATURE; 201 USETW(req.wValue, sel); 202 USETW(req.wIndex, epaddr); 203 USETW(req.wLength, 0); 204 return (usbd_do_request(dev, &req, 0)); 205 } 206 207 usbd_status 208 usbd_set_port_feature(struct usbd_device *dev, int port, int sel) 209 { 210 usb_device_request_t req; 211 212 req.bmRequestType = UT_WRITE_CLASS_OTHER; 213 req.bRequest = UR_SET_FEATURE; 214 USETW(req.wValue, sel); 215 USETW(req.wIndex, port); 216 USETW(req.wLength, 0); 217 return (usbd_do_request(dev, &req, 0)); 218 } 219 220 usbd_status 221 usbd_set_idle(struct usbd_device *dev, int ifaceno, int duration, int id) 222 { 223 usb_device_request_t req; 224 225 DPRINTFN(4, ("%s: %d %d\n", __func__, duration, id)); 226 req.bmRequestType = UT_WRITE_CLASS_INTERFACE; 227 req.bRequest = UR_SET_IDLE; 228 USETW2(req.wValue, duration, id); 229 USETW(req.wIndex, ifaceno); 230 USETW(req.wLength, 0); 231 return (usbd_do_request(dev, &req, 0)); 232 } 233 234 usbd_status 235 usbd_get_report_descriptor(struct usbd_device *dev, int ifaceno, 236 void *data, int len) 237 { 238 usb_device_request_t req; 239 240 req.bmRequestType = UT_READ_INTERFACE; 241 req.bRequest = UR_GET_DESCRIPTOR; 242 USETW2(req.wValue, UDESC_REPORT, 0); /* report id should be 0 */ 243 USETW(req.wIndex, ifaceno); 244 USETW(req.wLength, len); 245 return (usbd_do_request(dev, &req, data)); 246 } 247 248 struct usb_hid_descriptor * 249 usbd_get_hid_descriptor(struct usbd_device *dev, usb_interface_descriptor_t *id) 250 { 251 usb_config_descriptor_t *cdesc = usbd_get_config_descriptor(dev); 252 struct usb_hid_descriptor *hd; 253 char *p, *end; 254 255 p = (char *)id + id->bLength; 256 end = (char *)cdesc + UGETW(cdesc->wTotalLength); 257 258 for (; p < end; p += hd->bLength) { 259 hd = (struct usb_hid_descriptor *)p; 260 if (p + hd->bLength <= end && hd->bDescriptorType == UDESC_HID) 261 return (hd); 262 if (hd->bDescriptorType == UDESC_INTERFACE) 263 break; 264 } 265 return (0); 266 } 267 268 usbd_status 269 usbd_get_config(struct usbd_device *dev, u_int8_t *conf) 270 { 271 usb_device_request_t req; 272 273 req.bmRequestType = UT_READ_DEVICE; 274 req.bRequest = UR_GET_CONFIG; 275 USETW(req.wValue, 0); 276 USETW(req.wIndex, 0); 277 USETW(req.wLength, 1); 278 return (usbd_do_request(dev, &req, conf)); 279 } 280 281 void 282 usb_detach_wait(struct device *dv) 283 { 284 DPRINTF(("%s: waiting for %s\n", __func__, dv->dv_xname)); 285 if (tsleep_nsec(dv, PZERO, "usbdet", SEC_TO_NSEC(60))) 286 printf("%s: %s didn't detach\n", __func__, dv->dv_xname); 287 DPRINTF(("%s: %s done\n", __func__, dv->dv_xname)); 288 } 289 290 void 291 usb_detach_wakeup(struct device *dv) 292 { 293 DPRINTF(("%s: for %s\n", __func__, dv->dv_xname)); 294 wakeup(dv); 295 } 296