110 0, "Debug level");
111#endif
112
113
114/* prototypes */
115
116static int
117ugen_transfer_setup(struct usb2_fifo *f,
118 const struct usb2_config *setup, uint8_t n_setup)
119{
120 struct usb2_pipe *pipe = f->priv_sc0;
121 struct usb2_device *udev = f->udev;
122 uint8_t iface_index = pipe->iface_index;
123 int error;
124
125 mtx_unlock(f->priv_mtx);
126
127 /*
128 * "usb2_transfer_setup()" can sleep so one needs to make a wrapper,
129 * exiting the mutex and checking things
130 */
131 error = usb2_transfer_setup(udev, &iface_index, f->xfer,
132 setup, n_setup, f, f->priv_mtx);
133 if (error == 0) {
134
135 if (f->xfer[0]->nframes == 1) {
136 error = usb2_fifo_alloc_buffer(f,
137 f->xfer[0]->max_data_length, 2);
138 } else {
139 error = usb2_fifo_alloc_buffer(f,
140 f->xfer[0]->max_frame_size,
141 2 * f->xfer[0]->nframes);
142 }
143 if (error) {
144 usb2_transfer_unsetup(f->xfer, n_setup);
145 }
146 }
147 mtx_lock(f->priv_mtx);
148
149 return (error);
150}
151
152static int
153ugen_open(struct usb2_fifo *f, int fflags)
154{
155 struct usb2_pipe *pipe = f->priv_sc0;
156 struct usb2_endpoint_descriptor *ed = pipe->edesc;
157 uint8_t type;
158
159 DPRINTFN(6, "flag=0x%x\n", fflags);
160
161 mtx_lock(f->priv_mtx);
162 switch (usb2_get_speed(f->udev)) {
163 case USB_SPEED_LOW:
164 case USB_SPEED_FULL:
165 f->nframes = UGEN_HW_FRAMES;
166 f->bufsize = UGEN_BULK_FS_BUFFER_SIZE;
167 break;
168 default:
169 f->nframes = UGEN_HW_FRAMES * 8;
170 f->bufsize = UGEN_BULK_HS_BUFFER_SIZE;
171 break;
172 }
173
174 type = ed->bmAttributes & UE_XFERTYPE;
175 if (type == UE_INTERRUPT) {
176 f->bufsize = 0; /* use "wMaxPacketSize" */
177 }
178 f->timeout = USB_NO_TIMEOUT;
179 f->flag_short = 0;
180 f->fifo_zlp = 0;
181 mtx_unlock(f->priv_mtx);
182
183 return (0);
184}
185
186static void
187ugen_close(struct usb2_fifo *f, int fflags)
188{
189 DPRINTFN(6, "flag=0x%x\n", fflags);
190
191 /* cleanup */
192
193 mtx_lock(f->priv_mtx);
194 usb2_transfer_stop(f->xfer[0]);
195 usb2_transfer_stop(f->xfer[1]);
196 mtx_unlock(f->priv_mtx);
197
198 usb2_transfer_unsetup(f->xfer, 2);
199 usb2_fifo_free_buffer(f);
200
201 if (ugen_fs_uninit(f)) {
202 /* ignore any errors - we are closing */
203 DPRINTFN(6, "no FIFOs\n");
204 }
205}
206
207static int
208ugen_open_pipe_write(struct usb2_fifo *f)
209{
210 struct usb2_config usb2_config[2];
211 struct usb2_pipe *pipe = f->priv_sc0;
212 struct usb2_endpoint_descriptor *ed = pipe->edesc;
213
214 mtx_assert(f->priv_mtx, MA_OWNED);
215
216 if (f->xfer[0] || f->xfer[1]) {
217 /* transfers are already opened */
218 return (0);
219 }
220 bzero(usb2_config, sizeof(usb2_config));
221
222 usb2_config[1].type = UE_CONTROL;
223 usb2_config[1].endpoint = 0;
224 usb2_config[1].direction = UE_DIR_ANY;
225 usb2_config[1].timeout = 1000; /* 1 second */
226 usb2_config[1].interval = 50;/* 50 milliseconds */
227 usb2_config[1].bufsize = sizeof(struct usb2_device_request);
228 usb2_config[1].callback = &ugen_write_clear_stall_callback;
229 usb2_config[1].usb_mode = USB_MODE_HOST;
230
231 usb2_config[0].type = ed->bmAttributes & UE_XFERTYPE;
232 usb2_config[0].endpoint = ed->bEndpointAddress & UE_ADDR;
233 usb2_config[0].direction = UE_DIR_TX;
234 usb2_config[0].interval = USB_DEFAULT_INTERVAL;
235 usb2_config[0].flags.proxy_buffer = 1;
236 usb2_config[0].usb_mode = USB_MODE_DUAL; /* both modes */
237
238 switch (ed->bmAttributes & UE_XFERTYPE) {
239 case UE_INTERRUPT:
240 case UE_BULK:
241 if (f->flag_short) {
242 usb2_config[0].flags.force_short_xfer = 1;
243 }
244 usb2_config[0].callback = &ugen_default_write_callback;
245 usb2_config[0].timeout = f->timeout;
246 usb2_config[0].frames = 1;
247 usb2_config[0].bufsize = f->bufsize;
248 if (ugen_transfer_setup(f, usb2_config, 2)) {
249 return (EIO);
250 }
251 /* first transfer does not clear stall */
252 f->flag_stall = 0;
253 break;
254
255 case UE_ISOCHRONOUS:
256 usb2_config[0].flags.short_xfer_ok = 1;
257 usb2_config[0].bufsize = 0; /* use default */
258 usb2_config[0].frames = f->nframes;
259 usb2_config[0].callback = &ugen_isoc_write_callback;
260 usb2_config[0].timeout = 0;
261
262 /* clone configuration */
263 usb2_config[1] = usb2_config[0];
264
265 if (ugen_transfer_setup(f, usb2_config, 2)) {
266 return (EIO);
267 }
268 break;
269 default:
270 return (EINVAL);
271 }
272 return (0);
273}
274
275static int
276ugen_open_pipe_read(struct usb2_fifo *f)
277{
278 struct usb2_config usb2_config[2];
279 struct usb2_pipe *pipe = f->priv_sc0;
280 struct usb2_endpoint_descriptor *ed = pipe->edesc;
281
282 mtx_assert(f->priv_mtx, MA_OWNED);
283
284 if (f->xfer[0] || f->xfer[1]) {
285 /* transfers are already opened */
286 return (0);
287 }
288 bzero(usb2_config, sizeof(usb2_config));
289
290 usb2_config[1].type = UE_CONTROL;
291 usb2_config[1].endpoint = 0;
292 usb2_config[1].direction = UE_DIR_ANY;
293 usb2_config[1].timeout = 1000; /* 1 second */
294 usb2_config[1].interval = 50;/* 50 milliseconds */
295 usb2_config[1].bufsize = sizeof(struct usb2_device_request);
296 usb2_config[1].callback = &ugen_read_clear_stall_callback;
297 usb2_config[1].usb_mode = USB_MODE_HOST;
298
299 usb2_config[0].type = ed->bmAttributes & UE_XFERTYPE;
300 usb2_config[0].endpoint = ed->bEndpointAddress & UE_ADDR;
301 usb2_config[0].direction = UE_DIR_RX;
302 usb2_config[0].interval = USB_DEFAULT_INTERVAL;
303 usb2_config[0].flags.proxy_buffer = 1;
304 usb2_config[0].usb_mode = USB_MODE_DUAL; /* both modes */
305
306 switch (ed->bmAttributes & UE_XFERTYPE) {
307 case UE_INTERRUPT:
308 case UE_BULK:
309 if (f->flag_short) {
310 usb2_config[0].flags.short_xfer_ok = 1;
311 }
312 usb2_config[0].timeout = f->timeout;
313 usb2_config[0].frames = 1;
314 usb2_config[0].callback = &ugen_default_read_callback;
315 usb2_config[0].bufsize = f->bufsize;
316
317 if (ugen_transfer_setup(f, usb2_config, 2)) {
318 return (EIO);
319 }
320 /* first transfer does not clear stall */
321 f->flag_stall = 0;
322 break;
323
324 case UE_ISOCHRONOUS:
325 usb2_config[0].flags.short_xfer_ok = 1;
326 usb2_config[0].bufsize = 0; /* use default */
327 usb2_config[0].frames = f->nframes;
328 usb2_config[0].callback = &ugen_isoc_read_callback;
329 usb2_config[0].timeout = 0;
330
331 /* clone configuration */
332 usb2_config[1] = usb2_config[0];
333
334 if (ugen_transfer_setup(f, usb2_config, 2)) {
335 return (EIO);
336 }
337 break;
338
339 default:
340 return (EINVAL);
341 }
342 return (0);
343}
344
345static void
346ugen_start_read(struct usb2_fifo *f)
347{
348 /* check that pipes are open */
349 if (ugen_open_pipe_read(f)) {
350 /* signal error */
351 usb2_fifo_put_data_error(f);
352 }
353 /* start transfers */
354 usb2_transfer_start(f->xfer[0]);
355 usb2_transfer_start(f->xfer[1]);
356}
357
358static void
359ugen_start_write(struct usb2_fifo *f)
360{
361 /* check that pipes are open */
362 if (ugen_open_pipe_write(f)) {
363 /* signal error */
364 usb2_fifo_get_data_error(f);
365 }
366 /* start transfers */
367 usb2_transfer_start(f->xfer[0]);
368 usb2_transfer_start(f->xfer[1]);
369}
370
371static void
372ugen_stop_io(struct usb2_fifo *f)
373{
374 /* stop transfers */
375 usb2_transfer_stop(f->xfer[0]);
376 usb2_transfer_stop(f->xfer[1]);
377}
378
379static void
380ugen_default_read_callback(struct usb2_xfer *xfer)
381{
382 struct usb2_fifo *f = xfer->priv_sc;
383 struct usb2_mbuf *m;
384
385 DPRINTFN(4, "actlen=%u, aframes=%u\n", xfer->actlen, xfer->aframes);
386
387 switch (USB_GET_STATE(xfer)) {
388 case USB_ST_TRANSFERRED:
389 if (xfer->actlen == 0) {
390 if (f->fifo_zlp != 4) {
391 f->fifo_zlp++;
392 } else {
393 /*
394 * Throttle a little bit we have multiple ZLPs
395 * in a row!
396 */
397 xfer->interval = 64; /* ms */
398 }
399 } else {
400 /* clear throttle */
401 xfer->interval = 0;
402 f->fifo_zlp = 0;
403 }
404 usb2_fifo_put_data(f, xfer->frbuffers, 0,
405 xfer->actlen, 1);
406
407 case USB_ST_SETUP:
408 if (f->flag_stall) {
409 usb2_transfer_start(f->xfer[1]);
410 break;
411 }
412 USB_IF_POLL(&f->free_q, m);
413 if (m) {
414 xfer->frlengths[0] = xfer->max_data_length;
415 usb2_start_hardware(xfer);
416 }
417 break;
418
419 default: /* Error */
420 if (xfer->error != USB_ERR_CANCELLED) {
421 /* send a zero length packet to userland */
422 usb2_fifo_put_data(f, xfer->frbuffers, 0, 0, 1);
423 f->flag_stall = 1;
424 f->fifo_zlp = 0;
425 usb2_transfer_start(f->xfer[1]);
426 }
427 break;
428 }
429}
430
431static void
432ugen_default_write_callback(struct usb2_xfer *xfer)
433{
434 struct usb2_fifo *f = xfer->priv_sc;
435 usb2_frlength_t actlen;
436
437 DPRINTFN(4, "actlen=%u, aframes=%u\n", xfer->actlen, xfer->aframes);
438
439 switch (USB_GET_STATE(xfer)) {
440 case USB_ST_SETUP:
441 case USB_ST_TRANSFERRED:
442 /*
443 * If writing is in stall, just jump to clear stall
444 * callback and solve the situation.
445 */
446 if (f->flag_stall) {
447 usb2_transfer_start(f->xfer[1]);
448 break;
449 }
450 /*
451 * Write data, setup and perform hardware transfer.
452 */
453 if (usb2_fifo_get_data(f, xfer->frbuffers, 0,
454 xfer->max_data_length, &actlen, 0)) {
455 xfer->frlengths[0] = actlen;
456 usb2_start_hardware(xfer);
457 }
458 break;
459
460 default: /* Error */
461 if (xfer->error != USB_ERR_CANCELLED) {
462 f->flag_stall = 1;
463 usb2_transfer_start(f->xfer[1]);
464 }
465 break;
466 }
467}
468
469static void
470ugen_read_clear_stall_callback(struct usb2_xfer *xfer)
471{
472 struct usb2_fifo *f = xfer->priv_sc;
473 struct usb2_xfer *xfer_other = f->xfer[0];
474
475 if (f->flag_stall == 0) {
476 /* nothing to do */
477 return;
478 }
479 if (usb2_clear_stall_callback(xfer, xfer_other)) {
480 DPRINTFN(5, "f=%p: stall cleared\n", f);
481 f->flag_stall = 0;
482 usb2_transfer_start(xfer_other);
483 }
484}
485
486static void
487ugen_write_clear_stall_callback(struct usb2_xfer *xfer)
488{
489 struct usb2_fifo *f = xfer->priv_sc;
490 struct usb2_xfer *xfer_other = f->xfer[0];
491
492 if (f->flag_stall == 0) {
493 /* nothing to do */
494 return;
495 }
496 if (usb2_clear_stall_callback(xfer, xfer_other)) {
497 DPRINTFN(5, "f=%p: stall cleared\n", f);
498 f->flag_stall = 0;
499 usb2_transfer_start(xfer_other);
500 }
501}
502
503static void
504ugen_isoc_read_callback(struct usb2_xfer *xfer)
505{
506 struct usb2_fifo *f = xfer->priv_sc;
507 usb2_frlength_t offset;
508 usb2_frcount_t n;
509
510 DPRINTFN(4, "actlen=%u, aframes=%u\n", xfer->actlen, xfer->aframes);
511
512 switch (USB_GET_STATE(xfer)) {
513 case USB_ST_TRANSFERRED:
514
515 DPRINTFN(6, "actlen=%d\n", xfer->actlen);
516
517 offset = 0;
518
519 for (n = 0; n != xfer->aframes; n++) {
520 usb2_fifo_put_data(f, xfer->frbuffers, offset,
521 xfer->frlengths[n], 1);
522 offset += xfer->max_frame_size;
523 }
524
525 case USB_ST_SETUP:
526tr_setup:
527 for (n = 0; n != xfer->nframes; n++) {
528 /* setup size for next transfer */
529 xfer->frlengths[n] = xfer->max_frame_size;
530 }
531 usb2_start_hardware(xfer);
532 break;
533
534 default: /* Error */
535 if (xfer->error == USB_ERR_CANCELLED) {
536 break;
537 }
538 goto tr_setup;
539 }
540}
541
542static void
543ugen_isoc_write_callback(struct usb2_xfer *xfer)
544{
545 struct usb2_fifo *f = xfer->priv_sc;
546 usb2_frlength_t actlen;
547 usb2_frlength_t offset;
548 usb2_frcount_t n;
549
550 DPRINTFN(4, "actlen=%u, aframes=%u\n", xfer->actlen, xfer->aframes);
551
552 switch (USB_GET_STATE(xfer)) {
553 case USB_ST_TRANSFERRED:
554 case USB_ST_SETUP:
555tr_setup:
556 offset = 0;
557 for (n = 0; n != xfer->nframes; n++) {
558 if (usb2_fifo_get_data(f, xfer->frbuffers, offset,
559 xfer->max_frame_size, &actlen, 1)) {
560 xfer->frlengths[n] = actlen;
561 offset += actlen;
562 } else {
563 break;
564 }
565 }
566
567 for (; n != xfer->nframes; n++) {
568 /* fill in zero frames */
569 xfer->frlengths[n] = 0;
570 }
571 usb2_start_hardware(xfer);
572 break;
573
574 default: /* Error */
575 if (xfer->error == USB_ERR_CANCELLED) {
576 break;
577 }
578 goto tr_setup;
579 }
580}
581
582static int
583ugen_set_config(struct usb2_fifo *f, uint8_t index)
584{
585 DPRINTFN(2, "index %u\n", index);
586
587 if (f->udev->flags.usb_mode != USB_MODE_HOST) {
588 /* not possible in device side mode */
589 return (ENOTTY);
590 }
591 if (f->udev->curr_config_index == index) {
592 /* no change needed */
593 return (0);
594 }
595 /* make sure all FIFO's are gone */
596 /* else there can be a deadlock */
597 if (ugen_fs_uninit(f)) {
598 /* ignore any errors */
599 DPRINTFN(6, "no FIFOs\n");
600 }
601 /* change setting - will free generic FIFOs, if any */
602 if (usb2_set_config_index(f->udev, index)) {
603 return (EIO);
604 }
605 /* probe and attach */
606 if (usb2_probe_and_attach(f->udev, USB_IFACE_INDEX_ANY)) {
607 return (EIO);
608 }
609 return (0);
610}
611
612static int
613ugen_set_interface(struct usb2_fifo *f,
614 uint8_t iface_index, uint8_t alt_index)
615{
616 DPRINTFN(2, "%u, %u\n", iface_index, alt_index);
617
618 if (f->udev->flags.usb_mode != USB_MODE_HOST) {
619 /* not possible in device side mode */
620 return (ENOTTY);
621 }
622 /* make sure all FIFO's are gone */
623 /* else there can be a deadlock */
624 if (ugen_fs_uninit(f)) {
625 /* ignore any errors */
626 DPRINTFN(6, "no FIFOs\n");
627 }
628 /* change setting - will free generic FIFOs, if any */
629 if (usb2_set_alt_interface_index(f->udev, iface_index, alt_index)) {
630 return (EIO);
631 }
632 /* probe and attach */
633 if (usb2_probe_and_attach(f->udev, iface_index)) {
634 return (EIO);
635 }
636 return (0);
637}
638
639/*------------------------------------------------------------------------*
640 * ugen_get_cdesc
641 *
642 * This function will retrieve the complete configuration descriptor
643 * at the given index.
644 *------------------------------------------------------------------------*/
645static int
646ugen_get_cdesc(struct usb2_fifo *f, struct usb2_gen_descriptor *ugd)
647{
648 struct usb2_config_descriptor *cdesc;
649 struct usb2_device *udev = f->udev;
650 int error;
651 uint16_t len;
652 uint8_t free_data;
653
654 DPRINTFN(6, "\n");
655
656 if (ugd->ugd_data == NULL) {
657 /* userland pointer should not be zero */
658 return (EINVAL);
659 }
660 if ((ugd->ugd_config_index == USB_UNCONFIG_INDEX) ||
661 (ugd->ugd_config_index == udev->curr_config_index)) {
662 cdesc = usb2_get_config_descriptor(udev);
663 if (cdesc == NULL) {
664 return (ENXIO);
665 }
666 free_data = 0;
667
668 } else {
669 if (usb2_req_get_config_desc_full(udev,
670 NULL, &cdesc, M_USBDEV,
671 ugd->ugd_config_index)) {
672 return (ENXIO);
673 }
674 free_data = 1;
675 }
676
677 len = UGETW(cdesc->wTotalLength);
678 if (len > ugd->ugd_maxlen) {
679 len = ugd->ugd_maxlen;
680 }
681 DPRINTFN(6, "len=%u\n", len);
682
683 ugd->ugd_actlen = len;
684 ugd->ugd_offset = 0;
685
686 error = copyout(cdesc, ugd->ugd_data, len);
687
688 if (free_data) {
689 free(cdesc, M_USBDEV);
690 }
691 return (error);
692}
693
694static int
695ugen_get_sdesc(struct usb2_fifo *f, struct usb2_gen_descriptor *ugd)
696{
697 void *ptr = f->udev->bus->scratch[0].data;
698 uint16_t size = sizeof(f->udev->bus->scratch[0].data);
699 int error;
700
701 if (usb2_req_get_string_desc(f->udev, NULL, ptr,
702 size, ugd->ugd_lang_id, ugd->ugd_string_index)) {
703 error = EINVAL;
704 } else {
705
706 if (size > ((uint8_t *)ptr)[0]) {
707 size = ((uint8_t *)ptr)[0];
708 }
709 if (size > ugd->ugd_maxlen) {
710 size = ugd->ugd_maxlen;
711 }
712 ugd->ugd_actlen = size;
713 ugd->ugd_offset = 0;
714
715 error = copyout(ptr, ugd->ugd_data, size);
716 }
717 return (error);
718}
719
720/*------------------------------------------------------------------------*
721 * ugen_get_iface_driver
722 *
723 * This function generates an USB interface description for userland.
724 *
725 * Returns:
726 * 0: Success
727 * Else: Failure
728 *------------------------------------------------------------------------*/
729static int
730ugen_get_iface_driver(struct usb2_fifo *f, struct usb2_gen_descriptor *ugd)
731{
732 struct usb2_device *udev = f->udev;
733 struct usb2_interface *iface;
734 const char *ptr;
735 const char *desc;
736 unsigned int len;
737 unsigned int maxlen;
738 char buf[128];
739 int error;
740
741 DPRINTFN(6, "\n");
742
743 if ((ugd->ugd_data == NULL) || (ugd->ugd_maxlen == 0)) {
744 /* userland pointer should not be zero */
745 return (EINVAL);
746 }
747
748 iface = usb2_get_iface(udev, ugd->ugd_iface_index);
749 if ((iface == NULL) || (iface->idesc == NULL)) {
750 /* invalid interface index */
751 return (EINVAL);
752 }
753
754 /* read out device nameunit string, if any */
755 if ((iface->subdev != NULL) &&
756 device_is_attached(iface->subdev) &&
757 (ptr = device_get_nameunit(iface->subdev)) &&
758 (desc = device_get_desc(iface->subdev))) {
759
760 /* print description */
761 snprintf(buf, sizeof(buf), "%s: <%s>", ptr, desc);
762
763 /* range checks */
764 maxlen = ugd->ugd_maxlen - 1;
765 len = strlen(buf);
766 if (len > maxlen)
767 len = maxlen;
768
769 /* update actual length, including terminating zero */
770 ugd->ugd_actlen = len + 1;
771
772 /* copy out interface description */
773 error = copyout(buf, ugd->ugd_data, ugd->ugd_actlen);
774 } else {
775 /* zero length string is default */
776 error = copyout("", ugd->ugd_data, 1);
777 }
778 return (error);
779}
780
781/*------------------------------------------------------------------------*
782 * usb2_gen_fill_deviceinfo
783 *
784 * This function dumps information about an USB device to the
785 * structure pointed to by the "di" argument.
786 *
787 * Returns:
788 * 0: Success
789 * Else: Failure
790 *------------------------------------------------------------------------*/
791static int
792usb2_gen_fill_deviceinfo(struct usb2_fifo *f, struct usb2_device_info *di)
793{
794 struct usb2_device *udev;
795 struct usb2_device *hub;
796
797 udev = f->udev;
798
799 bzero(di, sizeof(di[0]));
800
801 di->udi_bus = device_get_unit(udev->bus->bdev);
802 di->udi_addr = udev->address;
803 di->udi_index = udev->device_index;
804#if USB_HAVE_STRINGS
805 strlcpy(di->udi_serial, udev->serial,
806 sizeof(di->udi_serial));
807 strlcpy(di->udi_vendor, udev->manufacturer,
808 sizeof(di->udi_vendor));
809 strlcpy(di->udi_product, udev->product,
810 sizeof(di->udi_product));
811#endif
812 usb2_printBCD(di->udi_release, sizeof(di->udi_release),
813 UGETW(udev->ddesc.bcdDevice));
814 di->udi_vendorNo = UGETW(udev->ddesc.idVendor);
815 di->udi_productNo = UGETW(udev->ddesc.idProduct);
816 di->udi_releaseNo = UGETW(udev->ddesc.bcdDevice);
817 di->udi_class = udev->ddesc.bDeviceClass;
818 di->udi_subclass = udev->ddesc.bDeviceSubClass;
819 di->udi_protocol = udev->ddesc.bDeviceProtocol;
820 di->udi_config_no = udev->curr_config_no;
821 di->udi_config_index = udev->curr_config_index;
822 di->udi_power = udev->flags.self_powered ? 0 : udev->power;
823 di->udi_speed = udev->speed;
824 di->udi_mode = udev->flags.usb_mode;
825 di->udi_power_mode = udev->power_mode;
826 di->udi_suspended = udev->flags.peer_suspended;
827
828 hub = udev->parent_hub;
829 if (hub) {
830 di->udi_hubaddr = hub->address;
831 di->udi_hubindex = hub->device_index;
832 di->udi_hubport = udev->port_no;
833 }
834 return (0);
835}
836
837/*------------------------------------------------------------------------*
838 * ugen_check_request
839 *
840 * Return values:
841 * 0: Access allowed
842 * Else: No access
843 *------------------------------------------------------------------------*/
844static int
845ugen_check_request(struct usb2_device *udev, struct usb2_device_request *req)
846{
847 struct usb2_pipe *pipe;
848 int error;
849
850 /*
851 * Avoid requests that would damage the bus integrity:
852 */
853 if (((req->bmRequestType == UT_WRITE_DEVICE) &&
854 (req->bRequest == UR_SET_ADDRESS)) ||
855 ((req->bmRequestType == UT_WRITE_DEVICE) &&
856 (req->bRequest == UR_SET_CONFIG)) ||
857 ((req->bmRequestType == UT_WRITE_INTERFACE) &&
858 (req->bRequest == UR_SET_INTERFACE))) {
859 /*
860 * These requests can be useful for testing USB drivers.
861 */
862 error = priv_check(curthread, PRIV_DRIVER);
863 if (error) {
864 return (error);
865 }
866 }
867 /*
868 * Special case - handle clearing of stall
869 */
870 if (req->bmRequestType == UT_WRITE_ENDPOINT) {
871
872 pipe = usb2_get_pipe_by_addr(udev, req->wIndex[0]);
873 if (pipe == NULL) {
874 return (EINVAL);
875 }
876 if ((req->bRequest == UR_CLEAR_FEATURE) &&
877 (UGETW(req->wValue) == UF_ENDPOINT_HALT)) {
878 usb2_clear_data_toggle(udev, pipe);
879 }
880 }
881 /* TODO: add more checks to verify the interface index */
882
883 return (0);
884}
885
886int
887ugen_do_request(struct usb2_fifo *f, struct usb2_ctl_request *ur)
888{
889 int error;
890 uint16_t len;
891 uint16_t actlen;
892
893 if (ugen_check_request(f->udev, &ur->ucr_request)) {
894 return (EPERM);
895 }
896 len = UGETW(ur->ucr_request.wLength);
897
898 /* check if "ucr_data" is valid */
899 if (len != 0) {
900 if (ur->ucr_data == NULL) {
901 return (EFAULT);
902 }
903 }
904 /* do the USB request */
905 error = usb2_do_request_flags
906 (f->udev, NULL, &ur->ucr_request, ur->ucr_data,
907 (ur->ucr_flags & USB_SHORT_XFER_OK) |
908 USB_USER_DATA_PTR, &actlen,
909 USB_DEFAULT_TIMEOUT);
910
911 ur->ucr_actlen = actlen;
912
913 if (error) {
914 error = EIO;
915 }
916 return (error);
917}
918
919/*------------------------------------------------------------------------
920 * ugen_re_enumerate
921 *------------------------------------------------------------------------*/
922static int
923ugen_re_enumerate(struct usb2_fifo *f)
924{
925 struct usb2_device *udev = f->udev;
926 int error;
927
928 /*
929 * This request can be useful for testing USB drivers:
930 */
931 error = priv_check(curthread, PRIV_DRIVER);
932 if (error) {
933 return (error);
934 }
935 /* get the device unconfigured */
936 error = ugen_set_config(f, USB_UNCONFIG_INDEX);
937 if (error) {
938 return (error);
939 }
940 /* do a bus-reset */
941 mtx_lock(f->priv_mtx);
942 error = usb2_req_re_enumerate(udev, f->priv_mtx);
943 mtx_unlock(f->priv_mtx);
944
945 if (error) {
946 return (ENXIO);
947 }
948 /* restore configuration to index 0 */
949 error = ugen_set_config(f, 0);
950 if (error) {
951 return (error);
952 }
953 return (0);
954}
955
956int
957ugen_fs_uninit(struct usb2_fifo *f)
958{
959 if (f->fs_xfer == NULL) {
960 return (EINVAL);
961 }
962 usb2_transfer_unsetup(f->fs_xfer, f->fs_ep_max);
963 free(f->fs_xfer, M_USB);
964 f->fs_xfer = NULL;
965 f->fs_ep_max = 0;
966 f->fs_ep_ptr = NULL;
967 f->flag_iscomplete = 0;
968 usb2_fifo_free_buffer(f);
969 return (0);
970}
971
972static uint8_t
973ugen_fs_get_complete(struct usb2_fifo *f, uint8_t *pindex)
974{
975 struct usb2_mbuf *m;
976
977 USB_IF_DEQUEUE(&f->used_q, m);
978
979 if (m) {
980 *pindex = *((uint8_t *)(m->cur_data_ptr));
981
982 USB_IF_ENQUEUE(&f->free_q, m);
983
984 return (0); /* success */
985 } else {
986
987 *pindex = 0; /* fix compiler warning */
988
989 f->flag_iscomplete = 0;
990 }
991 return (1); /* failure */
992}
993
994static void
995ugen_fs_set_complete(struct usb2_fifo *f, uint8_t index)
996{
997 struct usb2_mbuf *m;
998
999 USB_IF_DEQUEUE(&f->free_q, m);
1000
1001 if (m == NULL) {
1002 /* can happen during close */
1003 DPRINTF("out of buffers\n");
1004 return;
1005 }
1006 USB_MBUF_RESET(m);
1007
1008 *((uint8_t *)(m->cur_data_ptr)) = index;
1009
1010 USB_IF_ENQUEUE(&f->used_q, m);
1011
1012 f->flag_iscomplete = 1;
1013
1014 usb2_fifo_wakeup(f);
1015}
1016
1017static int
1018ugen_fs_copy_in(struct usb2_fifo *f, uint8_t ep_index)
1019{
1020 struct usb2_device_request *req;
1021 struct usb2_xfer *xfer;
1022 struct usb2_fs_endpoint fs_ep;
1023 void *uaddr; /* userland pointer */
1024 void *kaddr;
1025 usb2_frlength_t offset;
1026 usb2_frlength_t rem;
1027 usb2_frcount_t n;
1028 uint32_t length;
1029 int error;
1030 uint8_t isread;
1031
1032 if (ep_index >= f->fs_ep_max) {
1033 return (EINVAL);
1034 }
1035 xfer = f->fs_xfer[ep_index];
1036 if (xfer == NULL) {
1037 return (EINVAL);
1038 }
1039 mtx_lock(f->priv_mtx);
1040 if (usb2_transfer_pending(xfer)) {
1041 mtx_unlock(f->priv_mtx);
1042 return (EBUSY); /* should not happen */
1043 }
1044 mtx_unlock(f->priv_mtx);
1045
1046 error = copyin(f->fs_ep_ptr +
1047 ep_index, &fs_ep, sizeof(fs_ep));
1048 if (error) {
1049 return (error);
1050 }
1051 /* security checks */
1052
1053 if (fs_ep.nFrames > xfer->max_frame_count) {
1054 xfer->error = USB_ERR_INVAL;
1055 goto complete;
1056 }
1057 if (fs_ep.nFrames == 0) {
1058 xfer->error = USB_ERR_INVAL;
1059 goto complete;
1060 }
1061 error = copyin(fs_ep.ppBuffer,
1062 &uaddr, sizeof(uaddr));
1063 if (error) {
1064 return (error);
1065 }
1066 /* reset first frame */
1067 usb2_set_frame_offset(xfer, 0, 0);
1068
1069 if (xfer->flags_int.control_xfr) {
1070
1071 req = xfer->frbuffers[0].buffer;
1072
1073 error = copyin(fs_ep.pLength,
1074 &length, sizeof(length));
1075 if (error) {
1076 return (error);
1077 }
1078 if (length >= sizeof(*req)) {
1079 xfer->error = USB_ERR_INVAL;
1080 goto complete;
1081 }
1082 if (length != 0) {
1083 error = copyin(uaddr, req, length);
1084 if (error) {
1085 return (error);
1086 }
1087 }
1088 if (ugen_check_request(f->udev, req)) {
1089 xfer->error = USB_ERR_INVAL;
1090 goto complete;
1091 }
1092 xfer->frlengths[0] = length;
1093
1094 /* Host mode only ! */
1095 if ((req->bmRequestType &
1096 (UT_READ | UT_WRITE)) == UT_READ) {
1097 isread = 1;
1098 } else {
1099 isread = 0;
1100 }
1101 n = 1;
1102 offset = sizeof(*req);
1103
1104 } else {
1105 /* Device and Host mode */
1106 if (USB_GET_DATA_ISREAD(xfer)) {
1107 isread = 1;
1108 } else {
1109 isread = 0;
1110 }
1111 n = 0;
1112 offset = 0;
1113 }
1114
1115 rem = xfer->max_data_length;
1116 xfer->nframes = fs_ep.nFrames;
1117 xfer->timeout = fs_ep.timeout;
1118 if (xfer->timeout > 65535) {
1119 xfer->timeout = 65535;
1120 }
1121 if (fs_ep.flags & USB_FS_FLAG_SINGLE_SHORT_OK)
1122 xfer->flags.short_xfer_ok = 1;
1123 else
1124 xfer->flags.short_xfer_ok = 0;
1125
1126 if (fs_ep.flags & USB_FS_FLAG_MULTI_SHORT_OK)
1127 xfer->flags.short_frames_ok = 1;
1128 else
1129 xfer->flags.short_frames_ok = 0;
1130
1131 if (fs_ep.flags & USB_FS_FLAG_FORCE_SHORT)
1132 xfer->flags.force_short_xfer = 1;
1133 else
1134 xfer->flags.force_short_xfer = 0;
1135
1136 if (fs_ep.flags & USB_FS_FLAG_CLEAR_STALL)
1137 xfer->flags.stall_pipe = 1;
1138 else
1139 xfer->flags.stall_pipe = 0;
1140
1141 for (; n != xfer->nframes; n++) {
1142
1143 error = copyin(fs_ep.pLength + n,
1144 &length, sizeof(length));
1145 if (error) {
1146 break;
1147 }
1148 xfer->frlengths[n] = length;
1149
1150 if (length > rem) {
1151 xfer->error = USB_ERR_INVAL;
1152 goto complete;
1153 }
1154 rem -= length;
1155
1156 if (!isread) {
1157
1158 /* we need to know the source buffer */
1159 error = copyin(fs_ep.ppBuffer + n,
1160 &uaddr, sizeof(uaddr));
1161 if (error) {
1162 break;
1163 }
1164 if (xfer->flags_int.isochronous_xfr) {
1165 /* get kernel buffer address */
1166 kaddr = xfer->frbuffers[0].buffer;
1167 kaddr = USB_ADD_BYTES(kaddr, offset);
1168 } else {
1169 /* set current frame offset */
1170 usb2_set_frame_offset(xfer, offset, n);
1171
1172 /* get kernel buffer address */
1173 kaddr = xfer->frbuffers[n].buffer;
1174 }
1175
1176 /* move data */
1177 error = copyin(uaddr, kaddr, length);
1178 if (error) {
1179 break;
1180 }
1181 }
1182 offset += length;
1183 }
1184 return (error);
1185
1186complete:
1187 mtx_lock(f->priv_mtx);
1188 ugen_fs_set_complete(f, ep_index);
1189 mtx_unlock(f->priv_mtx);
1190 return (0);
1191}
1192
1193static int
1194ugen_fs_copy_out(struct usb2_fifo *f, uint8_t ep_index)
1195{
1196 struct usb2_device_request *req;
1197 struct usb2_xfer *xfer;
1198 struct usb2_fs_endpoint fs_ep;
1199 struct usb2_fs_endpoint *fs_ep_uptr; /* userland ptr */
1200 void *uaddr; /* userland ptr */
1201 void *kaddr;
1202 usb2_frlength_t offset;
1203 usb2_frlength_t rem;
1204 usb2_frcount_t n;
1205 uint32_t length;
1206 uint32_t temp;
1207 int error;
1208 uint8_t isread;
1209
1210 if (ep_index >= f->fs_ep_max)
1211 return (EINVAL);
1212
1213 xfer = f->fs_xfer[ep_index];
1214 if (xfer == NULL)
1215 return (EINVAL);
1216
1217 mtx_lock(f->priv_mtx);
1218 if (usb2_transfer_pending(xfer)) {
1219 mtx_unlock(f->priv_mtx);
1220 return (EBUSY); /* should not happen */
1221 }
1222 mtx_unlock(f->priv_mtx);
1223
1224 fs_ep_uptr = f->fs_ep_ptr + ep_index;
1225 error = copyin(fs_ep_uptr, &fs_ep, sizeof(fs_ep));
1226 if (error) {
1227 return (error);
1228 }
1229 fs_ep.status = xfer->error;
1230 fs_ep.aFrames = xfer->aframes;
1231 fs_ep.isoc_time_complete = xfer->isoc_time_complete;
1232 if (xfer->error) {
1233 goto complete;
1234 }
1235 if (xfer->flags_int.control_xfr) {
1236 req = xfer->frbuffers[0].buffer;
1237
1238 /* Host mode only ! */
1239 if ((req->bmRequestType & (UT_READ | UT_WRITE)) == UT_READ) {
1240 isread = 1;
1241 } else {
1242 isread = 0;
1243 }
1244 if (xfer->nframes == 0)
1245 n = 0; /* should never happen */
1246 else
1247 n = 1;
1248 } else {
1249 /* Device and Host mode */
1250 if (USB_GET_DATA_ISREAD(xfer)) {
1251 isread = 1;
1252 } else {
1253 isread = 0;
1254 }
1255 n = 0;
1256 }
1257
1258 /* Update lengths and copy out data */
1259
1260 rem = xfer->max_data_length;
1261 offset = 0;
1262
1263 for (; n != xfer->nframes; n++) {
1264
1265 /* get initial length into "temp" */
1266 error = copyin(fs_ep.pLength + n,
1267 &temp, sizeof(temp));
1268 if (error) {
1269 return (error);
1270 }
1271 if (temp > rem) {
1272 /* the userland length has been corrupted */
1273 DPRINTF("corrupt userland length "
1274 "%u > %u\n", temp, rem);
1275 fs_ep.status = USB_ERR_INVAL;
1276 goto complete;
1277 }
1278 rem -= temp;
1279
1280 /* get actual transfer length */
1281 length = xfer->frlengths[n];
1282 if (length > temp) {
1283 /* data overflow */
1284 fs_ep.status = USB_ERR_INVAL;
1285 DPRINTF("data overflow %u > %u\n",
1286 length, temp);
1287 goto complete;
1288 }
1289 if (isread) {
1290
1291 /* we need to know the destination buffer */
1292 error = copyin(fs_ep.ppBuffer + n,
1293 &uaddr, sizeof(uaddr));
1294 if (error) {
1295 return (error);
1296 }
1297 if (xfer->flags_int.isochronous_xfr) {
1298 /* only one frame buffer */
1299 kaddr = USB_ADD_BYTES(
1300 xfer->frbuffers[0].buffer, offset);
1301 } else {
1302 /* multiple frame buffers */
1303 kaddr = xfer->frbuffers[n].buffer;
1304 }
1305
1306 /* move data */
1307 error = copyout(kaddr, uaddr, length);
1308 if (error) {
1309 return (error);
1310 }
1311 }
1312 /*
1313 * Update offset according to initial length, which is
1314 * needed by isochronous transfers!
1315 */
1316 offset += temp;
1317
1318 /* update length */
1319 error = copyout(&length,
1320 fs_ep.pLength + n, sizeof(length));
1321 if (error) {
1322 return (error);
1323 }
1324 }
1325
1326complete:
1327 /* update "aFrames" */
1328 error = copyout(&fs_ep.aFrames, &fs_ep_uptr->aFrames,
1329 sizeof(fs_ep.aFrames));
1330 if (error)
1331 goto done;
1332
1333 /* update "isoc_time_complete" */
1334 error = copyout(&fs_ep.isoc_time_complete,
1335 &fs_ep_uptr->isoc_time_complete,
1336 sizeof(fs_ep.isoc_time_complete));
1337 if (error)
1338 goto done;
1339 /* update "status" */
1340 error = copyout(&fs_ep.status, &fs_ep_uptr->status,
1341 sizeof(fs_ep.status));
1342done:
1343 return (error);
1344}
1345
1346static uint8_t
1347ugen_fifo_in_use(struct usb2_fifo *f, int fflags)
1348{
1349 struct usb2_fifo *f_rx;
1350 struct usb2_fifo *f_tx;
1351
1352 f_rx = f->udev->fifo[(f->fifo_index & ~1) + USB_FIFO_RX];
1353 f_tx = f->udev->fifo[(f->fifo_index & ~1) + USB_FIFO_TX];
1354
1355 if ((fflags & FREAD) && f_rx &&
1356 (f_rx->xfer[0] || f_rx->xfer[1])) {
1357 return (1); /* RX FIFO in use */
1358 }
1359 if ((fflags & FWRITE) && f_tx &&
1360 (f_tx->xfer[0] || f_tx->xfer[1])) {
1361 return (1); /* TX FIFO in use */
1362 }
1363 return (0); /* not in use */
1364}
1365
1366static int
1367ugen_ioctl(struct usb2_fifo *f, u_long cmd, void *addr, int fflags)
1368{
1369 struct usb2_config usb2_config[1];
1370 struct usb2_device_request req;
1371 union {
1372 struct usb2_fs_complete *pcomp;
1373 struct usb2_fs_start *pstart;
1374 struct usb2_fs_stop *pstop;
1375 struct usb2_fs_open *popen;
1376 struct usb2_fs_close *pclose;
1377 struct usb2_fs_clear_stall_sync *pstall;
1378 void *addr;
1379 } u;
1380 struct usb2_pipe *pipe;
1381 struct usb2_endpoint_descriptor *ed;
1382 int error = 0;
1383 uint8_t iface_index;
1384 uint8_t isread;
1385 uint8_t ep_index;
1386
1387 u.addr = addr;
1388
1389 DPRINTFN(6, "cmd=0x%08lx\n", cmd);
1390
1391 switch (cmd) {
1392 case USB_FS_COMPLETE:
1393 mtx_lock(f->priv_mtx);
1394 error = ugen_fs_get_complete(f, &ep_index);
1395 mtx_unlock(f->priv_mtx);
1396
1397 if (error) {
1398 error = EBUSY;
1399 break;
1400 }
1401 u.pcomp->ep_index = ep_index;
1402 error = ugen_fs_copy_out(f, u.pcomp->ep_index);
1403 break;
1404
1405 case USB_FS_START:
1406 error = ugen_fs_copy_in(f, u.pstart->ep_index);
1407 if (error) {
1408 break;
1409 }
1410 mtx_lock(f->priv_mtx);
1411 usb2_transfer_start(f->fs_xfer[u.pstart->ep_index]);
1412 mtx_unlock(f->priv_mtx);
1413 break;
1414
1415 case USB_FS_STOP:
1416 if (u.pstop->ep_index >= f->fs_ep_max) {
1417 error = EINVAL;
1418 break;
1419 }
1420 mtx_lock(f->priv_mtx);
1421 usb2_transfer_stop(f->fs_xfer[u.pstop->ep_index]);
1422 mtx_unlock(f->priv_mtx);
1423 break;
1424
1425 case USB_FS_OPEN:
1426 if (u.popen->ep_index >= f->fs_ep_max) {
1427 error = EINVAL;
1428 break;
1429 }
1430 if (f->fs_xfer[u.popen->ep_index] != NULL) {
1431 error = EBUSY;
1432 break;
1433 }
1434 if (u.popen->max_bufsize > USB_FS_MAX_BUFSIZE) {
1435 u.popen->max_bufsize = USB_FS_MAX_BUFSIZE;
1436 }
1437 if (u.popen->max_frames > USB_FS_MAX_FRAMES) {
1438 u.popen->max_frames = USB_FS_MAX_FRAMES;
1439 break;
1440 }
1441 if (u.popen->max_frames == 0) {
1442 error = EINVAL;
1443 break;
1444 }
1445 pipe = usb2_get_pipe_by_addr(f->udev, u.popen->ep_no);
1446 if (pipe == NULL) {
1447 error = EINVAL;
1448 break;
1449 }
1450 ed = pipe->edesc;
1451 if (ed == NULL) {
1452 error = ENXIO;
1453 break;
1454 }
1455 iface_index = pipe->iface_index;
1456
1457 bzero(usb2_config, sizeof(usb2_config));
1458
1459 usb2_config[0].type = ed->bmAttributes & UE_XFERTYPE;
1460 usb2_config[0].endpoint = ed->bEndpointAddress & UE_ADDR;
1461 usb2_config[0].direction = ed->bEndpointAddress & (UE_DIR_OUT | UE_DIR_IN);
1462 usb2_config[0].interval = USB_DEFAULT_INTERVAL;
1463 usb2_config[0].flags.proxy_buffer = 1;
1464 usb2_config[0].callback = &ugen_default_fs_callback;
1465 usb2_config[0].timeout = 0; /* no timeout */
1466 usb2_config[0].frames = u.popen->max_frames;
1467 usb2_config[0].bufsize = u.popen->max_bufsize;
1468 usb2_config[0].usb_mode = USB_MODE_DUAL; /* both modes */
1469
1470 if (usb2_config[0].type == UE_CONTROL) {
1471 if (f->udev->flags.usb_mode != USB_MODE_HOST) {
1472 error = EINVAL;
1473 break;
1474 }
1475 } else {
1476
1477 isread = ((usb2_config[0].endpoint &
1478 (UE_DIR_IN | UE_DIR_OUT)) == UE_DIR_IN);
1479
1480 if (f->udev->flags.usb_mode != USB_MODE_HOST) {
1481 isread = !isread;
1482 }
1483 /* check permissions */
1484 if (isread) {
1485 if (!(fflags & FREAD)) {
1486 error = EPERM;
1487 break;
1488 }
1489 } else {
1490 if (!(fflags & FWRITE)) {
1491 error = EPERM;
1492 break;
1493 }
1494 }
1495 }
1496 error = usb2_transfer_setup(f->udev, &iface_index,
1497 f->fs_xfer + u.popen->ep_index, usb2_config, 1,
1498 f, f->priv_mtx);
1499 if (error == 0) {
1500 /* update maximums */
1501 u.popen->max_packet_length =
1502 f->fs_xfer[u.popen->ep_index]->max_frame_size;
1503 u.popen->max_bufsize =
1504 f->fs_xfer[u.popen->ep_index]->max_data_length;
1505 f->fs_xfer[u.popen->ep_index]->priv_fifo =
1506 ((uint8_t *)0) + u.popen->ep_index;
1507 } else {
1508 error = ENOMEM;
1509 }
1510 break;
1511
1512 case USB_FS_CLOSE:
1513 if (u.pclose->ep_index >= f->fs_ep_max) {
1514 error = EINVAL;
1515 break;
1516 }
1517 if (f->fs_xfer[u.pclose->ep_index] == NULL) {
1518 error = EINVAL;
1519 break;
1520 }
1521 usb2_transfer_unsetup(f->fs_xfer + u.pclose->ep_index, 1);
1522 break;
1523
1524 case USB_FS_CLEAR_STALL_SYNC:
1525 if (u.pstall->ep_index >= f->fs_ep_max) {
1526 error = EINVAL;
1527 break;
1528 }
1529 if (f->fs_xfer[u.pstall->ep_index] == NULL) {
1530 error = EINVAL;
1531 break;
1532 }
1533 if (f->udev->flags.usb_mode != USB_MODE_HOST) {
1534 error = EINVAL;
1535 break;
1536 }
1537 mtx_lock(f->priv_mtx);
1538 error = usb2_transfer_pending(f->fs_xfer[u.pstall->ep_index]);
1539 mtx_unlock(f->priv_mtx);
1540
1541 if (error) {
1542 return (EBUSY);
1543 }
1544 pipe = f->fs_xfer[u.pstall->ep_index]->pipe;
1545
1546 /* setup a clear-stall packet */
1547 req.bmRequestType = UT_WRITE_ENDPOINT;
1548 req.bRequest = UR_CLEAR_FEATURE;
1549 USETW(req.wValue, UF_ENDPOINT_HALT);
1550 req.wIndex[0] = pipe->edesc->bEndpointAddress;
1551 req.wIndex[1] = 0;
1552 USETW(req.wLength, 0);
1553
1554 error = usb2_do_request(f->udev, NULL, &req, NULL);
1555 if (error == 0) {
1556 usb2_clear_data_toggle(f->udev, pipe);
1557 } else {
1558 error = ENXIO;
1559 }
1560 break;
1561
1562 default:
1563 error = ENOIOCTL;
1564 break;
1565 }
1566
1567 DPRINTFN(6, "error=%d\n", error);
1568
1569 return (error);
1570}
1571
1572static int
1573ugen_set_short_xfer(struct usb2_fifo *f, void *addr)
1574{
1575 uint8_t t;
1576
1577 if (*(int *)addr)
1578 t = 1;
1579 else
1580 t = 0;
1581
1582 if (f->flag_short == t) {
1583 /* same value like before - accept */
1584 return (0);
1585 }
1586 if (f->xfer[0] || f->xfer[1]) {
1587 /* cannot change this during transfer */
1588 return (EBUSY);
1589 }
1590 f->flag_short = t;
1591 return (0);
1592}
1593
1594static int
1595ugen_set_timeout(struct usb2_fifo *f, void *addr)
1596{
1597 f->timeout = *(int *)addr;
1598 if (f->timeout > 65535) {
1599 /* limit user input */
1600 f->timeout = 65535;
1601 }
1602 return (0);
1603}
1604
1605static int
1606ugen_get_frame_size(struct usb2_fifo *f, void *addr)
1607{
1608 if (f->xfer[0]) {
1609 *(int *)addr = f->xfer[0]->max_frame_size;
1610 } else {
1611 return (EINVAL);
1612 }
1613 return (0);
1614}
1615
1616static int
1617ugen_set_buffer_size(struct usb2_fifo *f, void *addr)
1618{
1619 usb2_frlength_t t;
1620
1621 if (*(int *)addr < 0)
1622 t = 0; /* use "wMaxPacketSize" */
1623 else if (*(int *)addr < (256 * 1024))
1624 t = *(int *)addr;
1625 else
1626 t = 256 * 1024;
1627
1628 if (f->bufsize == t) {
1629 /* same value like before - accept */
1630 return (0);
1631 }
1632 if (f->xfer[0] || f->xfer[1]) {
1633 /* cannot change this during transfer */
1634 return (EBUSY);
1635 }
1636 f->bufsize = t;
1637 return (0);
1638}
1639
1640static int
1641ugen_get_buffer_size(struct usb2_fifo *f, void *addr)
1642{
1643 *(int *)addr = f->bufsize;
1644 return (0);
1645}
1646
1647static int
1648ugen_get_iface_desc(struct usb2_fifo *f,
1649 struct usb2_interface_descriptor *idesc)
1650{
1651 struct usb2_interface *iface;
1652
1653 iface = usb2_get_iface(f->udev, f->iface_index);
1654 if (iface && iface->idesc) {
1655 *idesc = *(iface->idesc);
1656 } else {
1657 return (EIO);
1658 }
1659 return (0);
1660}
1661
1662static int
1663ugen_get_endpoint_desc(struct usb2_fifo *f,
1664 struct usb2_endpoint_descriptor *ed)
1665{
1666 struct usb2_pipe *pipe;
1667
1668 pipe = f->priv_sc0;
1669
1670 if (pipe && pipe->edesc) {
1671 *ed = *pipe->edesc;
1672 } else {
1673 return (EINVAL);
1674 }
1675 return (0);
1676}
1677
1678static int
1679ugen_set_power_mode(struct usb2_fifo *f, int mode)
1680{
1681 struct usb2_device *udev = f->udev;
1682 int err;
1683 uint8_t old_mode;
1684
1685 if ((udev == NULL) ||
1686 (udev->parent_hub == NULL)) {
1687 return (EINVAL);
1688 }
1689 err = priv_check(curthread, PRIV_DRIVER);
1690 if (err)
1691 return (err);
1692
1693 /* get old power mode */
1694 old_mode = udev->power_mode;
1695
1696 /* if no change, then just return */
1697 if (old_mode == mode)
1698 return (0);
1699
1700 switch (mode) {
1701 case USB_POWER_MODE_OFF:
1702 /* get the device unconfigured */
1703 err = ugen_set_config(f, USB_UNCONFIG_INDEX);
1704 if (err) {
1705 DPRINTFN(0, "Could not unconfigure "
1706 "device (ignored)\n");
1707 }
1708
1709 /* clear port enable */
1710 err = usb2_req_clear_port_feature(udev->parent_hub,
1711 NULL, udev->port_no, UHF_PORT_ENABLE);
1712 break;
1713
1714 case USB_POWER_MODE_ON:
1715 case USB_POWER_MODE_SAVE:
1716 break;
1717
1718 case USB_POWER_MODE_RESUME:
1719 err = usb2_req_clear_port_feature(udev->parent_hub,
1720 NULL, udev->port_no, UHF_PORT_SUSPEND);
1721 mode = USB_POWER_MODE_SAVE;
1722 break;
1723
1724 case USB_POWER_MODE_SUSPEND:
1725 err = usb2_req_set_port_feature(udev->parent_hub,
1726 NULL, udev->port_no, UHF_PORT_SUSPEND);
1727 mode = USB_POWER_MODE_SAVE;
1728 break;
1729
1730 default:
1731 return (EINVAL);
1732 }
1733
1734 if (err)
1735 return (ENXIO); /* I/O failure */
1736
1737 /* if we are powered off we need to re-enumerate first */
1738 if (old_mode == USB_POWER_MODE_OFF) {
1739 err = ugen_re_enumerate(f);
1740 if (err)
1741 return (err);
1742 }
1743
1744 /* set new power mode */
1745 usb2_set_power_mode(udev, mode);
1746
1747 return (0); /* success */
1748}
1749
1750static int
1751ugen_get_power_mode(struct usb2_fifo *f)
1752{
1753 struct usb2_device *udev = f->udev;
1754
1755 if ((udev == NULL) ||
1756 (udev->parent_hub == NULL)) {
1757 return (USB_POWER_MODE_ON);
1758 }
1759 return (udev->power_mode);
1760}
1761
1762static int
1763ugen_do_port_feature(struct usb2_fifo *f, uint8_t port_no,
1764 uint8_t set, uint16_t feature)
1765{
1766 struct usb2_device *udev = f->udev;
1767 struct usb2_hub *hub;
1768 int err;
1769
1770 err = priv_check(curthread, PRIV_DRIVER);
1771 if (err) {
1772 return (err);
1773 }
1774 if (port_no == 0) {
1775 return (EINVAL);
1776 }
1777 if ((udev == NULL) ||
1778 (udev->hub == NULL)) {
1779 return (EINVAL);
1780 }
1781 hub = udev->hub;
1782
1783 if (port_no > hub->nports) {
1784 return (EINVAL);
1785 }
1786 if (set)
1787 err = usb2_req_set_port_feature(udev,
1788 NULL, port_no, feature);
1789 else
1790 err = usb2_req_clear_port_feature(udev,
1791 NULL, port_no, feature);
1792
1793 if (err)
1794 return (ENXIO); /* failure */
1795
1796 return (0); /* success */
1797}
1798
1799static int
1800ugen_iface_ioctl(struct usb2_fifo *f, u_long cmd, void *addr, int fflags)
1801{
1802 struct usb2_fifo *f_rx;
1803 struct usb2_fifo *f_tx;
1804 int error = 0;
1805
1806 f_rx = f->udev->fifo[(f->fifo_index & ~1) + USB_FIFO_RX];
1807 f_tx = f->udev->fifo[(f->fifo_index & ~1) + USB_FIFO_TX];
1808
1809 switch (cmd) {
1810 case USB_SET_RX_SHORT_XFER:
1811 if (fflags & FREAD) {
1812 error = ugen_set_short_xfer(f_rx, addr);
1813 } else {
1814 error = EINVAL;
1815 }
1816 break;
1817
1818 case USB_SET_TX_FORCE_SHORT:
1819 if (fflags & FWRITE) {
1820 error = ugen_set_short_xfer(f_tx, addr);
1821 } else {
1822 error = EINVAL;
1823 }
1824 break;
1825
1826 case USB_SET_RX_TIMEOUT:
1827 if (fflags & FREAD) {
1828 error = ugen_set_timeout(f_rx, addr);
1829 } else {
1830 error = EINVAL;
1831 }
1832 break;
1833
1834 case USB_SET_TX_TIMEOUT:
1835 if (fflags & FWRITE) {
1836 error = ugen_set_timeout(f_tx, addr);
1837 } else {
1838 error = EINVAL;
1839 }
1840 break;
1841
1842 case USB_GET_RX_FRAME_SIZE:
1843 if (fflags & FREAD) {
1844 error = ugen_get_frame_size(f_rx, addr);
1845 } else {
1846 error = EINVAL;
1847 }
1848 break;
1849
1850 case USB_GET_TX_FRAME_SIZE:
1851 if (fflags & FWRITE) {
1852 error = ugen_get_frame_size(f_tx, addr);
1853 } else {
1854 error = EINVAL;
1855 }
1856 break;
1857
1858 case USB_SET_RX_BUFFER_SIZE:
1859 if (fflags & FREAD) {
1860 error = ugen_set_buffer_size(f_rx, addr);
1861 } else {
1862 error = EINVAL;
1863 }
1864 break;
1865
1866 case USB_SET_TX_BUFFER_SIZE:
1867 if (fflags & FWRITE) {
1868 error = ugen_set_buffer_size(f_tx, addr);
1869 } else {
1870 error = EINVAL;
1871 }
1872 break;
1873
1874 case USB_GET_RX_BUFFER_SIZE:
1875 if (fflags & FREAD) {
1876 error = ugen_get_buffer_size(f_rx, addr);
1877 } else {
1878 error = EINVAL;
1879 }
1880 break;
1881
1882 case USB_GET_TX_BUFFER_SIZE:
1883 if (fflags & FWRITE) {
1884 error = ugen_get_buffer_size(f_tx, addr);
1885 } else {
1886 error = EINVAL;
1887 }
1888 break;
1889
1890 case USB_GET_RX_INTERFACE_DESC:
1891 if (fflags & FREAD) {
1892 error = ugen_get_iface_desc(f_rx, addr);
1893 } else {
1894 error = EINVAL;
1895 }
1896 break;
1897
1898 case USB_GET_TX_INTERFACE_DESC:
1899 if (fflags & FWRITE) {
1900 error = ugen_get_iface_desc(f_tx, addr);
1901 } else {
1902 error = EINVAL;
1903 }
1904 break;
1905
1906 case USB_GET_RX_ENDPOINT_DESC:
1907 if (fflags & FREAD) {
1908 error = ugen_get_endpoint_desc(f_rx, addr);
1909 } else {
1910 error = EINVAL;
1911 }
1912 break;
1913
1914 case USB_GET_TX_ENDPOINT_DESC:
1915 if (fflags & FWRITE) {
1916 error = ugen_get_endpoint_desc(f_tx, addr);
1917 } else {
1918 error = EINVAL;
1919 }
1920 break;
1921
1922 case USB_SET_RX_STALL_FLAG:
1923 if ((fflags & FREAD) && (*(int *)addr)) {
1924 f_rx->flag_stall = 1;
1925 }
1926 break;
1927
1928 case USB_SET_TX_STALL_FLAG:
1929 if ((fflags & FWRITE) && (*(int *)addr)) {
1930 f_tx->flag_stall = 1;
1931 }
1932 break;
1933
1934 default:
1935 error = ENOIOCTL;
1936 break;
1937 }
1938 return (error);
1939}
1940
1941static int
1942ugen_ioctl_post(struct usb2_fifo *f, u_long cmd, void *addr, int fflags)
1943{
1944 union {
1945 struct usb2_interface_descriptor *idesc;
1946 struct usb2_alt_interface *ai;
1947 struct usb2_device_descriptor *ddesc;
1948 struct usb2_config_descriptor *cdesc;
1949 struct usb2_device_stats *stat;
1950 struct usb2_fs_init *pinit;
1951 struct usb2_fs_uninit *puninit;
1952 uint32_t *ptime;
1953 void *addr;
1954 int *pint;
1955 } u;
1956 struct usb2_device_descriptor *dtemp;
1957 struct usb2_config_descriptor *ctemp;
1958 struct usb2_interface *iface;
1959 int error = 0;
1960 uint8_t n;
1961
1962 u.addr = addr;
1963
1964 DPRINTFN(6, "cmd=0x%08lx\n", cmd);
1965
1966 switch (cmd) {
1967 case USB_DISCOVER:
1968 usb2_needs_explore_all();
1969 break;
1970
1971 case USB_SETDEBUG:
1972 if (!(fflags & FWRITE)) {
1973 error = EPERM;
1974 break;
1975 }
1976 usb2_debug = *(int *)addr;
1977 break;
1978
1979 case USB_GET_CONFIG:
1980 *(int *)addr = f->udev->curr_config_index;
1981 break;
1982
1983 case USB_SET_CONFIG:
1984 if (!(fflags & FWRITE)) {
1985 error = EPERM;
1986 break;
1987 }
1988 error = ugen_set_config(f, *(int *)addr);
1989 break;
1990
1991 case USB_GET_ALTINTERFACE:
1992 iface = usb2_get_iface(f->udev,
1993 u.ai->uai_interface_index);
1994 if (iface && iface->idesc) {
1995 u.ai->uai_alt_index = iface->alt_index;
1996 } else {
1997 error = EINVAL;
1998 }
1999 break;
2000
2001 case USB_SET_ALTINTERFACE:
2002 if (!(fflags & FWRITE)) {
2003 error = EPERM;
2004 break;
2005 }
2006 error = ugen_set_interface(f,
2007 u.ai->uai_interface_index, u.ai->uai_alt_index);
2008 break;
2009
2010 case USB_GET_DEVICE_DESC:
2011 dtemp = usb2_get_device_descriptor(f->udev);
2012 if (!dtemp) {
2013 error = EIO;
2014 break;
2015 }
2016 *u.ddesc = *dtemp;
2017 break;
2018
2019 case USB_GET_CONFIG_DESC:
2020 ctemp = usb2_get_config_descriptor(f->udev);
2021 if (!ctemp) {
2022 error = EIO;
2023 break;
2024 }
2025 *u.cdesc = *ctemp;
2026 break;
2027
2028 case USB_GET_FULL_DESC:
2029 error = ugen_get_cdesc(f, addr);
2030 break;
2031
2032 case USB_GET_STRING_DESC:
2033 error = ugen_get_sdesc(f, addr);
2034 break;
2035
2036 case USB_GET_IFACE_DRIVER:
2037 error = ugen_get_iface_driver(f, addr);
2038 break;
2039
2040 case USB_REQUEST:
2041 case USB_DO_REQUEST:
2042 if (!(fflags & FWRITE)) {
2043 error = EPERM;
2044 break;
2045 }
2046 error = ugen_do_request(f, addr);
2047 break;
2048
2049 case USB_DEVICEINFO:
2050 case USB_GET_DEVICEINFO:
2051 error = usb2_gen_fill_deviceinfo(f, addr);
2052 break;
2053
2054 case USB_DEVICESTATS:
2055 for (n = 0; n != 4; n++) {
2056
2057 u.stat->uds_requests_fail[n] =
2058 f->udev->bus->stats_err.uds_requests[n];
2059
2060 u.stat->uds_requests_ok[n] =
2061 f->udev->bus->stats_ok.uds_requests[n];
2062 }
2063 break;
2064
2065 case USB_DEVICEENUMERATE:
2066 error = ugen_re_enumerate(f);
2067 break;
2068
2069 case USB_GET_PLUGTIME:
2070 *u.ptime = f->udev->plugtime;
2071 break;
2072
2073 case USB_CLAIM_INTERFACE:
2074 case USB_RELEASE_INTERFACE:
2075 /* TODO */
2076 break;
2077
2078 case USB_IFACE_DRIVER_ACTIVE:
2079 /* TODO */
2080 *u.pint = 0;
2081 break;
2082
2083 case USB_IFACE_DRIVER_DETACH:
2084 /* TODO */
2085 error = priv_check(curthread, PRIV_DRIVER);
2086 if (error) {
2087 break;
2088 }
2089 error = EINVAL;
2090 break;
2091
2092 case USB_SET_POWER_MODE:
2093 error = ugen_set_power_mode(f, *u.pint);
2094 break;
2095
2096 case USB_GET_POWER_MODE:
2097 *u.pint = ugen_get_power_mode(f);
2098 break;
2099
2100 case USB_SET_PORT_ENABLE:
2101 error = ugen_do_port_feature(f,
2102 *u.pint, 1, UHF_PORT_ENABLE);
2103 break;
2104
2105 case USB_SET_PORT_DISABLE:
2106 error = ugen_do_port_feature(f,
2107 *u.pint, 0, UHF_PORT_ENABLE);
2108 break;
2109
2110 case USB_FS_INIT:
2111 /* verify input parameters */
2112 if (u.pinit->pEndpoints == NULL) {
2113 error = EINVAL;
2114 break;
2115 }
2116 if (u.pinit->ep_index_max > 127) {
2117 error = EINVAL;
2118 break;
2119 }
2120 if (u.pinit->ep_index_max == 0) {
2121 error = EINVAL;
2122 break;
2123 }
2124 if (f->fs_xfer != NULL) {
2125 error = EBUSY;
2126 break;
2127 }
2128 if (f->dev_ep_index != 0) {
2129 error = EINVAL;
2130 break;
2131 }
2132 if (ugen_fifo_in_use(f, fflags)) {
2133 error = EBUSY;
2134 break;
2135 }
2136 error = usb2_fifo_alloc_buffer(f, 1, u.pinit->ep_index_max);
2137 if (error) {
2138 break;
2139 }
2140 f->fs_xfer = malloc(sizeof(f->fs_xfer[0]) *
2141 u.pinit->ep_index_max, M_USB, M_WAITOK | M_ZERO);
2142 if (f->fs_xfer == NULL) {
2143 usb2_fifo_free_buffer(f);
2144 error = ENOMEM;
2145 break;
2146 }
2147 f->fs_ep_max = u.pinit->ep_index_max;
2148 f->fs_ep_ptr = u.pinit->pEndpoints;
2149 break;
2150
2151 case USB_FS_UNINIT:
2152 if (u.puninit->dummy != 0) {
2153 error = EINVAL;
2154 break;
2155 }
2156 error = ugen_fs_uninit(f);
2157 break;
2158
2159 default:
2160 mtx_lock(f->priv_mtx);
2161 error = ugen_iface_ioctl(f, cmd, addr, fflags);
2162 mtx_unlock(f->priv_mtx);
2163 break;
2164 }
2165 DPRINTFN(6, "error=%d\n", error);
2166 return (error);
2167}
2168
2169static void
2170ugen_default_fs_callback(struct usb2_xfer *xfer)
2171{
2172 ; /* workaround for a bug in "indent" */
2173
2174 DPRINTF("st=%u alen=%u aframes=%u\n",
2175 USB_GET_STATE(xfer), xfer->actlen, xfer->aframes);
2176
2177 switch (USB_GET_STATE(xfer)) {
2178 case USB_ST_SETUP:
2179 usb2_start_hardware(xfer);
2180 break;
2181 default:
2182 ugen_fs_set_complete(xfer->priv_sc, USB_P2U(xfer->priv_fifo));
2183 break;
2184 }
2185}
2186#endif /* USB_HAVE_UGEN */
|