1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause
3 *
4 * Copyright (c) 2008-2023 Hans Petter Selasky
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25 * SUCH DAMAGE.
26 */
27
28 #ifdef USB_GLOBAL_INCLUDE_FILE
29 #include USB_GLOBAL_INCLUDE_FILE
30 #else
31 #ifdef COMPAT_FREEBSD32
32 #include <sys/abi_compat.h>
33 #endif
34 #include <sys/stdint.h>
35 #include <sys/stddef.h>
36 #include <sys/param.h>
37 #include <sys/queue.h>
38 #include <sys/types.h>
39 #include <sys/systm.h>
40 #include <sys/kernel.h>
41 #include <sys/bus.h>
42 #include <sys/module.h>
43 #include <sys/lock.h>
44 #include <sys/mutex.h>
45 #include <sys/condvar.h>
46 #include <sys/sysctl.h>
47 #include <sys/sx.h>
48 #include <sys/unistd.h>
49 #include <sys/callout.h>
50 #include <sys/malloc.h>
51 #include <sys/priv.h>
52 #include <sys/conf.h>
53 #include <sys/fcntl.h>
54
55 #include <dev/usb/usb.h>
56 #include <dev/usb/usb_ioctl.h>
57 #include <dev/usb/usbdi.h>
58 #include <dev/usb/usbdi_util.h>
59
60 #define USB_DEBUG_VAR ugen_debug
61
62 #include <dev/usb/usb_core.h>
63 #include <dev/usb/usb_dev.h>
64 #include <dev/usb/usb_mbuf.h>
65 #include <dev/usb/usb_process.h>
66 #include <dev/usb/usb_device.h>
67 #include <dev/usb/usb_debug.h>
68 #include <dev/usb/usb_request.h>
69 #include <dev/usb/usb_busdma.h>
70 #include <dev/usb/usb_util.h>
71 #include <dev/usb/usb_hub.h>
72 #include <dev/usb/usb_generic.h>
73 #include <dev/usb/usb_transfer.h>
74
75 #include <dev/usb/usb_controller.h>
76 #include <dev/usb/usb_bus.h>
77 #endif /* USB_GLOBAL_INCLUDE_FILE */
78
79 #if USB_HAVE_UGEN
80
81 /* defines */
82
83 #define UGEN_BULK_FS_BUFFER_SIZE (64*32) /* bytes */
84 #define UGEN_BULK_HS_BUFFER_SIZE (1024*32) /* bytes */
85 #define UGEN_HW_FRAMES 50 /* number of milliseconds per transfer */
86
87 /* function prototypes */
88
89 static usb_callback_t ugen_read_clear_stall_callback;
90 static usb_callback_t ugen_write_clear_stall_callback;
91 static usb_callback_t ugen_ctrl_read_callback;
92 static usb_callback_t ugen_ctrl_write_callback;
93 static usb_callback_t ugen_isoc_read_callback;
94 static usb_callback_t ugen_isoc_write_callback;
95 static usb_callback_t ugen_ctrl_fs_callback;
96
97 static usb_fifo_open_t ugen_open;
98 static usb_fifo_close_t ugen_close;
99 static usb_fifo_ioctl_t ugen_ioctl;
100 static usb_fifo_ioctl_t ugen_ioctl_post;
101 static usb_fifo_cmd_t ugen_start_read;
102 static usb_fifo_cmd_t ugen_start_write;
103 static usb_fifo_cmd_t ugen_stop_io;
104
105 static int ugen_transfer_setup(struct usb_fifo *,
106 const struct usb_config *, uint8_t);
107 static int ugen_open_pipe_write(struct usb_fifo *);
108 static int ugen_open_pipe_read(struct usb_fifo *);
109 static int ugen_set_config(struct usb_fifo *, uint8_t);
110 static int ugen_set_interface(struct usb_fifo *, uint8_t, uint8_t);
111 static int ugen_get_cdesc(struct usb_fifo *, struct usb_gen_descriptor *);
112 static int ugen_get_sdesc(struct usb_fifo *, struct usb_gen_descriptor *);
113 static int ugen_get_iface_driver(struct usb_fifo *f, struct usb_gen_descriptor *ugd);
114 #ifdef COMPAT_FREEBSD32
115 static int ugen_get32(u_long cmd, struct usb_fifo *f, struct usb_gen_descriptor32 *ugd32);
116 #endif
117 static int ugen_re_enumerate(struct usb_fifo *);
118 static int ugen_iface_ioctl(struct usb_fifo *, u_long, void *, int);
119 static uint8_t ugen_fs_get_complete(struct usb_fifo *, uint8_t *);
120 static int ugen_fs_uninit(struct usb_fifo *f);
121 static int ugen_fs_copyin(struct usb_fifo *, uint8_t, struct usb_fs_endpoint*);
122 static uint8_t ugen_fifo_in_use(struct usb_fifo *, int fflags);
123
124 /* structures */
125
126 struct usb_fifo_methods usb_ugen_methods = {
127 .f_open = &ugen_open,
128 .f_close = &ugen_close,
129 .f_ioctl = &ugen_ioctl,
130 .f_ioctl_post = &ugen_ioctl_post,
131 .f_start_read = &ugen_start_read,
132 .f_stop_read = &ugen_stop_io,
133 .f_start_write = &ugen_start_write,
134 .f_stop_write = &ugen_stop_io,
135 };
136
137 #ifdef USB_DEBUG
138 static int ugen_debug = 0;
139
140 static SYSCTL_NODE(_hw_usb, OID_AUTO, ugen, CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
141 "USB generic");
142 SYSCTL_INT(_hw_usb_ugen, OID_AUTO, debug, CTLFLAG_RWTUN, &ugen_debug,
143 0, "Debug level");
144 #endif
145
146 static const int usb_error_to_errno[USB_ERR_MAX] = {
147 [USB_ERR_NORMAL_COMPLETION] = 0,
148 [USB_ERR_PENDING_REQUESTS] = EALREADY,
149 [USB_ERR_NOT_STARTED] = EINVAL,
150 [USB_ERR_INVAL] = EINVAL,
151 [USB_ERR_NOMEM] = ENOMEM,
152 [USB_ERR_CANCELLED] = ECANCELED,
153 [USB_ERR_BAD_ADDRESS] = EFAULT,
154 [USB_ERR_BAD_BUFSIZE] = ENOBUFS,
155 [USB_ERR_BAD_FLAG] = EINVAL,
156 [USB_ERR_NO_CALLBACK] = EINVAL,
157 [USB_ERR_IN_USE] = EADDRINUSE,
158 [USB_ERR_NO_ADDR] = EADDRNOTAVAIL,
159 [USB_ERR_NO_PIPE] = ENOENT,
160 [USB_ERR_ZERO_NFRAMES] = EINVAL,
161 [USB_ERR_ZERO_MAXP] = EINVAL,
162 [USB_ERR_SET_ADDR_FAILED] = EADDRNOTAVAIL,
163 [USB_ERR_NO_POWER] = ENXIO,
164 [USB_ERR_TOO_DEEP] = EINVAL,
165 [USB_ERR_IOERROR] = EIO,
166 [USB_ERR_NOT_CONFIGURED] = ENXIO,
167 [USB_ERR_TIMEOUT] = ETIMEDOUT,
168 [USB_ERR_SHORT_XFER] = ERANGE,
169 [USB_ERR_STALLED] = EPIPE,
170 [USB_ERR_INTERRUPTED] = EINTR,
171 [USB_ERR_DMA_LOAD_FAILED] = EIO,
172 [USB_ERR_BAD_CONTEXT] = EBADMSG,
173 [USB_ERR_NO_ROOT_HUB] = EINVAL,
174 [USB_ERR_NO_INTR_THREAD] = EIO,
175 [USB_ERR_NOT_LOCKED] = EINVAL,
176 };
177
178 /* prototypes */
179
180 static int
ugen_transfer_setup(struct usb_fifo * f,const struct usb_config * setup,uint8_t n_setup)181 ugen_transfer_setup(struct usb_fifo *f,
182 const struct usb_config *setup, uint8_t n_setup)
183 {
184 struct usb_endpoint *ep = usb_fifo_softc(f);
185 struct usb_device *udev = f->udev;
186 uint8_t iface_index = ep->iface_index;
187 int error;
188
189 mtx_unlock(f->priv_mtx);
190
191 /*
192 * "usbd_transfer_setup()" can sleep so one needs to make a wrapper,
193 * exiting the mutex and checking things
194 */
195 error = usbd_transfer_setup(udev, &iface_index, f->xfer,
196 setup, n_setup, f, f->priv_mtx);
197 if (error == 0) {
198 if (f->xfer[0]->nframes == 1) {
199 error = usb_fifo_alloc_buffer(f,
200 f->xfer[0]->max_data_length, 2);
201 } else {
202 error = usb_fifo_alloc_buffer(f,
203 f->xfer[0]->max_frame_size,
204 2 * f->xfer[0]->nframes);
205 }
206 if (error) {
207 usbd_transfer_unsetup(f->xfer, n_setup);
208 }
209 }
210 mtx_lock(f->priv_mtx);
211
212 return (error);
213 }
214
215 static int
ugen_open(struct usb_fifo * f,int fflags)216 ugen_open(struct usb_fifo *f, int fflags)
217 {
218 struct usb_endpoint *ep = usb_fifo_softc(f);
219 struct usb_endpoint_descriptor *ed = ep->edesc;
220 uint8_t type;
221
222 DPRINTFN(1, "flag=0x%x pid=%d name=%s\n", fflags,
223 curthread->td_proc->p_pid, curthread->td_proc->p_comm);
224
225 mtx_lock(f->priv_mtx);
226 switch (usbd_get_speed(f->udev)) {
227 case USB_SPEED_LOW:
228 case USB_SPEED_FULL:
229 f->nframes = UGEN_HW_FRAMES;
230 f->bufsize = UGEN_BULK_FS_BUFFER_SIZE;
231 break;
232 default:
233 f->nframes = UGEN_HW_FRAMES * 8;
234 f->bufsize = UGEN_BULK_HS_BUFFER_SIZE;
235 break;
236 }
237
238 type = ed->bmAttributes & UE_XFERTYPE;
239 if (type == UE_INTERRUPT) {
240 f->bufsize = 0; /* use "wMaxPacketSize" */
241 }
242 f->timeout = USB_NO_TIMEOUT;
243 f->flag_short = 0;
244 f->fifo_zlp = 0;
245 mtx_unlock(f->priv_mtx);
246
247 return (0);
248 }
249
250 static void
ugen_close(struct usb_fifo * f,int fflags)251 ugen_close(struct usb_fifo *f, int fflags)
252 {
253
254 DPRINTFN(1, "flag=0x%x pid=%d name=%s\n", fflags,
255 curthread->td_proc->p_pid, curthread->td_proc->p_comm);
256
257 /* cleanup */
258
259 mtx_lock(f->priv_mtx);
260 usbd_transfer_stop(f->xfer[0]);
261 usbd_transfer_stop(f->xfer[1]);
262 mtx_unlock(f->priv_mtx);
263
264 usbd_transfer_unsetup(f->xfer, 2);
265 usb_fifo_free_buffer(f);
266
267 if (ugen_fs_uninit(f)) {
268 /* ignore any errors - we are closing */
269 DPRINTFN(6, "no FIFOs\n");
270 }
271 }
272
273 static int
ugen_open_pipe_write(struct usb_fifo * f)274 ugen_open_pipe_write(struct usb_fifo *f)
275 {
276 struct usb_config usb_config[2];
277 struct usb_endpoint *ep = usb_fifo_softc(f);
278 struct usb_endpoint_descriptor *ed = ep->edesc;
279
280 USB_MTX_ASSERT(f->priv_mtx, MA_OWNED);
281
282 if (f->xfer[0] || f->xfer[1]) {
283 /* transfers are already opened */
284 return (0);
285 }
286 memset(usb_config, 0, sizeof(usb_config));
287
288 usb_config[1].type = UE_CONTROL;
289 usb_config[1].endpoint = 0;
290 usb_config[1].direction = UE_DIR_ANY;
291 usb_config[1].timeout = 1000; /* 1 second */
292 usb_config[1].interval = 50;/* 50 milliseconds */
293 usb_config[1].bufsize = sizeof(struct usb_device_request);
294 usb_config[1].callback = &ugen_write_clear_stall_callback;
295 usb_config[1].usb_mode = USB_MODE_HOST;
296
297 usb_config[0].type = ed->bmAttributes & UE_XFERTYPE;
298 usb_config[0].endpoint = ed->bEndpointAddress & UE_ADDR;
299 usb_config[0].stream_id = 0; /* XXX support more stream ID's */
300 usb_config[0].direction = UE_DIR_TX;
301 usb_config[0].interval = USB_DEFAULT_INTERVAL;
302 usb_config[0].flags.proxy_buffer = 1;
303 usb_config[0].usb_mode = USB_MODE_DUAL; /* both modes */
304
305 switch (ed->bmAttributes & UE_XFERTYPE) {
306 case UE_INTERRUPT:
307 case UE_BULK:
308 if (f->flag_short) {
309 usb_config[0].flags.force_short_xfer = 1;
310 }
311 usb_config[0].callback = &ugen_ctrl_write_callback;
312 usb_config[0].timeout = f->timeout;
313 usb_config[0].frames = 1;
314 usb_config[0].bufsize = f->bufsize;
315 if (ugen_transfer_setup(f, usb_config, 2)) {
316 return (EIO);
317 }
318 /* first transfer does not clear stall */
319 f->flag_stall = 0;
320 break;
321
322 case UE_ISOCHRONOUS:
323 usb_config[0].flags.short_xfer_ok = 1;
324 usb_config[0].bufsize = 0; /* use default */
325 usb_config[0].frames = f->nframes;
326 usb_config[0].callback = &ugen_isoc_write_callback;
327 usb_config[0].timeout = 0;
328
329 /* clone configuration */
330 usb_config[1] = usb_config[0];
331
332 if (ugen_transfer_setup(f, usb_config, 2)) {
333 return (EIO);
334 }
335 break;
336 default:
337 return (EINVAL);
338 }
339 return (0);
340 }
341
342 static int
ugen_open_pipe_read(struct usb_fifo * f)343 ugen_open_pipe_read(struct usb_fifo *f)
344 {
345 struct usb_config usb_config[2];
346 struct usb_endpoint *ep = usb_fifo_softc(f);
347 struct usb_endpoint_descriptor *ed = ep->edesc;
348
349 USB_MTX_ASSERT(f->priv_mtx, MA_OWNED);
350
351 if (f->xfer[0] || f->xfer[1]) {
352 /* transfers are already opened */
353 return (0);
354 }
355 memset(usb_config, 0, sizeof(usb_config));
356
357 usb_config[1].type = UE_CONTROL;
358 usb_config[1].endpoint = 0;
359 usb_config[1].direction = UE_DIR_ANY;
360 usb_config[1].timeout = 1000; /* 1 second */
361 usb_config[1].interval = 50;/* 50 milliseconds */
362 usb_config[1].bufsize = sizeof(struct usb_device_request);
363 usb_config[1].callback = &ugen_read_clear_stall_callback;
364 usb_config[1].usb_mode = USB_MODE_HOST;
365
366 usb_config[0].type = ed->bmAttributes & UE_XFERTYPE;
367 usb_config[0].endpoint = ed->bEndpointAddress & UE_ADDR;
368 usb_config[0].stream_id = 0; /* XXX support more stream ID's */
369 usb_config[0].direction = UE_DIR_RX;
370 usb_config[0].interval = USB_DEFAULT_INTERVAL;
371 usb_config[0].flags.proxy_buffer = 1;
372 usb_config[0].usb_mode = USB_MODE_DUAL; /* both modes */
373
374 switch (ed->bmAttributes & UE_XFERTYPE) {
375 case UE_INTERRUPT:
376 case UE_BULK:
377 if (f->flag_short) {
378 usb_config[0].flags.short_xfer_ok = 1;
379 }
380 usb_config[0].timeout = f->timeout;
381 usb_config[0].frames = 1;
382 usb_config[0].callback = &ugen_ctrl_read_callback;
383 usb_config[0].bufsize = f->bufsize;
384
385 if (ugen_transfer_setup(f, usb_config, 2)) {
386 return (EIO);
387 }
388 /* first transfer does not clear stall */
389 f->flag_stall = 0;
390 break;
391
392 case UE_ISOCHRONOUS:
393 usb_config[0].flags.short_xfer_ok = 1;
394 usb_config[0].bufsize = 0; /* use default */
395 usb_config[0].frames = f->nframes;
396 usb_config[0].callback = &ugen_isoc_read_callback;
397 usb_config[0].timeout = 0;
398
399 /* clone configuration */
400 usb_config[1] = usb_config[0];
401
402 if (ugen_transfer_setup(f, usb_config, 2)) {
403 return (EIO);
404 }
405 break;
406
407 default:
408 return (EINVAL);
409 }
410 return (0);
411 }
412
413 static void
ugen_start_read(struct usb_fifo * f)414 ugen_start_read(struct usb_fifo *f)
415 {
416 /* check that pipes are open */
417 if (ugen_open_pipe_read(f)) {
418 /* signal error */
419 usb_fifo_put_data_error(f);
420 }
421 /* start transfers */
422 usbd_transfer_start(f->xfer[0]);
423 usbd_transfer_start(f->xfer[1]);
424 }
425
426 static void
ugen_start_write(struct usb_fifo * f)427 ugen_start_write(struct usb_fifo *f)
428 {
429 /* check that pipes are open */
430 if (ugen_open_pipe_write(f)) {
431 /* signal error */
432 usb_fifo_get_data_error(f);
433 }
434 /* start transfers */
435 usbd_transfer_start(f->xfer[0]);
436 usbd_transfer_start(f->xfer[1]);
437 }
438
439 static void
ugen_stop_io(struct usb_fifo * f)440 ugen_stop_io(struct usb_fifo *f)
441 {
442 /* stop transfers */
443 usbd_transfer_stop(f->xfer[0]);
444 usbd_transfer_stop(f->xfer[1]);
445 }
446
447 static void
ugen_ctrl_read_callback(struct usb_xfer * xfer,usb_error_t error)448 ugen_ctrl_read_callback(struct usb_xfer *xfer, usb_error_t error)
449 {
450 struct usb_fifo *f = usbd_xfer_softc(xfer);
451 struct usb_mbuf *m;
452
453 DPRINTFN(4, "actlen=%u, aframes=%u\n", xfer->actlen, xfer->aframes);
454
455 switch (USB_GET_STATE(xfer)) {
456 case USB_ST_TRANSFERRED:
457 if (xfer->actlen == 0) {
458 if (f->fifo_zlp != 4) {
459 f->fifo_zlp++;
460 } else {
461 /*
462 * Throttle a little bit we have multiple ZLPs
463 * in a row!
464 */
465 xfer->interval = 64; /* ms */
466 }
467 } else {
468 /* clear throttle */
469 xfer->interval = 0;
470 f->fifo_zlp = 0;
471 }
472 usb_fifo_put_data(f, xfer->frbuffers, 0,
473 xfer->actlen, 1);
474
475 case USB_ST_SETUP:
476 if (f->flag_stall) {
477 usbd_transfer_start(f->xfer[1]);
478 break;
479 }
480 USB_IF_POLL(&f->free_q, m);
481 if (m) {
482 usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
483 usbd_transfer_submit(xfer);
484 }
485 break;
486
487 default: /* Error */
488 if (xfer->error != USB_ERR_CANCELLED) {
489 /* send a zero length packet to userland */
490 usb_fifo_put_data(f, xfer->frbuffers, 0, 0, 1);
491 f->flag_stall = 1;
492 f->fifo_zlp = 0;
493 usbd_transfer_start(f->xfer[1]);
494 }
495 break;
496 }
497 }
498
499 static void
ugen_ctrl_write_callback(struct usb_xfer * xfer,usb_error_t error)500 ugen_ctrl_write_callback(struct usb_xfer *xfer, usb_error_t error)
501 {
502 struct usb_fifo *f = usbd_xfer_softc(xfer);
503 usb_frlength_t actlen;
504
505 DPRINTFN(4, "actlen=%u, aframes=%u\n", xfer->actlen, xfer->aframes);
506
507 switch (USB_GET_STATE(xfer)) {
508 case USB_ST_SETUP:
509 case USB_ST_TRANSFERRED:
510 /*
511 * If writing is in stall, just jump to clear stall
512 * callback and solve the situation.
513 */
514 if (f->flag_stall) {
515 usbd_transfer_start(f->xfer[1]);
516 break;
517 }
518 /*
519 * Write data, setup and perform hardware transfer.
520 */
521 if (usb_fifo_get_data(f, xfer->frbuffers, 0,
522 xfer->max_data_length, &actlen, 0)) {
523 usbd_xfer_set_frame_len(xfer, 0, actlen);
524 usbd_transfer_submit(xfer);
525 }
526 break;
527
528 default: /* Error */
529 if (xfer->error != USB_ERR_CANCELLED) {
530 f->flag_stall = 1;
531 usbd_transfer_start(f->xfer[1]);
532 }
533 break;
534 }
535 }
536
537 static void
ugen_read_clear_stall_callback(struct usb_xfer * xfer,usb_error_t error)538 ugen_read_clear_stall_callback(struct usb_xfer *xfer, usb_error_t error)
539 {
540 struct usb_fifo *f = usbd_xfer_softc(xfer);
541 struct usb_xfer *xfer_other = f->xfer[0];
542
543 if (f->flag_stall == 0) {
544 /* nothing to do */
545 return;
546 }
547 if (usbd_clear_stall_callback(xfer, xfer_other)) {
548 DPRINTFN(5, "f=%p: stall cleared\n", f);
549 f->flag_stall = 0;
550 usbd_transfer_start(xfer_other);
551 }
552 }
553
554 static void
ugen_write_clear_stall_callback(struct usb_xfer * xfer,usb_error_t error)555 ugen_write_clear_stall_callback(struct usb_xfer *xfer, usb_error_t error)
556 {
557 struct usb_fifo *f = usbd_xfer_softc(xfer);
558 struct usb_xfer *xfer_other = f->xfer[0];
559
560 if (f->flag_stall == 0) {
561 /* nothing to do */
562 return;
563 }
564 if (usbd_clear_stall_callback(xfer, xfer_other)) {
565 DPRINTFN(5, "f=%p: stall cleared\n", f);
566 f->flag_stall = 0;
567 usbd_transfer_start(xfer_other);
568 }
569 }
570
571 static void
ugen_isoc_read_callback(struct usb_xfer * xfer,usb_error_t error)572 ugen_isoc_read_callback(struct usb_xfer *xfer, usb_error_t error)
573 {
574 struct usb_fifo *f = usbd_xfer_softc(xfer);
575 usb_frlength_t offset;
576 usb_frcount_t n;
577
578 DPRINTFN(4, "actlen=%u, aframes=%u\n", xfer->actlen, xfer->aframes);
579
580 switch (USB_GET_STATE(xfer)) {
581 case USB_ST_TRANSFERRED:
582
583 DPRINTFN(6, "actlen=%d\n", xfer->actlen);
584
585 offset = 0;
586
587 for (n = 0; n != xfer->aframes; n++) {
588 usb_fifo_put_data(f, xfer->frbuffers, offset,
589 xfer->frlengths[n], 1);
590 offset += xfer->max_frame_size;
591 }
592
593 case USB_ST_SETUP:
594 tr_setup:
595 for (n = 0; n != xfer->nframes; n++) {
596 /* setup size for next transfer */
597 usbd_xfer_set_frame_len(xfer, n, xfer->max_frame_size);
598 }
599 usbd_transfer_submit(xfer);
600 break;
601
602 default: /* Error */
603 if (xfer->error == USB_ERR_CANCELLED) {
604 break;
605 }
606 goto tr_setup;
607 }
608 }
609
610 static void
ugen_isoc_write_callback(struct usb_xfer * xfer,usb_error_t error)611 ugen_isoc_write_callback(struct usb_xfer *xfer, usb_error_t error)
612 {
613 struct usb_fifo *f = usbd_xfer_softc(xfer);
614 usb_frlength_t actlen;
615 usb_frlength_t offset;
616 usb_frcount_t n;
617
618 DPRINTFN(4, "actlen=%u, aframes=%u\n", xfer->actlen, xfer->aframes);
619
620 switch (USB_GET_STATE(xfer)) {
621 case USB_ST_TRANSFERRED:
622 case USB_ST_SETUP:
623 tr_setup:
624 offset = 0;
625 for (n = 0; n != xfer->nframes; n++) {
626 if (usb_fifo_get_data(f, xfer->frbuffers, offset,
627 xfer->max_frame_size, &actlen, 1)) {
628 usbd_xfer_set_frame_len(xfer, n, actlen);
629 offset += actlen;
630 } else {
631 break;
632 }
633 }
634
635 for (; n != xfer->nframes; n++) {
636 /* fill in zero frames */
637 usbd_xfer_set_frame_len(xfer, n, 0);
638 }
639 usbd_transfer_submit(xfer);
640 break;
641
642 default: /* Error */
643 if (xfer->error == USB_ERR_CANCELLED) {
644 break;
645 }
646 goto tr_setup;
647 }
648 }
649
650 static int
ugen_set_config(struct usb_fifo * f,uint8_t index)651 ugen_set_config(struct usb_fifo *f, uint8_t index)
652 {
653 DPRINTFN(2, "index %u\n", index);
654
655 if (f->udev->flags.usb_mode != USB_MODE_HOST) {
656 /* not possible in device side mode */
657 return (ENOTTY);
658 }
659
660 /* make sure all FIFO's are gone */
661 /* else there can be a deadlock */
662 if (ugen_fs_uninit(f)) {
663 /* ignore any errors */
664 DPRINTFN(6, "no FIFOs\n");
665 }
666
667 if (usbd_start_set_config(f->udev, index) != 0)
668 return (EIO);
669
670 return (0);
671 }
672
673 static int
ugen_set_interface(struct usb_fifo * f,uint8_t iface_index,uint8_t alt_index)674 ugen_set_interface(struct usb_fifo *f,
675 uint8_t iface_index, uint8_t alt_index)
676 {
677 DPRINTFN(2, "%u, %u\n", iface_index, alt_index);
678
679 if (f->udev->flags.usb_mode != USB_MODE_HOST) {
680 /* not possible in device side mode */
681 return (ENOTTY);
682 }
683 /* make sure all FIFO's are gone */
684 /* else there can be a deadlock */
685 if (ugen_fs_uninit(f)) {
686 /* ignore any errors */
687 DPRINTFN(6, "no FIFOs\n");
688 }
689 /* change setting - will free generic FIFOs, if any */
690 if (usbd_set_alt_interface_index(f->udev, iface_index, alt_index)) {
691 return (EIO);
692 }
693 /* probe and attach */
694 if (usb_probe_and_attach(f->udev, iface_index)) {
695 return (EIO);
696 }
697 return (0);
698 }
699
700 /*------------------------------------------------------------------------*
701 * ugen_get_cdesc
702 *
703 * This function will retrieve the complete configuration descriptor
704 * at the given index.
705 *------------------------------------------------------------------------*/
706 static int
ugen_get_cdesc(struct usb_fifo * f,struct usb_gen_descriptor * ugd)707 ugen_get_cdesc(struct usb_fifo *f, struct usb_gen_descriptor *ugd)
708 {
709 struct usb_config_descriptor *cdesc;
710 struct usb_device *udev = f->udev;
711 int error;
712 uint16_t len;
713 uint8_t free_data;
714
715 DPRINTFN(6, "\n");
716
717 if (ugd->ugd_data == NULL) {
718 /* userland pointer should not be zero */
719 return (EINVAL);
720 }
721 if ((ugd->ugd_config_index == USB_UNCONFIG_INDEX) ||
722 (ugd->ugd_config_index == udev->curr_config_index)) {
723 cdesc = usbd_get_config_descriptor(udev);
724 if (cdesc == NULL)
725 return (ENXIO);
726 free_data = 0;
727
728 } else {
729 #if (USB_HAVE_FIXED_CONFIG == 0)
730 if (usbd_req_get_config_desc_full(udev,
731 NULL, &cdesc, ugd->ugd_config_index)) {
732 return (ENXIO);
733 }
734 free_data = 1;
735 #else
736 /* configuration descriptor data is shared */
737 return (EINVAL);
738 #endif
739 }
740
741 len = UGETW(cdesc->wTotalLength);
742 if (len > ugd->ugd_maxlen) {
743 len = ugd->ugd_maxlen;
744 }
745 DPRINTFN(6, "len=%u\n", len);
746
747 ugd->ugd_actlen = len;
748 ugd->ugd_offset = 0;
749
750 error = copyout(cdesc, ugd->ugd_data, len);
751
752 if (free_data)
753 usbd_free_config_desc(udev, cdesc);
754
755 return (error);
756 }
757
758 static int
ugen_get_sdesc(struct usb_fifo * f,struct usb_gen_descriptor * ugd)759 ugen_get_sdesc(struct usb_fifo *f, struct usb_gen_descriptor *ugd)
760 {
761 void *ptr;
762 uint16_t size;
763 int error;
764 uint8_t do_unlock;
765
766 /* Protect scratch area */
767 do_unlock = usbd_ctrl_lock(f->udev);
768
769 ptr = f->udev->scratch.data;
770 size = sizeof(f->udev->scratch.data);
771
772 if (usbd_req_get_string_desc(f->udev, NULL, ptr,
773 size, ugd->ugd_lang_id, ugd->ugd_string_index)) {
774 error = EINVAL;
775 } else {
776 if (size > ((uint8_t *)ptr)[0]) {
777 size = ((uint8_t *)ptr)[0];
778 }
779 if (size > ugd->ugd_maxlen) {
780 size = ugd->ugd_maxlen;
781 }
782 ugd->ugd_actlen = size;
783 ugd->ugd_offset = 0;
784
785 error = copyout(ptr, ugd->ugd_data, size);
786 }
787 if (do_unlock)
788 usbd_ctrl_unlock(f->udev);
789
790 return (error);
791 }
792
793 /*------------------------------------------------------------------------*
794 * ugen_get_iface_driver
795 *
796 * This function generates an USB interface description for userland.
797 *
798 * Returns:
799 * 0: Success
800 * Else: Failure
801 *------------------------------------------------------------------------*/
802 static int
ugen_get_iface_driver(struct usb_fifo * f,struct usb_gen_descriptor * ugd)803 ugen_get_iface_driver(struct usb_fifo *f, struct usb_gen_descriptor *ugd)
804 {
805 struct usb_device *udev = f->udev;
806 struct usb_interface *iface;
807 const char *ptr;
808 const char *desc;
809 unsigned len;
810 unsigned maxlen;
811 char buf[128];
812 int error;
813
814 DPRINTFN(6, "\n");
815
816 if ((ugd->ugd_data == NULL) || (ugd->ugd_maxlen == 0)) {
817 /* userland pointer should not be zero */
818 return (EINVAL);
819 }
820
821 iface = usbd_get_iface(udev, ugd->ugd_iface_index);
822 if ((iface == NULL) || (iface->idesc == NULL)) {
823 /* invalid interface index */
824 return (EINVAL);
825 }
826
827 /* read out device nameunit string, if any */
828 if ((iface->subdev != NULL) &&
829 device_is_attached(iface->subdev) &&
830 (ptr = device_get_nameunit(iface->subdev)) &&
831 (desc = device_get_desc(iface->subdev))) {
832 /* print description */
833 snprintf(buf, sizeof(buf), "%s: <%s>", ptr, desc);
834
835 /* range checks */
836 maxlen = ugd->ugd_maxlen - 1;
837 len = strlen(buf);
838 if (len > maxlen)
839 len = maxlen;
840
841 /* update actual length, including terminating zero */
842 ugd->ugd_actlen = len + 1;
843
844 /* copy out interface description */
845 error = copyout(buf, ugd->ugd_data, ugd->ugd_actlen);
846 } else {
847 /* zero length string is default */
848 error = copyout("", ugd->ugd_data, 1);
849 }
850 return (error);
851 }
852
853 /*------------------------------------------------------------------------*
854 * ugen_fill_deviceinfo
855 *
856 * This function dumps information about an USB device to the
857 * structure pointed to by the "di" argument.
858 *
859 * Returns:
860 * 0: Success
861 * Else: Failure
862 *------------------------------------------------------------------------*/
863 int
ugen_fill_deviceinfo(struct usb_fifo * f,struct usb_device_info * di)864 ugen_fill_deviceinfo(struct usb_fifo *f, struct usb_device_info *di)
865 {
866 return (usbd_fill_deviceinfo(f->udev, di));
867 }
868
869 int
ugen_do_request(struct usb_fifo * f,struct usb_ctl_request * ur)870 ugen_do_request(struct usb_fifo *f, struct usb_ctl_request *ur)
871 {
872 int error;
873 uint16_t len;
874 uint16_t actlen;
875
876 if (usb_check_request(f->udev, &ur->ucr_request)) {
877 return (EPERM);
878 }
879 len = UGETW(ur->ucr_request.wLength);
880
881 /* check if "ucr_data" is valid */
882 if (len != 0) {
883 if (ur->ucr_data == NULL) {
884 return (EFAULT);
885 }
886 }
887 /* do the USB request */
888 error = usbd_do_request_flags
889 (f->udev, NULL, &ur->ucr_request, ur->ucr_data,
890 (ur->ucr_flags & USB_SHORT_XFER_OK) |
891 USB_USER_DATA_PTR, &actlen,
892 USB_DEFAULT_TIMEOUT);
893
894 ur->ucr_actlen = actlen;
895
896 /*
897 * Fall back to EIO for USB errors without a table entry, so
898 * that an unmapped error cannot be reported as success.
899 */
900 if (error < 0 || error >= USB_ERR_MAX ||
901 (error != USB_ERR_NORMAL_COMPLETION &&
902 usb_error_to_errno[error] == 0))
903 return (EIO);
904
905 return (usb_error_to_errno[error]);
906 }
907
908 #ifdef COMPAT_FREEBSD32
909 static int
ugen_do_request32(struct usb_fifo * f,struct usb_ctl_request32 * ur32)910 ugen_do_request32(struct usb_fifo *f, struct usb_ctl_request32 *ur32)
911 {
912 struct usb_ctl_request ur;
913 int error;
914
915 PTRIN_CP(*ur32, ur, ucr_data);
916 CP(*ur32, ur, ucr_flags);
917 CP(*ur32, ur, ucr_actlen);
918 CP(*ur32, ur, ucr_addr);
919 CP(*ur32, ur, ucr_request);
920
921 error = ugen_do_request(f, &ur);
922
923 /* Don't update ucr_data pointer */
924 CP(ur, *ur32, ucr_flags);
925 CP(ur, *ur32, ucr_actlen);
926 CP(ur, *ur32, ucr_addr);
927 CP(ur, *ur32, ucr_request);
928
929 return (error);
930 }
931 #endif
932
933 /*------------------------------------------------------------------------
934 * ugen_re_enumerate
935 *------------------------------------------------------------------------*/
936 static int
ugen_re_enumerate(struct usb_fifo * f)937 ugen_re_enumerate(struct usb_fifo *f)
938 {
939 struct usb_device *udev = f->udev;
940 int error;
941
942 /*
943 * This request can be useful for testing USB drivers:
944 */
945 error = priv_check(curthread, PRIV_DRIVER);
946 if (error) {
947 return (error);
948 }
949 if (udev->flags.usb_mode != USB_MODE_HOST) {
950 /* not possible in device side mode */
951 DPRINTFN(6, "device mode\n");
952 return (ENOTTY);
953 }
954 /* make sure all FIFO's are gone */
955 /* else there can be a deadlock */
956 if (ugen_fs_uninit(f)) {
957 /* ignore any errors */
958 DPRINTFN(6, "no FIFOs\n");
959 }
960 /* start re-enumeration of device */
961 usbd_start_re_enumerate(udev);
962 return (0);
963 }
964
965 static int
ugen_fs_init(struct usb_fifo * f,struct usb_fs_endpoint * fs_ep_ptr,usb_size_t fs_ep_sz,int fflags,uint8_t ep_index_max)966 ugen_fs_init(struct usb_fifo *f,
967 struct usb_fs_endpoint *fs_ep_ptr, usb_size_t fs_ep_sz,
968 int fflags, uint8_t ep_index_max)
969 {
970 int error;
971
972 /* verify input parameters */
973 if (fs_ep_ptr == NULL || ep_index_max > USB_FS_XFER_MAX)
974 return (EINVAL);
975
976 if (f->fs_ep_max != 0)
977 return (EBUSY);
978
979 if (f->dev_ep_index != 0 || ep_index_max == 0)
980 return (EINVAL);
981
982 if (ugen_fifo_in_use(f, fflags))
983 return (EBUSY);
984
985 error = usb_fifo_alloc_buffer(f, 1, ep_index_max);
986 if (error == 0) {
987 mtx_lock(f->priv_mtx);
988 f->fs_ep_max = ep_index_max;
989 f->fs_ep_ptr = fs_ep_ptr;
990 f->fs_ep_sz = fs_ep_sz;
991 mtx_unlock(f->priv_mtx);
992 }
993 return (error);
994 }
995
996 int
ugen_fs_uninit(struct usb_fifo * f)997 ugen_fs_uninit(struct usb_fifo *f)
998 {
999 if (f->fs_ep_max == 0)
1000 return (EINVAL);
1001
1002 /*
1003 * Prevent calls into the fast-path code, by setting fs_ep_max
1004 * to zero:
1005 */
1006 sx_xlock(&f->fs_fastpath_lock);
1007 mtx_lock(f->priv_mtx);
1008 f->fs_ep_max = 0;
1009 mtx_unlock(f->priv_mtx);
1010 sx_xunlock(&f->fs_fastpath_lock);
1011
1012 usbd_transfer_unsetup(f->fs_xfer, USB_FS_XFER_MAX);
1013
1014 mtx_lock(f->priv_mtx);
1015 f->fs_ep_ptr = NULL;
1016 f->flag_iscomplete = 0;
1017 mtx_unlock(f->priv_mtx);
1018
1019 usb_fifo_free_buffer(f);
1020 return (0);
1021 }
1022
1023 static int
usb_fs_open(struct usb_fifo * f,struct usb_fs_open * popen,int fflags,usb_stream_t stream_id)1024 usb_fs_open(struct usb_fifo *f, struct usb_fs_open *popen,
1025 int fflags, usb_stream_t stream_id)
1026 {
1027 struct usb_config usb_config[1] = {};
1028 struct usb_endpoint *ep;
1029 struct usb_endpoint_descriptor *ed;
1030 uint8_t iface_index;
1031 uint8_t pre_scale;
1032 uint8_t isread;
1033 int error;
1034
1035 if (popen->ep_index >= f->fs_ep_max)
1036 return (EINVAL);
1037
1038 if (f->fs_xfer[popen->ep_index] != NULL)
1039 return (EBUSY);
1040
1041 if (popen->max_bufsize > USB_FS_MAX_BUFSIZE)
1042 popen->max_bufsize = USB_FS_MAX_BUFSIZE;
1043
1044 if (popen->max_frames & USB_FS_MAX_FRAMES_PRE_SCALE) {
1045 pre_scale = 1;
1046 popen->max_frames &= ~USB_FS_MAX_FRAMES_PRE_SCALE;
1047 } else {
1048 pre_scale = 0;
1049 }
1050
1051 if (popen->max_frames > USB_FS_MAX_FRAMES)
1052 popen->max_frames = USB_FS_MAX_FRAMES;
1053
1054 if (popen->max_frames == 0)
1055 return (EINVAL);
1056
1057 ep = usbd_get_ep_by_addr(f->udev, popen->ep_no);
1058 if (ep == NULL)
1059 return (EINVAL);
1060
1061 ed = ep->edesc;
1062 if (ed == NULL)
1063 return (ENXIO);
1064
1065 iface_index = ep->iface_index;
1066
1067 usb_config[0].type = ed->bmAttributes & UE_XFERTYPE;
1068 usb_config[0].endpoint = ed->bEndpointAddress & UE_ADDR;
1069 usb_config[0].direction = ed->bEndpointAddress & (UE_DIR_OUT | UE_DIR_IN);
1070 usb_config[0].interval = USB_DEFAULT_INTERVAL;
1071 usb_config[0].flags.proxy_buffer = 1;
1072 if (pre_scale != 0)
1073 usb_config[0].flags.pre_scale_frames = 1;
1074
1075 usb_config[0].callback = &ugen_ctrl_fs_callback;
1076 usb_config[0].timeout = 0; /* no timeout */
1077 usb_config[0].frames = popen->max_frames;
1078 usb_config[0].bufsize = popen->max_bufsize;
1079 usb_config[0].usb_mode = USB_MODE_DUAL; /* both modes */
1080 usb_config[0].stream_id = stream_id;
1081
1082 if (usb_config[0].type == UE_CONTROL) {
1083 if (f->udev->flags.usb_mode != USB_MODE_HOST)
1084 return (EINVAL);
1085 } else {
1086 isread = ((usb_config[0].endpoint &
1087 (UE_DIR_IN | UE_DIR_OUT)) == UE_DIR_IN);
1088
1089 if (f->udev->flags.usb_mode != USB_MODE_HOST)
1090 isread = !isread;
1091
1092 /* check permissions */
1093 if (isread) {
1094 if (!(fflags & FREAD))
1095 return (EPERM);
1096 } else {
1097 if (!(fflags & FWRITE))
1098 return (EPERM);
1099 }
1100 }
1101 error = usbd_transfer_setup(f->udev, &iface_index,
1102 f->fs_xfer + popen->ep_index, usb_config, 1,
1103 f, f->priv_mtx);
1104 if (error == 0) {
1105 /* update maximums */
1106 popen->max_packet_length =
1107 f->fs_xfer[popen->ep_index]->max_frame_size;
1108 popen->max_bufsize =
1109 f->fs_xfer[popen->ep_index]->max_data_length;
1110 /* update number of frames */
1111 popen->max_frames =
1112 f->fs_xfer[popen->ep_index]->nframes;
1113 /* store index of endpoint */
1114 f->fs_xfer[popen->ep_index]->priv_fifo =
1115 ((uint8_t *)0) + popen->ep_index;
1116 } else {
1117 error = ENOMEM;
1118 }
1119 return (error);
1120 }
1121
1122 static int
usb_fs_close(struct usb_fifo * f,struct usb_fs_close * pclose)1123 usb_fs_close(struct usb_fifo *f, struct usb_fs_close *pclose)
1124 {
1125 struct usb_xfer *xfer;
1126
1127 if (pclose->ep_index >= f->fs_ep_max)
1128 return (EINVAL);
1129
1130 /*
1131 * Prevent calls into the fast-path code, by setting the
1132 * fs_xfer[] in question to NULL:
1133 */
1134 sx_xlock(&f->fs_fastpath_lock);
1135 mtx_lock(f->priv_mtx);
1136 xfer = f->fs_xfer[pclose->ep_index];
1137 f->fs_xfer[pclose->ep_index] = NULL;
1138 mtx_unlock(f->priv_mtx);
1139 sx_xunlock(&f->fs_fastpath_lock);
1140
1141 if (xfer == NULL)
1142 return (EINVAL);
1143
1144 usbd_transfer_unsetup(&xfer, 1);
1145 return (0);
1146 }
1147
1148 static int
usb_fs_clear_stall_sync(struct usb_fifo * f,struct usb_fs_clear_stall_sync * pstall)1149 usb_fs_clear_stall_sync(struct usb_fifo *f, struct usb_fs_clear_stall_sync *pstall)
1150 {
1151 struct usb_device_request req;
1152 struct usb_endpoint *ep;
1153 int error;
1154
1155 if (pstall->ep_index >= f->fs_ep_max)
1156 return (EINVAL);
1157
1158 if (f->fs_xfer[pstall->ep_index] == NULL)
1159 return (EINVAL);
1160
1161 if (f->udev->flags.usb_mode != USB_MODE_HOST)
1162 return (EINVAL);
1163
1164 mtx_lock(f->priv_mtx);
1165 error = usbd_transfer_pending(f->fs_xfer[pstall->ep_index]);
1166 mtx_unlock(f->priv_mtx);
1167
1168 if (error)
1169 return (EBUSY);
1170
1171 ep = f->fs_xfer[pstall->ep_index]->endpoint;
1172
1173 /* setup a clear-stall packet */
1174 req.bmRequestType = UT_WRITE_ENDPOINT;
1175 req.bRequest = UR_CLEAR_FEATURE;
1176 USETW(req.wValue, UF_ENDPOINT_HALT);
1177 req.wIndex[0] = ep->edesc->bEndpointAddress;
1178 req.wIndex[1] = 0;
1179 USETW(req.wLength, 0);
1180
1181 error = usbd_do_request(f->udev, NULL, &req, NULL);
1182 if (error == 0) {
1183 usbd_clear_data_toggle(f->udev, ep);
1184 } else {
1185 error = ENXIO;
1186 }
1187 return (error);
1188 }
1189
1190 static uint8_t
ugen_fs_get_complete(struct usb_fifo * f,uint8_t * pindex)1191 ugen_fs_get_complete(struct usb_fifo *f, uint8_t *pindex)
1192 {
1193 struct usb_mbuf *m;
1194
1195 USB_IF_DEQUEUE(&f->used_q, m);
1196
1197 if (m) {
1198 *pindex = *((uint8_t *)(m->cur_data_ptr));
1199
1200 USB_IF_ENQUEUE(&f->free_q, m);
1201
1202 return (0); /* success */
1203 } else {
1204 *pindex = 0; /* fix compiler warning */
1205
1206 f->flag_iscomplete = 0;
1207 }
1208 return (1); /* failure */
1209 }
1210
1211 static void
ugen_fs_set_complete(struct usb_fifo * f,uint8_t index)1212 ugen_fs_set_complete(struct usb_fifo *f, uint8_t index)
1213 {
1214 struct usb_mbuf *m;
1215
1216 USB_IF_DEQUEUE(&f->free_q, m);
1217
1218 if (m == NULL) {
1219 /* can happen during close */
1220 DPRINTF("out of buffers\n");
1221 return;
1222 }
1223 USB_MBUF_RESET(m);
1224
1225 *((uint8_t *)(m->cur_data_ptr)) = index;
1226
1227 USB_IF_ENQUEUE(&f->used_q, m);
1228
1229 f->flag_iscomplete = 1;
1230
1231 usb_fifo_wakeup(f);
1232 }
1233
1234 static int
ugen_fs_getbuffer(void ** uptrp,struct usb_fifo * f,void * buffer,usb_frcount_t n)1235 ugen_fs_getbuffer(void **uptrp, struct usb_fifo *f, void *buffer,
1236 usb_frcount_t n)
1237 {
1238 union {
1239 void **ppBuffer;
1240 #ifdef COMPAT_FREEBSD32
1241 uint32_t *ppBuffer32;
1242 #endif
1243 } u;
1244 #ifdef COMPAT_FREEBSD32
1245 uint32_t uptr32;
1246 #endif
1247
1248 u.ppBuffer = buffer;
1249 switch (f->fs_ep_sz) {
1250 case sizeof(struct usb_fs_endpoint):
1251 if (fueword(u.ppBuffer + n, (long *)uptrp) != 0)
1252 return (EFAULT);
1253 return (0);
1254 #ifdef COMPAT_FREEBSD32
1255 case sizeof(struct usb_fs_endpoint32):
1256 if (fueword32(u.ppBuffer32 + n, &uptr32) != 0)
1257 return (EFAULT);
1258 *uptrp = PTRIN(uptr32);
1259 return (0);
1260 #endif
1261 default:
1262 panic("%s: unhandled fs_ep_sz %#x", __func__, f->fs_ep_sz);
1263 }
1264 }
1265
1266 static int
ugen_fs_copy_in(struct usb_fifo * f,uint8_t ep_index)1267 ugen_fs_copy_in(struct usb_fifo *f, uint8_t ep_index)
1268 {
1269 struct usb_device_request *req;
1270 struct usb_xfer *xfer;
1271 struct usb_fs_endpoint fs_ep;
1272 void *uaddr; /* userland pointer */
1273 void *kaddr;
1274 usb_frlength_t offset;
1275 usb_frlength_t rem;
1276 usb_frcount_t n;
1277 uint32_t length;
1278 int error;
1279 uint8_t isread;
1280
1281 mtx_lock(f->priv_mtx);
1282 if (ep_index >= f->fs_ep_max) {
1283 mtx_unlock(f->priv_mtx);
1284 return (EINVAL);
1285 }
1286 xfer = f->fs_xfer[ep_index];
1287 if (xfer == NULL) {
1288 mtx_unlock(f->priv_mtx);
1289 return (EINVAL);
1290 }
1291 if (usbd_transfer_pending(xfer)) {
1292 mtx_unlock(f->priv_mtx);
1293 return (EBUSY); /* should not happen */
1294 }
1295 mtx_unlock(f->priv_mtx);
1296
1297 error = ugen_fs_copyin(f, ep_index, &fs_ep);
1298 if (error) {
1299 return (error);
1300 }
1301 /* security checks */
1302
1303 if (fs_ep.nFrames > xfer->max_frame_count) {
1304 xfer->error = USB_ERR_INVAL;
1305 goto complete;
1306 }
1307 if (fs_ep.nFrames == 0) {
1308 xfer->error = USB_ERR_INVAL;
1309 goto complete;
1310 }
1311 error = ugen_fs_getbuffer(&uaddr, f, fs_ep.ppBuffer, 0);
1312 if (error) {
1313 return (error);
1314 }
1315 /* reset first frame */
1316 usbd_xfer_set_frame_offset(xfer, 0, 0);
1317
1318 if (xfer->flags_int.control_xfr) {
1319 req = xfer->frbuffers[0].buffer;
1320
1321 if (fueword32(fs_ep.pLength, &length) != 0) {
1322 return (EFAULT);
1323 }
1324 if (length != sizeof(*req)) {
1325 xfer->error = USB_ERR_INVAL;
1326 goto complete;
1327 }
1328 if (length != 0) {
1329 error = copyin(uaddr, req, length);
1330 if (error) {
1331 return (error);
1332 }
1333 }
1334 if (usb_check_request(f->udev, req)) {
1335 xfer->error = USB_ERR_INVAL;
1336 goto complete;
1337 }
1338 usbd_xfer_set_frame_len(xfer, 0, length);
1339
1340 /* Host mode only ! */
1341 if ((req->bmRequestType &
1342 (UT_READ | UT_WRITE)) == UT_READ) {
1343 isread = 1;
1344 } else {
1345 isread = 0;
1346 }
1347 n = 1;
1348 offset = sizeof(*req);
1349
1350 } else {
1351 /* Device and Host mode */
1352 if (USB_GET_DATA_ISREAD(xfer)) {
1353 isread = 1;
1354 } else {
1355 isread = 0;
1356 }
1357 n = 0;
1358 offset = 0;
1359 }
1360
1361 rem = usbd_xfer_max_len(xfer);
1362 xfer->nframes = fs_ep.nFrames;
1363 xfer->timeout = fs_ep.timeout;
1364 if (xfer->timeout > 65535) {
1365 xfer->timeout = 65535;
1366 }
1367 if (fs_ep.flags & USB_FS_FLAG_SINGLE_SHORT_OK)
1368 xfer->flags.short_xfer_ok = 1;
1369 else
1370 xfer->flags.short_xfer_ok = 0;
1371
1372 if (fs_ep.flags & USB_FS_FLAG_MULTI_SHORT_OK)
1373 xfer->flags.short_frames_ok = 1;
1374 else
1375 xfer->flags.short_frames_ok = 0;
1376
1377 if (fs_ep.flags & USB_FS_FLAG_FORCE_SHORT)
1378 xfer->flags.force_short_xfer = 1;
1379 else
1380 xfer->flags.force_short_xfer = 0;
1381
1382 if (fs_ep.flags & USB_FS_FLAG_CLEAR_STALL)
1383 usbd_xfer_set_stall(xfer);
1384 else
1385 xfer->flags.stall_pipe = 0;
1386
1387 for (; n != xfer->nframes; n++) {
1388 if (fueword32(fs_ep.pLength + n, &length) != 0) {
1389 break;
1390 }
1391 usbd_xfer_set_frame_len(xfer, n, length);
1392
1393 if (length > rem) {
1394 xfer->error = USB_ERR_INVAL;
1395 goto complete;
1396 }
1397 rem -= length;
1398
1399 if (!isread) {
1400 /* we need to know the source buffer */
1401 error = ugen_fs_getbuffer(&uaddr, f, fs_ep.ppBuffer, n);
1402 if (error) {
1403 break;
1404 }
1405 if (xfer->flags_int.isochronous_xfr) {
1406 /* get kernel buffer address */
1407 kaddr = xfer->frbuffers[0].buffer;
1408 kaddr = USB_ADD_BYTES(kaddr, offset);
1409 } else {
1410 /* set current frame offset */
1411 usbd_xfer_set_frame_offset(xfer, offset, n);
1412
1413 /* get kernel buffer address */
1414 kaddr = xfer->frbuffers[n].buffer;
1415 }
1416
1417 /* move data */
1418 error = copyin(uaddr, kaddr, length);
1419 if (error) {
1420 break;
1421 }
1422 }
1423 offset += length;
1424 }
1425 return (error);
1426
1427 complete:
1428 mtx_lock(f->priv_mtx);
1429 ugen_fs_set_complete(f, ep_index);
1430 mtx_unlock(f->priv_mtx);
1431 return (0);
1432 }
1433
1434 static struct usb_fs_endpoint *
ugen_fs_ep_uptr(struct usb_fifo * f,uint8_t ep_index)1435 ugen_fs_ep_uptr(struct usb_fifo *f, uint8_t ep_index)
1436 {
1437 return ((struct usb_fs_endpoint *)
1438 ((char *)f->fs_ep_ptr + (ep_index * f->fs_ep_sz)));
1439 }
1440
1441 static int
ugen_fs_copyin(struct usb_fifo * f,uint8_t ep_index,struct usb_fs_endpoint * fs_ep)1442 ugen_fs_copyin(struct usb_fifo *f, uint8_t ep_index,
1443 struct usb_fs_endpoint* fs_ep)
1444 {
1445 #ifdef COMPAT_FREEBSD32
1446 struct usb_fs_endpoint32 fs_ep32;
1447 #endif
1448 int error;
1449
1450 switch (f->fs_ep_sz) {
1451 case sizeof(struct usb_fs_endpoint):
1452 error = copyin(ugen_fs_ep_uptr(f, ep_index), fs_ep,
1453 f->fs_ep_sz);
1454 if (error != 0)
1455 return (error);
1456 break;
1457
1458 #ifdef COMPAT_FREEBSD32
1459 case sizeof(struct usb_fs_endpoint32):
1460 error = copyin(ugen_fs_ep_uptr(f, ep_index), &fs_ep32,
1461 f->fs_ep_sz);
1462 if (error != 0)
1463 return (error);
1464 PTRIN_CP(fs_ep32, *fs_ep, ppBuffer);
1465 PTRIN_CP(fs_ep32, *fs_ep, pLength);
1466 CP(fs_ep32, *fs_ep, nFrames);
1467 CP(fs_ep32, *fs_ep, aFrames);
1468 CP(fs_ep32, *fs_ep, flags);
1469 CP(fs_ep32, *fs_ep, timeout);
1470 CP(fs_ep32, *fs_ep, isoc_time_complete);
1471 CP(fs_ep32, *fs_ep, status);
1472 break;
1473 #endif
1474 default:
1475 panic("%s: unhandled fs_ep_sz %#x", __func__, f->fs_ep_sz);
1476 }
1477
1478 return (0);
1479 }
1480
1481 static int
ugen_fs_update(const struct usb_fs_endpoint * fs_ep,struct usb_fifo * f,uint8_t ep_index)1482 ugen_fs_update(const struct usb_fs_endpoint *fs_ep,
1483 struct usb_fifo *f, uint8_t ep_index)
1484 {
1485 union {
1486 struct usb_fs_endpoint *fs_ep_uptr;
1487 #ifdef COMPAT_FREEBSD32
1488 struct usb_fs_endpoint32 *fs_ep_uptr32;
1489 #endif
1490 } u;
1491 uint32_t *aFrames_uptr;
1492 uint16_t *isoc_time_complete_uptr;
1493 int *status_uptr;
1494
1495 switch (f->fs_ep_sz) {
1496 case sizeof(struct usb_fs_endpoint):
1497 u.fs_ep_uptr = ugen_fs_ep_uptr(f, ep_index);
1498 aFrames_uptr = &u.fs_ep_uptr->aFrames;
1499 isoc_time_complete_uptr = &u.fs_ep_uptr->isoc_time_complete;
1500 status_uptr = &u.fs_ep_uptr->status;
1501 break;
1502 #ifdef COMPAT_FREEBSD32
1503 case sizeof(struct usb_fs_endpoint32):
1504 u.fs_ep_uptr32 = (struct usb_fs_endpoint32 *)
1505 ugen_fs_ep_uptr(f, ep_index);
1506 aFrames_uptr = &u.fs_ep_uptr32->aFrames;
1507 isoc_time_complete_uptr = &u.fs_ep_uptr32->isoc_time_complete;
1508 status_uptr = &u.fs_ep_uptr32->status;
1509 break;
1510 #endif
1511 default:
1512 panic("%s: unhandled fs_ep_sz %#x", __func__, f->fs_ep_sz);
1513 }
1514
1515 /* update "aFrames" */
1516 if (suword32(aFrames_uptr, fs_ep->aFrames) != 0)
1517 return (EFAULT);
1518
1519 /* update "isoc_time_complete" */
1520 if (suword16(isoc_time_complete_uptr, fs_ep->isoc_time_complete) != 0)
1521 return (EFAULT);
1522
1523 /* update "status" */
1524 if (suword32(status_uptr, fs_ep->status) != 0)
1525 return (EFAULT);
1526
1527 return (0);
1528 }
1529
1530 static int
ugen_fs_copy_out_cancelled(struct usb_fifo * f,uint8_t ep_index)1531 ugen_fs_copy_out_cancelled(struct usb_fifo *f, uint8_t ep_index)
1532 {
1533 struct usb_fs_endpoint fs_ep;
1534 int error;
1535
1536 error = ugen_fs_copyin(f, ep_index, &fs_ep);
1537 if (error)
1538 return (error);
1539
1540 fs_ep.status = USB_ERR_CANCELLED;
1541 fs_ep.aFrames = 0;
1542 fs_ep.isoc_time_complete = 0;
1543
1544 return (ugen_fs_update(&fs_ep, f, ep_index));
1545 }
1546
1547 static int
ugen_fs_copy_out(struct usb_fifo * f,uint8_t ep_index)1548 ugen_fs_copy_out(struct usb_fifo *f, uint8_t ep_index)
1549 {
1550 struct usb_device_request *req;
1551 struct usb_xfer *xfer;
1552 struct usb_fs_endpoint fs_ep;
1553 void *uaddr; /* userland ptr */
1554 void *kaddr;
1555 usb_frlength_t offset;
1556 usb_frlength_t rem;
1557 usb_frcount_t n;
1558 uint32_t length;
1559 uint32_t temp;
1560 int error;
1561 uint8_t isread;
1562
1563 mtx_lock(f->priv_mtx);
1564 if (ep_index >= f->fs_ep_max) {
1565 mtx_unlock(f->priv_mtx);
1566 return (EINVAL);
1567 }
1568 xfer = f->fs_xfer[ep_index];
1569 if (xfer == NULL) {
1570 mtx_unlock(f->priv_mtx);
1571 return (EINVAL);
1572 }
1573 if (!xfer->flags_int.transferring &&
1574 !xfer->flags_int.started) {
1575 mtx_unlock(f->priv_mtx);
1576 DPRINTF("Returning fake cancel event\n");
1577 return (ugen_fs_copy_out_cancelled(f, ep_index));
1578 } else if (usbd_transfer_pending(xfer)) {
1579 mtx_unlock(f->priv_mtx);
1580 return (EBUSY); /* should not happen */
1581 }
1582 mtx_unlock(f->priv_mtx);
1583
1584 error = ugen_fs_copyin(f, ep_index, &fs_ep);
1585 if (error) {
1586 return (error);
1587 }
1588
1589 fs_ep.status = xfer->error;
1590 fs_ep.aFrames = xfer->aframes;
1591 fs_ep.isoc_time_complete = xfer->isoc_time_complete;
1592 if (xfer->error) {
1593 goto complete;
1594 }
1595 if (xfer->flags_int.control_xfr) {
1596 req = xfer->frbuffers[0].buffer;
1597
1598 /* Host mode only ! */
1599 if ((req->bmRequestType & (UT_READ | UT_WRITE)) == UT_READ) {
1600 isread = 1;
1601 } else {
1602 isread = 0;
1603 }
1604 if (xfer->nframes == 0)
1605 n = 0; /* should never happen */
1606 else
1607 n = 1;
1608 } else {
1609 /* Device and Host mode */
1610 if (USB_GET_DATA_ISREAD(xfer)) {
1611 isread = 1;
1612 } else {
1613 isread = 0;
1614 }
1615 n = 0;
1616 }
1617
1618 /* Update lengths and copy out data */
1619
1620 rem = usbd_xfer_max_len(xfer);
1621 offset = 0;
1622
1623 for (; n != xfer->nframes; n++) {
1624 /* get initial length into "temp" */
1625 if (fueword32(fs_ep.pLength + n, &temp) != 0) {
1626 return (EFAULT);
1627 }
1628 if (temp > rem) {
1629 /* the userland length has been corrupted */
1630 DPRINTF("corrupt userland length "
1631 "%u > %u\n", temp, rem);
1632 fs_ep.status = USB_ERR_INVAL;
1633 goto complete;
1634 }
1635 rem -= temp;
1636
1637 /* get actual transfer length */
1638 length = xfer->frlengths[n];
1639 if (length > temp) {
1640 /* data overflow */
1641 fs_ep.status = USB_ERR_INVAL;
1642 DPRINTF("data overflow %u > %u\n",
1643 length, temp);
1644 goto complete;
1645 }
1646 if (isread) {
1647 /* we need to know the destination buffer */
1648 error = ugen_fs_getbuffer(&uaddr, f, fs_ep.ppBuffer, n);
1649 if (error) {
1650 return (error);
1651 }
1652 if (xfer->flags_int.isochronous_xfr) {
1653 /* only one frame buffer */
1654 kaddr = USB_ADD_BYTES(
1655 xfer->frbuffers[0].buffer, offset);
1656 } else {
1657 /* multiple frame buffers */
1658 kaddr = xfer->frbuffers[n].buffer;
1659 }
1660
1661 /* move data */
1662 error = copyout(kaddr, uaddr, length);
1663 if (error) {
1664 goto complete;
1665 }
1666 }
1667 /*
1668 * Update offset according to initial length, which is
1669 * needed by isochronous transfers!
1670 */
1671 offset += temp;
1672
1673 /* update length */
1674 if (suword32(fs_ep.pLength + n, length) != 0)
1675 goto complete;
1676 }
1677
1678 complete:
1679 if (error == 0)
1680 error = ugen_fs_update(&fs_ep, f, ep_index);
1681 return (error);
1682 }
1683
1684 static uint8_t
ugen_fifo_in_use(struct usb_fifo * f,int fflags)1685 ugen_fifo_in_use(struct usb_fifo *f, int fflags)
1686 {
1687 struct usb_fifo *f_rx;
1688 struct usb_fifo *f_tx;
1689
1690 f_rx = f->udev->fifo[(f->fifo_index & ~1) + USB_FIFO_RX];
1691 f_tx = f->udev->fifo[(f->fifo_index & ~1) + USB_FIFO_TX];
1692
1693 if ((fflags & FREAD) && f_rx &&
1694 (f_rx->xfer[0] || f_rx->xfer[1])) {
1695 return (1); /* RX FIFO in use */
1696 }
1697 if ((fflags & FWRITE) && f_tx &&
1698 (f_tx->xfer[0] || f_tx->xfer[1])) {
1699 return (1); /* TX FIFO in use */
1700 }
1701 return (0); /* not in use */
1702 }
1703
1704 static int
ugen_ioctl(struct usb_fifo * f,u_long cmd,void * addr,int fflags)1705 ugen_ioctl(struct usb_fifo *f, u_long cmd, void *addr, int fflags)
1706 {
1707 union {
1708 struct usb_fs_complete *pcomp;
1709 struct usb_fs_start *pstart;
1710 struct usb_fs_stop *pstop;
1711 void *addr;
1712 } u;
1713 struct usb_xfer *xfer;
1714 int error;
1715 uint8_t ep_index;
1716
1717 u.addr = addr;
1718
1719 DPRINTFN(6, "cmd=0x%08lx\n", cmd);
1720
1721 switch (cmd) {
1722 case USB_FS_COMPLETE:
1723 sx_slock(&f->fs_fastpath_lock);
1724 mtx_lock(f->priv_mtx);
1725 error = ugen_fs_get_complete(f, &ep_index);
1726 mtx_unlock(f->priv_mtx);
1727
1728 if (error != 0) {
1729 error = EBUSY;
1730 } else {
1731 u.pcomp->ep_index = ep_index;
1732 error = ugen_fs_copy_out(f, u.pcomp->ep_index);
1733 }
1734 sx_sunlock(&f->fs_fastpath_lock);
1735 break;
1736
1737 case USB_FS_START:
1738 sx_slock(&f->fs_fastpath_lock);
1739 error = ugen_fs_copy_in(f, u.pstart->ep_index);
1740 if (error == 0) {
1741 mtx_lock(f->priv_mtx);
1742 xfer = f->fs_xfer[u.pstart->ep_index];
1743 usbd_transfer_start(xfer);
1744 mtx_unlock(f->priv_mtx);
1745 }
1746 sx_sunlock(&f->fs_fastpath_lock);
1747 break;
1748
1749 case USB_FS_STOP:
1750 mtx_lock(f->priv_mtx);
1751 if (u.pstop->ep_index >= f->fs_ep_max) {
1752 error = EINVAL;
1753 } else {
1754 error = 0;
1755 xfer = f->fs_xfer[u.pstart->ep_index];
1756 if (usbd_transfer_pending(xfer)) {
1757 usbd_transfer_stop(xfer);
1758
1759 /*
1760 * Check if the USB transfer was
1761 * stopped before it was even started
1762 * and fake a cancel event.
1763 */
1764 if (!xfer->flags_int.transferring &&
1765 !xfer->flags_int.started) {
1766 DPRINTF("Issuing fake completion event\n");
1767 ugen_fs_set_complete(xfer->priv_sc,
1768 USB_P2U(xfer->priv_fifo));
1769 }
1770 }
1771 }
1772 mtx_unlock(f->priv_mtx);
1773 break;
1774
1775 default:
1776 error = ENOIOCTL;
1777 break;
1778 }
1779
1780 DPRINTFN(6, "error=%d\n", error);
1781
1782 return (error);
1783 }
1784
1785 static int
ugen_set_short_xfer(struct usb_fifo * f,void * addr)1786 ugen_set_short_xfer(struct usb_fifo *f, void *addr)
1787 {
1788 uint8_t t;
1789
1790 if (*(int *)addr)
1791 t = 1;
1792 else
1793 t = 0;
1794
1795 if (f->flag_short == t) {
1796 /* same value like before - accept */
1797 return (0);
1798 }
1799 if (f->xfer[0] || f->xfer[1]) {
1800 /* cannot change this during transfer */
1801 return (EBUSY);
1802 }
1803 f->flag_short = t;
1804 return (0);
1805 }
1806
1807 static int
ugen_set_timeout(struct usb_fifo * f,void * addr)1808 ugen_set_timeout(struct usb_fifo *f, void *addr)
1809 {
1810 f->timeout = *(int *)addr;
1811 if (f->timeout > 65535) {
1812 /* limit user input */
1813 f->timeout = 65535;
1814 }
1815 return (0);
1816 }
1817
1818 static int
ugen_get_frame_size(struct usb_fifo * f,void * addr)1819 ugen_get_frame_size(struct usb_fifo *f, void *addr)
1820 {
1821 if (f->xfer[0]) {
1822 *(int *)addr = f->xfer[0]->max_frame_size;
1823 } else {
1824 return (EINVAL);
1825 }
1826 return (0);
1827 }
1828
1829 static int
ugen_set_buffer_size(struct usb_fifo * f,void * addr)1830 ugen_set_buffer_size(struct usb_fifo *f, void *addr)
1831 {
1832 usb_frlength_t t;
1833
1834 if (*(int *)addr < 0)
1835 t = 0; /* use "wMaxPacketSize" */
1836 else if (*(int *)addr < (256 * 1024))
1837 t = *(int *)addr;
1838 else
1839 t = 256 * 1024;
1840
1841 if (f->bufsize == t) {
1842 /* same value like before - accept */
1843 return (0);
1844 }
1845 if (f->xfer[0] || f->xfer[1]) {
1846 /* cannot change this during transfer */
1847 return (EBUSY);
1848 }
1849 f->bufsize = t;
1850 return (0);
1851 }
1852
1853 static int
ugen_get_buffer_size(struct usb_fifo * f,void * addr)1854 ugen_get_buffer_size(struct usb_fifo *f, void *addr)
1855 {
1856 *(int *)addr = f->bufsize;
1857 return (0);
1858 }
1859
1860 static int
ugen_get_iface_desc(struct usb_fifo * f,struct usb_interface_descriptor * idesc)1861 ugen_get_iface_desc(struct usb_fifo *f,
1862 struct usb_interface_descriptor *idesc)
1863 {
1864 struct usb_interface *iface;
1865
1866 iface = usbd_get_iface(f->udev, f->iface_index);
1867 if (iface && iface->idesc) {
1868 *idesc = *(iface->idesc);
1869 } else {
1870 return (EIO);
1871 }
1872 return (0);
1873 }
1874
1875 static int
ugen_get_endpoint_desc(struct usb_fifo * f,struct usb_endpoint_descriptor * ed)1876 ugen_get_endpoint_desc(struct usb_fifo *f,
1877 struct usb_endpoint_descriptor *ed)
1878 {
1879 struct usb_endpoint *ep;
1880
1881 ep = usb_fifo_softc(f);
1882
1883 if (ep && ep->edesc) {
1884 *ed = *ep->edesc;
1885 } else {
1886 return (EINVAL);
1887 }
1888 return (0);
1889 }
1890
1891 static int
ugen_set_power_mode(struct usb_fifo * f,int mode)1892 ugen_set_power_mode(struct usb_fifo *f, int mode)
1893 {
1894 struct usb_device *udev = f->udev;
1895 int err;
1896 uint8_t old_mode;
1897
1898 if ((udev == NULL) ||
1899 (udev->parent_hub == NULL)) {
1900 return (EINVAL);
1901 }
1902 err = priv_check(curthread, PRIV_DRIVER);
1903 if (err)
1904 return (err);
1905
1906 /* get old power mode */
1907 old_mode = udev->power_mode;
1908
1909 /* if no change, then just return */
1910 if (old_mode == mode)
1911 return (0);
1912
1913 switch (mode) {
1914 case USB_POWER_MODE_OFF:
1915 if (udev->flags.usb_mode == USB_MODE_HOST &&
1916 udev->re_enumerate_wait == USB_RE_ENUM_DONE) {
1917 udev->re_enumerate_wait = USB_RE_ENUM_PWR_OFF;
1918 }
1919 /* set power mode will wake up the explore thread */
1920 break;
1921
1922 case USB_POWER_MODE_ON:
1923 case USB_POWER_MODE_SAVE:
1924 break;
1925
1926 case USB_POWER_MODE_RESUME:
1927 #if USB_HAVE_POWERD
1928 /* let USB-powerd handle resume */
1929 USB_BUS_LOCK(udev->bus);
1930 udev->pwr_save.write_refs++;
1931 udev->pwr_save.last_xfer_time = ticks;
1932 USB_BUS_UNLOCK(udev->bus);
1933
1934 /* set new power mode */
1935 usbd_set_power_mode(udev, USB_POWER_MODE_SAVE);
1936
1937 /* wait for resume to complete */
1938 usb_pause_mtx(NULL, hz / 4);
1939
1940 /* clear write reference */
1941 USB_BUS_LOCK(udev->bus);
1942 udev->pwr_save.write_refs--;
1943 USB_BUS_UNLOCK(udev->bus);
1944 #endif
1945 mode = USB_POWER_MODE_SAVE;
1946 break;
1947
1948 case USB_POWER_MODE_SUSPEND:
1949 #if USB_HAVE_POWERD
1950 /* let USB-powerd handle suspend */
1951 USB_BUS_LOCK(udev->bus);
1952 udev->pwr_save.last_xfer_time = ticks - (256 * hz);
1953 USB_BUS_UNLOCK(udev->bus);
1954 #endif
1955 mode = USB_POWER_MODE_SAVE;
1956 break;
1957
1958 default:
1959 return (EINVAL);
1960 }
1961
1962 if (err)
1963 return (ENXIO); /* I/O failure */
1964
1965 /* if we are powered off we need to re-enumerate first */
1966 if (old_mode == USB_POWER_MODE_OFF) {
1967 if (udev->flags.usb_mode == USB_MODE_HOST &&
1968 udev->re_enumerate_wait == USB_RE_ENUM_DONE) {
1969 udev->re_enumerate_wait = USB_RE_ENUM_START;
1970 }
1971 /* set power mode will wake up the explore thread */
1972 }
1973
1974 /* set new power mode */
1975 usbd_set_power_mode(udev, mode);
1976
1977 return (0); /* success */
1978 }
1979
1980 static int
ugen_get_power_mode(struct usb_fifo * f)1981 ugen_get_power_mode(struct usb_fifo *f)
1982 {
1983 struct usb_device *udev = f->udev;
1984
1985 if (udev == NULL)
1986 return (USB_POWER_MODE_ON);
1987
1988 return (udev->power_mode);
1989 }
1990
1991 static int
ugen_get_port_path(struct usb_fifo * f,struct usb_device_port_path * dpp)1992 ugen_get_port_path(struct usb_fifo *f, struct usb_device_port_path *dpp)
1993 {
1994 struct usb_device *udev = f->udev;
1995 struct usb_device *next;
1996 unsigned nlevel = 0;
1997
1998 if (udev == NULL)
1999 goto error;
2000
2001 dpp->udp_bus = device_get_unit(udev->bus->bdev);
2002 dpp->udp_index = udev->device_index;
2003
2004 /* count port levels */
2005 next = udev;
2006 while (next->parent_hub != NULL) {
2007 nlevel++;
2008 next = next->parent_hub;
2009 }
2010
2011 /* check if too many levels */
2012 if (nlevel > USB_DEVICE_PORT_PATH_MAX)
2013 goto error;
2014
2015 /* store total level of ports */
2016 dpp->udp_port_level = nlevel;
2017
2018 /* store port index array */
2019 next = udev;
2020 while (next->parent_hub != NULL) {
2021 dpp->udp_port_no[--nlevel] = next->port_no;
2022 next = next->parent_hub;
2023 }
2024 return (0); /* success */
2025
2026 error:
2027 return (EINVAL); /* failure */
2028 }
2029
2030 static int
ugen_get_power_usage(struct usb_fifo * f)2031 ugen_get_power_usage(struct usb_fifo *f)
2032 {
2033 struct usb_device *udev = f->udev;
2034
2035 if (udev == NULL)
2036 return (0);
2037
2038 return (udev->power);
2039 }
2040
2041 static int
ugen_do_port_feature(struct usb_fifo * f,uint8_t port_no,uint8_t set,uint16_t feature)2042 ugen_do_port_feature(struct usb_fifo *f, uint8_t port_no,
2043 uint8_t set, uint16_t feature)
2044 {
2045 struct usb_device *udev = f->udev;
2046 struct usb_hub *hub;
2047 int err;
2048
2049 err = priv_check(curthread, PRIV_DRIVER);
2050 if (err) {
2051 return (err);
2052 }
2053 if (port_no == 0) {
2054 return (EINVAL);
2055 }
2056 if ((udev == NULL) ||
2057 (udev->hub == NULL)) {
2058 return (EINVAL);
2059 }
2060 hub = udev->hub;
2061
2062 if (port_no > hub->nports) {
2063 return (EINVAL);
2064 }
2065 if (set)
2066 err = usbd_req_set_port_feature(udev,
2067 NULL, port_no, feature);
2068 else
2069 err = usbd_req_clear_port_feature(udev,
2070 NULL, port_no, feature);
2071
2072 if (err)
2073 return (ENXIO); /* failure */
2074
2075 return (0); /* success */
2076 }
2077
2078 static int
ugen_iface_ioctl(struct usb_fifo * f,u_long cmd,void * addr,int fflags)2079 ugen_iface_ioctl(struct usb_fifo *f, u_long cmd, void *addr, int fflags)
2080 {
2081 struct usb_fifo *f_rx;
2082 struct usb_fifo *f_tx;
2083 int error = 0;
2084
2085 f_rx = f->udev->fifo[(f->fifo_index & ~1) + USB_FIFO_RX];
2086 f_tx = f->udev->fifo[(f->fifo_index & ~1) + USB_FIFO_TX];
2087
2088 switch (cmd) {
2089 case USB_SET_RX_SHORT_XFER:
2090 if (fflags & FREAD) {
2091 error = ugen_set_short_xfer(f_rx, addr);
2092 } else {
2093 error = EINVAL;
2094 }
2095 break;
2096
2097 case USB_SET_TX_FORCE_SHORT:
2098 if (fflags & FWRITE) {
2099 error = ugen_set_short_xfer(f_tx, addr);
2100 } else {
2101 error = EINVAL;
2102 }
2103 break;
2104
2105 case USB_SET_RX_TIMEOUT:
2106 if (fflags & FREAD) {
2107 error = ugen_set_timeout(f_rx, addr);
2108 } else {
2109 error = EINVAL;
2110 }
2111 break;
2112
2113 case USB_SET_TX_TIMEOUT:
2114 if (fflags & FWRITE) {
2115 error = ugen_set_timeout(f_tx, addr);
2116 } else {
2117 error = EINVAL;
2118 }
2119 break;
2120
2121 case USB_GET_RX_FRAME_SIZE:
2122 if (fflags & FREAD) {
2123 error = ugen_get_frame_size(f_rx, addr);
2124 } else {
2125 error = EINVAL;
2126 }
2127 break;
2128
2129 case USB_GET_TX_FRAME_SIZE:
2130 if (fflags & FWRITE) {
2131 error = ugen_get_frame_size(f_tx, addr);
2132 } else {
2133 error = EINVAL;
2134 }
2135 break;
2136
2137 case USB_SET_RX_BUFFER_SIZE:
2138 if (fflags & FREAD) {
2139 error = ugen_set_buffer_size(f_rx, addr);
2140 } else {
2141 error = EINVAL;
2142 }
2143 break;
2144
2145 case USB_SET_TX_BUFFER_SIZE:
2146 if (fflags & FWRITE) {
2147 error = ugen_set_buffer_size(f_tx, addr);
2148 } else {
2149 error = EINVAL;
2150 }
2151 break;
2152
2153 case USB_GET_RX_BUFFER_SIZE:
2154 if (fflags & FREAD) {
2155 error = ugen_get_buffer_size(f_rx, addr);
2156 } else {
2157 error = EINVAL;
2158 }
2159 break;
2160
2161 case USB_GET_TX_BUFFER_SIZE:
2162 if (fflags & FWRITE) {
2163 error = ugen_get_buffer_size(f_tx, addr);
2164 } else {
2165 error = EINVAL;
2166 }
2167 break;
2168
2169 case USB_GET_RX_INTERFACE_DESC:
2170 if (fflags & FREAD) {
2171 error = ugen_get_iface_desc(f_rx, addr);
2172 } else {
2173 error = EINVAL;
2174 }
2175 break;
2176
2177 case USB_GET_TX_INTERFACE_DESC:
2178 if (fflags & FWRITE) {
2179 error = ugen_get_iface_desc(f_tx, addr);
2180 } else {
2181 error = EINVAL;
2182 }
2183 break;
2184
2185 case USB_GET_RX_ENDPOINT_DESC:
2186 if (fflags & FREAD) {
2187 error = ugen_get_endpoint_desc(f_rx, addr);
2188 } else {
2189 error = EINVAL;
2190 }
2191 break;
2192
2193 case USB_GET_TX_ENDPOINT_DESC:
2194 if (fflags & FWRITE) {
2195 error = ugen_get_endpoint_desc(f_tx, addr);
2196 } else {
2197 error = EINVAL;
2198 }
2199 break;
2200
2201 case USB_SET_RX_STALL_FLAG:
2202 if ((fflags & FREAD) && (*(int *)addr)) {
2203 f_rx->flag_stall = 1;
2204 }
2205 break;
2206
2207 case USB_SET_TX_STALL_FLAG:
2208 if ((fflags & FWRITE) && (*(int *)addr)) {
2209 f_tx->flag_stall = 1;
2210 }
2211 break;
2212
2213 default:
2214 error = ENOIOCTL;
2215 break;
2216 }
2217 return (error);
2218 }
2219
2220 static int
ugen_ioctl_post(struct usb_fifo * f,u_long cmd,void * addr,int fflags)2221 ugen_ioctl_post(struct usb_fifo *f, u_long cmd, void *addr, int fflags)
2222 {
2223 union {
2224 struct usb_interface_descriptor *idesc;
2225 struct usb_alt_interface *ai;
2226 struct usb_device_descriptor *ddesc;
2227 struct usb_config_descriptor *cdesc;
2228 struct usb_device_stats *stat;
2229 struct usb_fs_init *pinit;
2230 #ifdef COMPAT_FREEBSD32
2231 struct usb_fs_init32 *pinit32;
2232 #endif
2233 struct usb_fs_uninit *puninit;
2234 struct usb_fs_open *popen;
2235 struct usb_fs_open_stream *popen_stream;
2236 struct usb_fs_close *pclose;
2237 struct usb_fs_clear_stall_sync *pstall;
2238 struct usb_device_port_path *dpp;
2239 uint32_t *ptime;
2240 void *addr;
2241 int *pint;
2242 } u;
2243 struct usb_device_descriptor *dtemp;
2244 struct usb_config_descriptor *ctemp;
2245 struct usb_interface *iface;
2246 int error = 0;
2247 uint8_t n;
2248
2249 u.addr = addr;
2250
2251 DPRINTFN(6, "cmd=0x%08lx\n", cmd);
2252
2253 switch (cmd) {
2254 case USB_DISCOVER:
2255 usb_needs_explore_all();
2256 break;
2257
2258 case USB_SETDEBUG:
2259 if (!(fflags & FWRITE)) {
2260 error = EPERM;
2261 break;
2262 }
2263 usb_debug = *(int *)addr;
2264 break;
2265
2266 case USB_GET_CONFIG:
2267 *(int *)addr = f->udev->curr_config_index;
2268 break;
2269
2270 case USB_SET_CONFIG:
2271 if (!(fflags & FWRITE)) {
2272 error = EPERM;
2273 break;
2274 }
2275 error = ugen_set_config(f, *(int *)addr);
2276 break;
2277
2278 case USB_GET_ALTINTERFACE:
2279 iface = usbd_get_iface(f->udev,
2280 u.ai->uai_interface_index);
2281 if (iface && iface->idesc) {
2282 u.ai->uai_alt_index = iface->alt_index;
2283 } else {
2284 error = EINVAL;
2285 }
2286 break;
2287
2288 case USB_SET_ALTINTERFACE:
2289 if (!(fflags & FWRITE)) {
2290 error = EPERM;
2291 break;
2292 }
2293 error = ugen_set_interface(f,
2294 u.ai->uai_interface_index, u.ai->uai_alt_index);
2295 break;
2296
2297 case USB_GET_DEVICE_DESC:
2298 dtemp = usbd_get_device_descriptor(f->udev);
2299 if (!dtemp) {
2300 error = EIO;
2301 break;
2302 }
2303 *u.ddesc = *dtemp;
2304 break;
2305
2306 case USB_GET_CONFIG_DESC:
2307 ctemp = usbd_get_config_descriptor(f->udev);
2308 if (!ctemp) {
2309 error = EIO;
2310 break;
2311 }
2312 *u.cdesc = *ctemp;
2313 break;
2314
2315 case USB_GET_FULL_DESC:
2316 error = ugen_get_cdesc(f, addr);
2317 break;
2318
2319 case USB_GET_STRING_DESC:
2320 error = ugen_get_sdesc(f, addr);
2321 break;
2322
2323 case USB_GET_IFACE_DRIVER:
2324 error = ugen_get_iface_driver(f, addr);
2325 break;
2326
2327 #ifdef COMPAT_FREEBSD32
2328 case USB_GET_FULL_DESC32:
2329 case USB_GET_STRING_DESC32:
2330 case USB_GET_IFACE_DRIVER32:
2331 error = ugen_get32(cmd, f, addr);
2332 break;
2333 #endif
2334
2335 case USB_REQUEST:
2336 case USB_DO_REQUEST:
2337 if (!(fflags & FWRITE)) {
2338 error = EPERM;
2339 break;
2340 }
2341 error = ugen_do_request(f, addr);
2342 break;
2343
2344 #ifdef COMPAT_FREEBSD32
2345 case USB_REQUEST32:
2346 case USB_DO_REQUEST32:
2347 if (!(fflags & FWRITE)) {
2348 error = EPERM;
2349 break;
2350 }
2351 error = ugen_do_request32(f, addr);
2352 break;
2353 #endif
2354
2355 case USB_DEVICEINFO:
2356 case USB_GET_DEVICEINFO:
2357 error = ugen_fill_deviceinfo(f, addr);
2358 break;
2359
2360 case USB_DEVICESTATS:
2361 for (n = 0; n != 4; n++) {
2362 u.stat->uds_requests_fail[n] =
2363 f->udev->stats_err.uds_requests[n];
2364 u.stat->uds_requests_ok[n] =
2365 f->udev->stats_ok.uds_requests[n];
2366 }
2367 break;
2368
2369 case USB_DEVICEENUMERATE:
2370 error = ugen_re_enumerate(f);
2371 break;
2372
2373 case USB_GET_PLUGTIME:
2374 *u.ptime = f->udev->plugtime;
2375 break;
2376
2377 case USB_CLAIM_INTERFACE:
2378 case USB_RELEASE_INTERFACE:
2379 /* TODO */
2380 break;
2381
2382 case USB_IFACE_DRIVER_ACTIVE:
2383 n = *u.pint & 0xFF;
2384 iface = usbd_get_iface(f->udev, n);
2385 if (iface != NULL && iface->subdev != NULL &&
2386 device_is_alive(iface->subdev))
2387 error = 0;
2388 else
2389 error = ENXIO;
2390 break;
2391
2392 case USB_IFACE_DRIVER_DETACH:
2393
2394 error = priv_check(curthread, PRIV_DRIVER);
2395
2396 if (error)
2397 break;
2398
2399 n = *u.pint & 0xFF;
2400
2401 if (n == USB_IFACE_INDEX_ANY) {
2402 error = EINVAL;
2403 break;
2404 }
2405
2406 /*
2407 * Detach the currently attached driver.
2408 */
2409 usb_detach_device(f->udev, n, 0);
2410
2411 /*
2412 * Set parent to self, this should keep attach away
2413 * until the next set configuration event.
2414 */
2415 usbd_set_parent_iface(f->udev, n, n);
2416 break;
2417 case USB_IFACE_DRIVER_ATTACH:
2418
2419 error = priv_check(curthread, PRIV_DRIVER);
2420
2421 if (error)
2422 break;
2423
2424 n = *u.pint & 0xFF;
2425
2426 if (n == USB_IFACE_INDEX_ANY) {
2427 error = EINVAL;
2428 break;
2429 }
2430
2431 /*
2432 * Attach the currently detached driver.
2433 */
2434 usbd_set_parent_iface(f->udev, n, USB_IFACE_INDEX_ANY);
2435
2436 usb_probe_and_attach(f->udev, n);
2437
2438 break;
2439
2440 case USB_SET_POWER_MODE:
2441 error = ugen_set_power_mode(f, *u.pint);
2442 break;
2443
2444 case USB_GET_POWER_MODE:
2445 *u.pint = ugen_get_power_mode(f);
2446 break;
2447
2448 case USB_GET_DEV_PORT_PATH:
2449 error = ugen_get_port_path(f, u.dpp);
2450 break;
2451
2452 case USB_GET_POWER_USAGE:
2453 *u.pint = ugen_get_power_usage(f);
2454 break;
2455
2456 case USB_SET_PORT_ENABLE:
2457 error = ugen_do_port_feature(f,
2458 *u.pint, 1, UHF_PORT_ENABLE);
2459 break;
2460
2461 case USB_SET_PORT_DISABLE:
2462 error = ugen_do_port_feature(f,
2463 *u.pint, 0, UHF_PORT_ENABLE);
2464 break;
2465
2466 case USB_FS_INIT:
2467 error = ugen_fs_init(f, u.pinit->pEndpoints,
2468 sizeof(struct usb_fs_endpoint), fflags,
2469 u.pinit->ep_index_max);
2470 break;
2471 #ifdef COMPAT_FREEBSD32
2472 case USB_FS_INIT32:
2473 error = ugen_fs_init(f, PTRIN(u.pinit32->pEndpoints),
2474 sizeof(struct usb_fs_endpoint32), fflags,
2475 u.pinit32->ep_index_max);
2476 break;
2477 #endif
2478 case USB_FS_UNINIT:
2479 if (u.puninit->dummy != 0) {
2480 error = EINVAL;
2481 break;
2482 }
2483 error = ugen_fs_uninit(f);
2484 break;
2485
2486 case USB_FS_OPEN:
2487 case USB_FS_OPEN_STREAM:
2488 error = usb_fs_open(f, u.popen, fflags,
2489 (cmd == USB_FS_OPEN_STREAM) ? u.popen_stream->stream_id : 0);
2490 break;
2491
2492 case USB_FS_CLOSE:
2493 error = usb_fs_close(f, u.pclose);
2494 break;
2495
2496 case USB_FS_CLEAR_STALL_SYNC:
2497 error = usb_fs_clear_stall_sync(f, u.pstall);
2498 break;
2499
2500 default:
2501 mtx_lock(f->priv_mtx);
2502 error = ugen_iface_ioctl(f, cmd, addr, fflags);
2503 mtx_unlock(f->priv_mtx);
2504 break;
2505 }
2506 DPRINTFN(6, "error=%d\n", error);
2507 return (error);
2508 }
2509
2510 static void
ugen_ctrl_fs_callback(struct usb_xfer * xfer,usb_error_t error)2511 ugen_ctrl_fs_callback(struct usb_xfer *xfer, usb_error_t error)
2512 {
2513 ; /* workaround for a bug in "indent" */
2514
2515 DPRINTF("st=%u alen=%u aframes=%u\n",
2516 USB_GET_STATE(xfer), xfer->actlen, xfer->aframes);
2517
2518 switch (USB_GET_STATE(xfer)) {
2519 case USB_ST_SETUP:
2520 usbd_transfer_submit(xfer);
2521 break;
2522 default:
2523 ugen_fs_set_complete(xfer->priv_sc, USB_P2U(xfer->priv_fifo));
2524 break;
2525 }
2526 }
2527
2528 #ifdef COMPAT_FREEBSD32
2529 void
usb_gen_descriptor_from32(struct usb_gen_descriptor * ugd,const struct usb_gen_descriptor32 * ugd32)2530 usb_gen_descriptor_from32(struct usb_gen_descriptor *ugd,
2531 const struct usb_gen_descriptor32 *ugd32)
2532 {
2533 PTRIN_CP(*ugd32, *ugd, ugd_data);
2534 CP(*ugd32, *ugd, ugd_lang_id);
2535 CP(*ugd32, *ugd, ugd_maxlen);
2536 CP(*ugd32, *ugd, ugd_actlen);
2537 CP(*ugd32, *ugd, ugd_offset);
2538 CP(*ugd32, *ugd, ugd_config_index);
2539 CP(*ugd32, *ugd, ugd_string_index);
2540 CP(*ugd32, *ugd, ugd_iface_index);
2541 CP(*ugd32, *ugd, ugd_altif_index);
2542 CP(*ugd32, *ugd, ugd_endpt_index);
2543 CP(*ugd32, *ugd, ugd_report_type);
2544 /* Don't copy reserved */
2545 }
2546
2547 void
update_usb_gen_descriptor32(struct usb_gen_descriptor32 * ugd32,struct usb_gen_descriptor * ugd)2548 update_usb_gen_descriptor32(struct usb_gen_descriptor32 *ugd32,
2549 struct usb_gen_descriptor *ugd)
2550 {
2551 /* Don't update ugd_data pointer */
2552 CP(*ugd32, *ugd, ugd_lang_id);
2553 CP(*ugd32, *ugd, ugd_maxlen);
2554 CP(*ugd32, *ugd, ugd_actlen);
2555 CP(*ugd32, *ugd, ugd_offset);
2556 CP(*ugd32, *ugd, ugd_config_index);
2557 CP(*ugd32, *ugd, ugd_string_index);
2558 CP(*ugd32, *ugd, ugd_iface_index);
2559 CP(*ugd32, *ugd, ugd_altif_index);
2560 CP(*ugd32, *ugd, ugd_endpt_index);
2561 CP(*ugd32, *ugd, ugd_report_type);
2562 /* Don't update reserved */
2563 }
2564
2565 static int
ugen_get32(u_long cmd,struct usb_fifo * f,struct usb_gen_descriptor32 * ugd32)2566 ugen_get32(u_long cmd, struct usb_fifo *f, struct usb_gen_descriptor32 *ugd32)
2567 {
2568 struct usb_gen_descriptor ugd;
2569 int error;
2570
2571 usb_gen_descriptor_from32(&ugd, ugd32);
2572 switch (cmd) {
2573 case USB_GET_FULL_DESC32:
2574 error = ugen_get_cdesc(f, &ugd);
2575 break;
2576
2577 case USB_GET_STRING_DESC32:
2578 error = ugen_get_sdesc(f, &ugd);
2579 break;
2580
2581 case USB_GET_IFACE_DRIVER32:
2582 error = ugen_get_iface_driver(f, &ugd);
2583 break;
2584 default:
2585 /* Can't happen except by programmer error */
2586 panic("%s: called with invalid cmd %lx", __func__, cmd);
2587 }
2588 update_usb_gen_descriptor32(ugd32, &ugd);
2589
2590 return (error);
2591 }
2592
2593 #endif /* COMPAT_FREEBSD32 */
2594
2595 #endif /* USB_HAVE_UGEN */
2596