1/* $NetBSD: usbroothub.c,v 1.2 2016/04/23 10:15:32 skrll Exp $ */
2
3/*-
4 * Copyright (c) 1998, 2004, 2011, 2012 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Lennart Augustsson (lennart@augustsson.net) at
9 * Carlstedt Research & Technology, Jared D. McNeill (jmcneill@invisible.ca),
10 * Matthew R. Green (mrg@eterna.com.au) and Nick Hudson.
11 *
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
14 * are met:
15 * 1. Redistributions of source code must retain the above copyright
16 * notice, this list of conditions and the following disclaimer.
17 * 2. Redistributions in binary form must reproduce the above copyright
18 * notice, this list of conditions and the following disclaimer in the
19 * documentation and/or other materials provided with the distribution.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
23 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
24 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
31 * POSSIBILITY OF SUCH DAMAGE.
32 */
33
34/*
35 * Copyright (c) 2008
36 * Matthias Drochner. All rights reserved.
37 *
38 * Redistribution and use in source and binary forms, with or without
39 * modification, are permitted provided that the following conditions
40 * are met:
41 * 1. Redistributions of source code must retain the above copyright
42 * notice, this list of conditions and the following disclaimer.
43 * 2. Redistributions in binary form must reproduce the above copyright
44 * notice, this list of conditions and the following disclaimer in the
45 * documentation and/or other materials provided with the distribution.
46 *
47 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
48 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
49 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
50 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
51 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
52 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
53 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
54 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
55 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
56 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
57 *
58 */
59
60#include <dev/usb/usb.h>
61#include <dev/usb/usbdi.h>
62#include <dev/usb/usbdivar.h>
63#include <dev/usb/usbroothub.h>
64#include <dev/usb/usbhist.h>
65
66extern int usbdebug;
67
68/* helper functions for USB root hub emulation */
69
70static usbd_status roothub_ctrl_transfer(struct usbd_xfer *);
71static usbd_status roothub_ctrl_start(struct usbd_xfer *);
72static void roothub_ctrl_abort(struct usbd_xfer *);
73static void roothub_ctrl_close(struct usbd_pipe *);
74static void roothub_ctrl_done(struct usbd_xfer *);
75static void roothub_noop(struct usbd_pipe *pipe);
76
77const struct usbd_pipe_methods roothub_ctrl_methods = {
78 .upm_transfer = roothub_ctrl_transfer,
79 .upm_start = roothub_ctrl_start,
80 .upm_abort = roothub_ctrl_abort,
81 .upm_close = roothub_ctrl_close,
82 .upm_cleartoggle = roothub_noop,
83 .upm_done = roothub_ctrl_done,
84};
85
86int
87usb_makestrdesc(usb_string_descriptor_t *p, int l, const char *s)
88{
89 int i;
90
91 if (l == 0)
92 return 0;
93 p->bLength = 2 * strlen(s) + 2;
94 if (l == 1)
95 return 1;
96 p->bDescriptorType = UDESC_STRING;
97 l -= 2;
98 /* poor man's utf-16le conversion */
99 for (i = 0; s[i] && l > 1; i++, l -= 2)
100 USETW2(p->bString[i], 0, s[i]);
101 return 2 * i + 2;
102}
103
104int
105usb_makelangtbl(usb_string_descriptor_t *p, int l)
106{
107
108 if (l == 0)
109 return 0;
110 p->bLength = 4;
111 if (l == 1)
112 return 1;
113 p->bDescriptorType = UDESC_STRING;
114 if (l < 4)
115 return 2;
116 USETW(p->bString[0], 0x0409); /* english/US */
117 return 4;
118}
119
120/*
121 * Data structures and routines to emulate the root hub.
122 */
123static const usb_device_descriptor_t usbroothub_devd1 = {
124 .bLength = sizeof(usb_device_descriptor_t),
125 .bDescriptorType = UDESC_DEVICE,
126 .bcdUSB = {0x00, 0x01},
127 .bDeviceClass = UDCLASS_HUB,
128 .bDeviceSubClass = UDSUBCLASS_HUB,
129 .bDeviceProtocol = UDPROTO_FSHUB,
130 .bMaxPacketSize = 64,
131 .idVendor = {0},
132 .idProduct = {0},
133 .bcdDevice = {0x00, 0x01},
134 .iManufacturer = 1,
135 .iProduct = 2,
136 .iSerialNumber = 0,
137 .bNumConfigurations = 1
138};
139
140static const struct usb_roothub_descriptors usbroothub_confd1 = {
141 .urh_confd = {
142 .bLength = USB_CONFIG_DESCRIPTOR_SIZE,
143 .bDescriptorType = UDESC_CONFIG,
144 .wTotalLength = USETWD(sizeof(usbroothub_confd1)),
145 .bNumInterface = 1,
146 .bConfigurationValue = 1,
147 .iConfiguration = 0,
148 .bmAttributes = UC_ATTR_MBO | UC_SELF_POWERED,
149 .bMaxPower = 0,
150 },
151 .urh_ifcd = {
152 .bLength = USB_INTERFACE_DESCRIPTOR_SIZE,
153 .bDescriptorType = UDESC_INTERFACE,
154 .bInterfaceNumber = 0,
155 .bAlternateSetting = 0,
156 .bNumEndpoints = 1,
157 .bInterfaceClass = UICLASS_HUB,
158 .bInterfaceSubClass = UISUBCLASS_HUB,
159 .bInterfaceProtocol = UIPROTO_FSHUB,
160 .iInterface = 0
161 },
162 .urh_endpd = {
163 .bLength = USB_ENDPOINT_DESCRIPTOR_SIZE,
164 .bDescriptorType = UDESC_ENDPOINT,
165 .bEndpointAddress = UE_DIR_IN | USBROOTHUB_INTR_ENDPT,
166 .bmAttributes = UE_INTERRUPT,
167 .wMaxPacketSize = USETWD(8), /* max packet */
168 .bInterval = 255,
169 },
170};
171
172static const usb_device_descriptor_t usbroothub_devd2 = {
173 .bLength = sizeof(usb_device_descriptor_t),
174 .bDescriptorType = UDESC_DEVICE,
175 .bcdUSB = {0x00, 0x02},
176 .bDeviceClass = UDCLASS_HUB,
177 .bDeviceSubClass = UDSUBCLASS_HUB,
178 .bDeviceProtocol = UDPROTO_HSHUBSTT,
179 .bMaxPacketSize = 64,
180 .idVendor = {0},
181 .idProduct = {0},
182 .bcdDevice = {0x00, 0x01},
183 .iManufacturer = 1,
184 .iProduct = 2,
185 .iSerialNumber = 0,
186 .bNumConfigurations = 1
187};
188
189static const usb_device_qualifier_t usbroothub_odevd2 = {
190 .bLength = USB_DEVICE_QUALIFIER_SIZE,
191 .bDescriptorType = UDESC_DEVICE_QUALIFIER,
192 .bcdUSB = {0x00, 0x02},
193 .bDeviceClass = UDCLASS_HUB,
194 .bDeviceSubClass = UDSUBCLASS_HUB,
195 .bDeviceProtocol = UDPROTO_FSHUB,
196 .bMaxPacketSize0 = 64,
197 .bNumConfigurations = 1,
198};
199
200static const struct usb_roothub_descriptors usbroothub_confd2 = {
201 .urh_confd = {
202 .bLength = USB_CONFIG_DESCRIPTOR_SIZE,
203 .bDescriptorType = UDESC_CONFIG,
204 .wTotalLength = USETWD(sizeof(usbroothub_confd2)),
205 .bNumInterface = 1,
206 .bConfigurationValue = 1,
207 .iConfiguration = 0,
208 .bmAttributes = UC_ATTR_MBO | UC_SELF_POWERED,
209 .bMaxPower = 0,
210 },
211 .urh_ifcd = {
212 .bLength = USB_INTERFACE_DESCRIPTOR_SIZE,
213 .bDescriptorType = UDESC_INTERFACE,
214 .bInterfaceNumber = 0,
215 .bAlternateSetting = 0,
216 .bNumEndpoints = 1,
217 .bInterfaceClass = UICLASS_HUB,
218 .bInterfaceSubClass = UISUBCLASS_HUB,
219 .bInterfaceProtocol = UIPROTO_HSHUBSTT,
220 .iInterface = 0
221 },
222 .urh_endpd = {
223 .bLength = USB_ENDPOINT_DESCRIPTOR_SIZE,
224 .bDescriptorType = UDESC_ENDPOINT,
225 .bEndpointAddress = UE_DIR_IN | USBROOTHUB_INTR_ENDPT,
226 .bmAttributes = UE_INTERRUPT,
227 .wMaxPacketSize = USETWD(8), /* max packet */
228 .bInterval = 12,
229 },
230};
231
232static const usb_hub_descriptor_t usbroothub_hubd = {
233 .bDescLength = USB_HUB_DESCRIPTOR_SIZE,
234 .bDescriptorType = UDESC_HUB,
235 .bNbrPorts = 1,
236 .wHubCharacteristics = USETWD(UHD_PWR_NO_SWITCH | UHD_OC_INDIVIDUAL),
237 .bPwrOn2PwrGood = 50,
238 .bHubContrCurrent = 0,
239 .DeviceRemovable = {0}, /* port is removable */
240};
241
242/*
243 * Simulate a hardware hub by handling all the necessary requests.
244 */
245usbd_status
246roothub_ctrl_transfer(struct usbd_xfer *xfer)
247{
248 struct usbd_pipe *pipe = xfer->ux_pipe;
249 struct usbd_bus *bus = pipe->up_dev->ud_bus;
250 usbd_status err;
251
252 /* Insert last in queue. */
253 mutex_enter(bus->ub_lock);
254 err = usb_insert_transfer(xfer);
255 mutex_exit(bus->ub_lock);
256 if (err)
257 return err;
258
259 /* Pipe isn't running, start first */
260 return roothub_ctrl_start(SIMPLEQ_FIRST(&xfer->ux_pipe->up_queue));
261}
262
263static usbd_status
264roothub_ctrl_start(struct usbd_xfer *xfer)
265{
266 struct usbd_pipe *pipe = xfer->ux_pipe;
267 struct usbd_bus *bus = pipe->up_dev->ud_bus;
268 usb_device_request_t *req;
269 usbd_status err = USBD_IOERROR; /* XXX STALL? */
270 uint16_t len, value;
271 int buflen, actlen;
272 void *buf;
273
274 USBHIST_FUNC(); USBHIST_CALLED(usbdebug);
275
276 KASSERT(xfer->ux_rqflags & URQ_REQUEST);
277 req = &xfer->ux_request;
278
279 USBHIST_LOG(usbdebug, "type=%#2x request=%#2x", req->bmRequestType,
280 req->bRequest, 0, 0);
281
282 len = UGETW(req->wLength);
283 value = UGETW(req->wValue);
284
285 buf = len ? usbd_get_buffer(xfer) : NULL;
286 buflen = 0;
287
288#define C(x,y) ((x) | ((y) << 8))
289 switch (C(req->bRequest, req->bmRequestType)) {
290 case C(UR_CLEAR_FEATURE, UT_WRITE_DEVICE):
291 case C(UR_CLEAR_FEATURE, UT_WRITE_INTERFACE):
292 case C(UR_CLEAR_FEATURE, UT_WRITE_ENDPOINT):
293 /*
294 * DEVICE_REMOTE_WAKEUP and ENDPOINT_HALT are no-ops
295 * for the integrated root hub.
296 */
297 break;
298 case C(UR_GET_CONFIG, UT_READ_DEVICE):
299 if (len > 0) {
300 uint8_t *out = buf;
301
302 *out = bus->ub_rhconf;
303 buflen = sizeof(*out);
304 }
305 break;
306 case C(UR_GET_DESCRIPTOR, UT_READ_DEVICE):
307 USBHIST_LOG(usbdebug, "wValue=%#4x", value, 0, 0, 0);
308
309 if (len == 0)
310 break;
311 switch (value) {
312 case C(0, UDESC_DEVICE):
313 if (bus->ub_revision == USBREV_2_0) {
314 buflen = min(len, sizeof(usbroothub_devd2));
315 memcpy(buf, &usbroothub_devd2, buflen);
316 } else {
317 buflen = min(len, sizeof(usbroothub_devd1));
318 memcpy(buf, &usbroothub_devd1, buflen);
319 }
320 break;
321 case C(0, UDESC_CONFIG):
322 if (bus->ub_revision == USBREV_2_0) {
323 buflen = min(len, sizeof(usbroothub_confd2));
324 memcpy(buf, &usbroothub_confd2, buflen);
325 } else {
326 buflen = min(len, sizeof(usbroothub_confd1));
327 memcpy(buf, &usbroothub_confd1, buflen);
328 }
329 break;
330 case C(0, UDESC_DEVICE_QUALIFIER):
331 if (bus->ub_revision == USBREV_2_0) {
332 /*
333 * We can't really operate at another speed,
334 * but the spec says we need this descriptor.
335 */
336 buflen = min(len, sizeof(usbroothub_odevd2));
337 memcpy(buf, &usbroothub_odevd2, buflen);
338 } else
339 goto fail;
340 break;
341 case C(0, UDESC_OTHER_SPEED_CONFIGURATION):
342 if (bus->ub_revision == USBREV_2_0) {
343 struct usb_roothub_descriptors confd;
344
345 /*
346 * We can't really operate at another speed,
347 * but the spec says we need this descriptor.
348 */
349 buflen = min(len, sizeof(usbroothub_confd2));
350 memcpy(&confd, &usbroothub_confd2, buflen);
351 confd.urh_confd.bDescriptorType =
352 UDESC_OTHER_SPEED_CONFIGURATION;
353 memcpy(buf, &confd, buflen);
354 } else
355 goto fail;
356 break;
357#define sd ((usb_string_descriptor_t *)buf)
358 case C(0, UDESC_STRING):
359 /* Language table */
360 buflen = usb_makelangtbl(sd, len);
361 break;
362 case C(1, UDESC_STRING):
363 /* Vendor */
364 buflen = usb_makestrdesc(sd, len, "NetBSD");
365 break;
366 case C(2, UDESC_STRING):
367 /* Product */
368 buflen = usb_makestrdesc(sd, len, "Root hub");
369 break;
370#undef sd
371 default:
372 /* Default to error */
373 buflen = -1;
374 }
375 break;
376 case C(UR_GET_DESCRIPTOR, UT_READ_CLASS_DEVICE):
377 buflen = min(len, sizeof(usbroothub_hubd));
378 memcpy(buf, &usbroothub_hubd, buflen);
379 break;
380 case C(UR_GET_INTERFACE, UT_READ_INTERFACE):
381 /* Get Interface, 9.4.4 */
382 if (len > 0) {
383 uint8_t *out = buf;
384
385 *out = 0;
386 buflen = sizeof(*out);
387 }
388 break;
389 case C(UR_GET_STATUS, UT_READ_DEVICE):
390 /* Get Status from device, 9.4.5 */
391 if (len > 1) {
392 usb_status_t *out = buf;
393
394 USETW(out->wStatus, UDS_SELF_POWERED);
395 buflen = sizeof(*out);
396 }
397 break;
398 case C(UR_GET_STATUS, UT_READ_INTERFACE):
399 case C(UR_GET_STATUS, UT_READ_ENDPOINT):
400 /* Get Status from interface, endpoint, 9.4.5 */
401 if (len > 1) {
402 usb_status_t *out = buf;
403
404 USETW(out->wStatus, 0);
405 buflen = sizeof(*out);
406 }
407 break;
408 case C(UR_SET_ADDRESS, UT_WRITE_DEVICE):
409 /* Set Address, 9.4.6 */
410 USBHIST_LOG(usbdebug, "UR_SET_ADDRESS, UT_WRITE_DEVICE: addr %d",
411 value, 0, 0, 0);
412 if (value >= USB_MAX_DEVICES) {
413 goto fail;
414 }
415 bus->ub_rhaddr = value;
416 break;
417 case C(UR_SET_CONFIG, UT_WRITE_DEVICE):
418 /* Set Configuration, 9.4.7 */
419 if (value != 0 && value != 1) {
420 goto fail;
421 }
422 bus->ub_rhconf = value;
423 break;
424 case C(UR_SET_DESCRIPTOR, UT_WRITE_DEVICE):
425 /* Set Descriptor, 9.4.8, not supported */
426 break;
427 case C(UR_SET_FEATURE, UT_WRITE_DEVICE):
428 case C(UR_SET_FEATURE, UT_WRITE_INTERFACE):
429 case C(UR_SET_FEATURE, UT_WRITE_ENDPOINT):
430 /* Set Feature, 9.4.9, not supported */
431 goto fail;
432 case C(UR_SET_INTERFACE, UT_WRITE_INTERFACE):
433 /* Set Interface, 9.4.10, not supported */
434 break;
435 case C(UR_SYNCH_FRAME, UT_WRITE_ENDPOINT):
436 /* Synch Frame, 9.4.11, not supported */
437 break;
438 default:
439 /* Default to error */
440 buflen = -1;
441 break;
442 }
443
444 actlen = bus->ub_methods->ubm_rhctrl(bus, req, buf, buflen);
445 USBHIST_LOG(usbdebug, "xfer %p buflen %d actlen %d", xfer, buflen,
446 actlen, 0);
447 if (actlen < 0)
448 goto fail;
449
450 xfer->ux_actlen = actlen;
451 err = USBD_NORMAL_COMPLETION;
452
453 fail:
454 USBHIST_LOG(usbdebug, "xfer %p err %d", xfer, err, 0, 0);
455
456 xfer->ux_status = err;
457 mutex_enter(bus->ub_lock);
458 usb_transfer_complete(xfer);
459 mutex_exit(bus->ub_lock);
460
461 return USBD_NORMAL_COMPLETION;
462}
463
464/* Abort a root control request. */
465Static void
466roothub_ctrl_abort(struct usbd_xfer *xfer)
467{
468
469 /* Nothing to do, all transfers are synchronous. */
470}
471
472/* Close the root pipe. */
473Static void
474roothub_ctrl_close(struct usbd_pipe *pipe)
475{
476
477 /* Nothing to do. */
478}
479
480Static void
481roothub_ctrl_done(struct usbd_xfer *xfer)
482{
483
484 /* Nothing to do. */
485}
486
487static void
488roothub_noop(struct usbd_pipe *pipe)
489{
490
491}
492