3 * Copyright (c) 2008 Hans Petter Selasky <hselasky@FreeBSD.org>
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
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.
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
29 * This file contains the driver for the USS820 series USB Device
32 * NOTE: The datasheet does not document everything.
35 #include <dev/usb/usb.h>
36 #include <dev/usb/usb_mfunc.h>
37 #include <dev/usb/usb_revision.h>
38 #include <dev/usb/usb_error.h>
40 #define USB_DEBUG_VAR uss820dcidebug
42 #include <dev/usb/usb_core.h>
43 #include <dev/usb/usb_debug.h>
44 #include <dev/usb/usb_busdma.h>
45 #include <dev/usb/usb_process.h>
46 #include <dev/usb/usb_transfer.h>
47 #include <dev/usb/usb_device.h>
48 #include <dev/usb/usb_hub.h>
49 #include <dev/usb/usb_util.h>
51 #include <dev/usb/usb_controller.h>
52 #include <dev/usb/usb_bus.h>
53 #include <dev/usb/controller/uss820dci.h>
55 #define USS820_DCI_BUS2SC(bus) \
56 ((struct uss820dci_softc *)(((uint8_t *)(bus)) - \
57 ((uint8_t *)&(((struct uss820dci_softc *)0)->sc_bus))))
59 #define USS820_DCI_PC2SC(pc) \
60 USS820_DCI_BUS2SC(USB_DMATAG_TO_XROOT((pc)->tag_parent)->bus)
63 static int uss820dcidebug = 0;
65 SYSCTL_NODE(_hw_usb2, OID_AUTO, uss820dci, CTLFLAG_RW, 0, "USB uss820dci");
66 SYSCTL_INT(_hw_usb2_uss820dci, OID_AUTO, debug, CTLFLAG_RW,
67 &uss820dcidebug, 0, "uss820dci debug level");
70 #define USS820_DCI_INTR_ENDPT 1
74 struct usb2_bus_methods uss820dci_bus_methods;
75 struct usb2_pipe_methods uss820dci_device_bulk_methods;
76 struct usb2_pipe_methods uss820dci_device_ctrl_methods;
77 struct usb2_pipe_methods uss820dci_device_intr_methods;
78 struct usb2_pipe_methods uss820dci_device_isoc_fs_methods;
80 static uss820dci_cmd_t uss820dci_setup_rx;
81 static uss820dci_cmd_t uss820dci_data_rx;
82 static uss820dci_cmd_t uss820dci_data_tx;
83 static uss820dci_cmd_t uss820dci_data_tx_sync;
84 static void uss820dci_device_done(struct usb2_xfer *, usb2_error_t);
85 static void uss820dci_do_poll(struct usb2_bus *);
86 static void uss820dci_standard_done(struct usb2_xfer *);
87 static void uss820dci_intr_set(struct usb2_xfer *, uint8_t);
88 static void uss820dci_update_shared_1(struct uss820dci_softc *, uint8_t,
90 static void uss820dci_root_intr(struct uss820dci_softc *);
93 * Here is a list of what the USS820D chip can support. The main
94 * limitation is that the sum of the buffer sizes must be less than
97 static const struct usb2_hw_ep_profile
98 uss820dci_ep_profile[] = {
101 .max_in_frame_size = 32,
102 .max_out_frame_size = 32,
104 .support_control = 1,
107 .max_in_frame_size = 64,
108 .max_out_frame_size = 64,
110 .support_multi_buffer = 1,
112 .support_interrupt = 1,
117 .max_in_frame_size = 8,
118 .max_out_frame_size = 8,
120 .support_multi_buffer = 1,
122 .support_interrupt = 1,
127 .max_in_frame_size = 256,
128 .max_out_frame_size = 256,
130 .support_multi_buffer = 1,
131 .support_isochronous = 1,
138 uss820dci_update_shared_1(struct uss820dci_softc *sc, uint8_t reg,
139 uint8_t keep_mask, uint8_t set_mask)
143 USS820_WRITE_1(sc, USS820_PEND, 1);
144 temp = USS820_READ_1(sc, reg);
147 USS820_WRITE_1(sc, reg, temp);
148 USS820_WRITE_1(sc, USS820_PEND, 0);
152 uss820dci_get_hw_ep_profile(struct usb2_device *udev,
153 const struct usb2_hw_ep_profile **ppf, uint8_t ep_addr)
156 *ppf = uss820dci_ep_profile + 0;
157 } else if (ep_addr < 5) {
158 *ppf = uss820dci_ep_profile + 1;
159 } else if (ep_addr < 7) {
160 *ppf = uss820dci_ep_profile + 2;
161 } else if (ep_addr == 7) {
162 *ppf = uss820dci_ep_profile + 3;
169 uss820dci_pull_up(struct uss820dci_softc *sc)
173 /* pullup D+, if possible */
175 if (!sc->sc_flags.d_pulled_up &&
176 sc->sc_flags.port_powered) {
177 sc->sc_flags.d_pulled_up = 1;
181 temp = USS820_READ_1(sc, USS820_MCSR);
182 temp |= USS820_MCSR_DPEN;
183 USS820_WRITE_1(sc, USS820_MCSR, temp);
188 uss820dci_pull_down(struct uss820dci_softc *sc)
192 /* pulldown D+, if possible */
194 if (sc->sc_flags.d_pulled_up) {
195 sc->sc_flags.d_pulled_up = 0;
199 temp = USS820_READ_1(sc, USS820_MCSR);
200 temp &= ~USS820_MCSR_DPEN;
201 USS820_WRITE_1(sc, USS820_MCSR, temp);
206 uss820dci_wakeup_peer(struct uss820dci_softc *sc)
208 if (!(sc->sc_flags.status_suspend)) {
211 DPRINTFN(0, "not supported\n");
215 uss820dci_set_address(struct uss820dci_softc *sc, uint8_t addr)
217 DPRINTFN(5, "addr=%d\n", addr);
219 USS820_WRITE_1(sc, USS820_FADDR, addr);
223 uss820dci_setup_rx(struct uss820dci_td *td)
225 struct uss820dci_softc *sc;
226 struct usb2_device_request req;
231 /* select the correct endpoint */
232 bus_space_write_1(td->io_tag, td->io_hdl,
233 td->ep_reg, td->ep_index);
235 /* read out FIFO status */
236 rx_stat = bus_space_read_1(td->io_tag, td->io_hdl,
239 /* get pointer to softc */
240 sc = USS820_DCI_PC2SC(td->pc);
242 DPRINTFN(5, "rx_stat=0x%02x rem=%u\n", rx_stat, td->remainder);
244 if (!(rx_stat & USS820_RXSTAT_RXSETUP)) {
247 /* clear did stall */
250 /* clear stall and all I/O */
251 uss820dci_update_shared_1(sc, USS820_EPCON,
252 0xFF ^ (USS820_EPCON_TXSTL |
255 USS820_EPCON_TXOE), 0);
257 /* clear end overwrite flag */
258 uss820dci_update_shared_1(sc, USS820_RXSTAT,
259 0xFF ^ USS820_RXSTAT_EDOVW, 0);
261 /* get the packet byte count */
262 count = bus_space_read_1(td->io_tag, td->io_hdl,
263 td->rx_count_low_reg);
264 count |= (bus_space_read_1(td->io_tag, td->io_hdl,
265 td->rx_count_high_reg) << 8);
268 /* verify data length */
269 if (count != td->remainder) {
270 DPRINTFN(0, "Invalid SETUP packet "
271 "length, %d bytes\n", count);
272 goto setup_not_complete;
274 if (count != sizeof(req)) {
275 DPRINTFN(0, "Unsupported SETUP packet "
276 "length, %d bytes\n", count);
277 goto setup_not_complete;
280 bus_space_read_multi_1(td->io_tag, td->io_hdl,
281 td->rx_fifo_reg, (void *)&req, sizeof(req));
283 /* read out FIFO status */
284 rx_stat = bus_space_read_1(td->io_tag, td->io_hdl,
287 if (rx_stat & (USS820_RXSTAT_EDOVW |
288 USS820_RXSTAT_STOVW)) {
289 DPRINTF("new SETUP packet received\n");
290 return (1); /* not complete */
292 /* clear receive setup bit */
293 uss820dci_update_shared_1(sc, USS820_RXSTAT,
294 0xFF ^ (USS820_RXSTAT_RXSETUP |
295 USS820_RXSTAT_EDOVW |
296 USS820_RXSTAT_STOVW), 0);
299 temp = bus_space_read_1(td->io_tag, td->io_hdl,
301 temp |= USS820_RXCON_RXFFRC;
302 bus_space_write_1(td->io_tag, td->io_hdl,
303 td->rx_cntl_reg, temp);
305 /* copy data into real buffer */
306 usb2_copy_in(td->pc, 0, &req, sizeof(req));
308 td->offset = sizeof(req);
311 /* sneak peek the set address */
312 if ((req.bmRequestType == UT_WRITE_DEVICE) &&
313 (req.bRequest == UR_SET_ADDRESS)) {
314 sc->sc_dv_addr = req.wValue[0] & 0x7F;
316 sc->sc_dv_addr = 0xFF;
318 return (0); /* complete */
323 temp = bus_space_read_1(td->io_tag, td->io_hdl,
325 temp |= USS820_RXCON_RXFFRC;
326 bus_space_write_1(td->io_tag, td->io_hdl,
327 td->rx_cntl_reg, temp);
332 /* abort any ongoing transfer */
333 if (!td->did_stall) {
334 DPRINTFN(5, "stalling\n");
336 uss820dci_update_shared_1(sc, USS820_EPCON, 0xFF,
337 (USS820_EPCON_TXSTL | USS820_EPCON_RXSTL));
342 /* clear end overwrite flag, if any */
343 if (rx_stat & USS820_RXSTAT_RXSETUP) {
344 uss820dci_update_shared_1(sc, USS820_RXSTAT,
345 0xFF ^ (USS820_RXSTAT_EDOVW |
346 USS820_RXSTAT_STOVW |
347 USS820_RXSTAT_RXSETUP), 0);
349 return (1); /* not complete */
354 uss820dci_data_rx(struct uss820dci_td *td)
356 struct usb2_page_search buf_res;
364 to = 2; /* don't loop forever! */
367 /* select the correct endpoint */
368 bus_space_write_1(td->io_tag, td->io_hdl, td->ep_reg, td->ep_index);
370 /* check if any of the FIFO banks have data */
372 /* read out FIFO flag */
373 rx_flag = bus_space_read_1(td->io_tag, td->io_hdl,
375 /* read out FIFO status */
376 rx_stat = bus_space_read_1(td->io_tag, td->io_hdl,
379 DPRINTFN(5, "rx_stat=0x%02x rx_flag=0x%02x rem=%u\n",
380 rx_stat, rx_flag, td->remainder);
382 if (rx_stat & (USS820_RXSTAT_RXSETUP |
383 USS820_RXSTAT_RXSOVW |
384 USS820_RXSTAT_EDOVW)) {
385 if (td->remainder == 0) {
387 * We are actually complete and have
388 * received the next SETUP
390 DPRINTFN(5, "faking complete\n");
391 return (0); /* complete */
394 * USB Host Aborted the transfer.
397 return (0); /* complete */
399 /* check for errors */
400 if (rx_flag & (USS820_RXFLG_RXOVF |
401 USS820_RXFLG_RXURF)) {
402 DPRINTFN(5, "overflow or underflow\n");
403 /* should not happen */
405 return (0); /* complete */
408 if (!(rx_flag & (USS820_RXFLG_RXFIF0 |
409 USS820_RXFLG_RXFIF1))) {
411 /* read out EPCON register */
412 /* enable RX input */
413 if (!td->did_stall) {
414 uss820dci_update_shared_1(USS820_DCI_PC2SC(td->pc),
415 USS820_EPCON, 0xFF, USS820_EPCON_RXIE);
418 return (1); /* not complete */
420 /* get the packet byte count */
421 count = bus_space_read_1(td->io_tag, td->io_hdl,
422 td->rx_count_low_reg);
424 count |= (bus_space_read_1(td->io_tag, td->io_hdl,
425 td->rx_count_high_reg) << 8);
428 DPRINTFN(5, "count=0x%04x\n", count);
430 /* verify the packet byte count */
431 if (count != td->max_packet_size) {
432 if (count < td->max_packet_size) {
433 /* we have a short packet */
437 /* invalid USB packet */
439 return (0); /* we are complete */
442 /* verify the packet byte count */
443 if (count > td->remainder) {
444 /* invalid USB packet */
446 return (0); /* we are complete */
449 usb2_get_page(td->pc, td->offset, &buf_res);
451 /* get correct length */
452 if (buf_res.length > count) {
453 buf_res.length = count;
456 bus_space_read_multi_1(td->io_tag, td->io_hdl,
457 td->rx_fifo_reg, buf_res.buffer, buf_res.length);
459 /* update counters */
460 count -= buf_res.length;
461 td->offset += buf_res.length;
462 td->remainder -= buf_res.length;
466 rx_cntl = bus_space_read_1(td->io_tag, td->io_hdl,
468 rx_cntl |= USS820_RXCON_RXFFRC;
469 bus_space_write_1(td->io_tag, td->io_hdl,
470 td->rx_cntl_reg, rx_cntl);
472 /* check if we are complete */
473 if ((td->remainder == 0) || got_short) {
475 /* we are complete */
478 /* else need to receive a zero length packet */
483 return (1); /* not complete */
487 uss820dci_data_tx(struct uss820dci_td *td)
489 struct usb2_page_search buf_res;
496 /* select the correct endpoint */
497 bus_space_write_1(td->io_tag, td->io_hdl,
498 td->ep_reg, td->ep_index);
500 to = 2; /* don't loop forever! */
503 /* read out TX FIFO flags */
504 tx_flag = bus_space_read_1(td->io_tag, td->io_hdl,
507 /* read out RX FIFO status last */
508 rx_stat = bus_space_read_1(td->io_tag, td->io_hdl,
511 DPRINTFN(5, "rx_stat=0x%02x tx_flag=0x%02x rem=%u\n",
512 rx_stat, tx_flag, td->remainder);
514 if (rx_stat & (USS820_RXSTAT_RXSETUP |
515 USS820_RXSTAT_RXSOVW |
516 USS820_RXSTAT_EDOVW)) {
518 * The current transfer was aborted
522 return (0); /* complete */
524 if (tx_flag & (USS820_TXFLG_TXOVF |
525 USS820_TXFLG_TXURF)) {
527 return (0); /* complete */
529 if (tx_flag & USS820_TXFLG_TXFIF0) {
530 if (tx_flag & USS820_TXFLG_TXFIF1) {
531 return (1); /* not complete */
534 if ((!td->support_multi_buffer) &&
535 (tx_flag & (USS820_TXFLG_TXFIF0 |
536 USS820_TXFLG_TXFIF1))) {
537 return (1); /* not complete */
539 count = td->max_packet_size;
540 if (td->remainder < count) {
541 /* we have a short packet */
543 count = td->remainder;
548 usb2_get_page(td->pc, td->offset, &buf_res);
550 /* get correct length */
551 if (buf_res.length > count) {
552 buf_res.length = count;
555 bus_space_write_multi_1(td->io_tag, td->io_hdl,
556 td->tx_fifo_reg, buf_res.buffer, buf_res.length);
558 /* update counters */
559 count -= buf_res.length;
560 td->offset += buf_res.length;
561 td->remainder -= buf_res.length;
564 /* post-write high packet byte count first */
565 bus_space_write_1(td->io_tag, td->io_hdl,
566 td->tx_count_high_reg, count_copy >> 8);
568 /* post-write low packet byte count last */
569 bus_space_write_1(td->io_tag, td->io_hdl,
570 td->tx_count_low_reg, count_copy);
573 * Enable TX output, which must happen after that we have written
574 * data into the FIFO. This is undocumented.
576 if (!td->did_stall) {
577 uss820dci_update_shared_1(USS820_DCI_PC2SC(td->pc),
578 USS820_EPCON, 0xFF, USS820_EPCON_TXOE);
581 /* check remainder */
582 if (td->remainder == 0) {
584 return (0); /* complete */
586 /* else we need to transmit a short packet */
591 return (1); /* not complete */
595 uss820dci_data_tx_sync(struct uss820dci_td *td)
597 struct uss820dci_softc *sc;
601 /* select the correct endpoint */
602 bus_space_write_1(td->io_tag, td->io_hdl,
603 td->ep_reg, td->ep_index);
605 /* read out TX FIFO flag */
606 tx_flag = bus_space_read_1(td->io_tag, td->io_hdl,
609 /* read out RX FIFO status last */
610 rx_stat = bus_space_read_1(td->io_tag, td->io_hdl,
613 DPRINTFN(5, "rx_stat=0x%02x rem=%u\n", rx_stat, td->remainder);
615 if (rx_stat & (USS820_RXSTAT_RXSETUP |
616 USS820_RXSTAT_RXSOVW |
617 USS820_RXSTAT_EDOVW)) {
618 DPRINTFN(5, "faking complete\n");
620 return (0); /* complete */
622 DPRINTFN(5, "tx_flag=0x%02x rem=%u\n",
623 tx_flag, td->remainder);
625 if (tx_flag & (USS820_TXFLG_TXOVF |
626 USS820_TXFLG_TXURF)) {
628 return (0); /* complete */
630 if (tx_flag & (USS820_TXFLG_TXFIF0 |
631 USS820_TXFLG_TXFIF1)) {
632 return (1); /* not complete */
634 sc = USS820_DCI_PC2SC(td->pc);
635 if (sc->sc_dv_addr != 0xFF) {
636 /* write function address */
637 uss820dci_set_address(sc, sc->sc_dv_addr);
639 return (0); /* complete */
643 uss820dci_xfer_do_fifo(struct usb2_xfer *xfer)
645 struct uss820dci_td *td;
649 td = xfer->td_transfer_cache;
651 if ((td->func) (td)) {
652 /* operation in progress */
655 if (((void *)td) == xfer->td_transfer_last) {
660 } else if (td->remainder > 0) {
662 * We had a short transfer. If there is no alternate
663 * next, stop processing !
670 * Fetch the next transfer descriptor.
673 xfer->td_transfer_cache = td;
675 return (1); /* not complete */
678 /* compute all actual lengths */
680 uss820dci_standard_done(xfer);
682 return (0); /* complete */
686 uss820dci_interrupt_poll(struct uss820dci_softc *sc)
688 struct usb2_xfer *xfer;
691 TAILQ_FOREACH(xfer, &sc->sc_bus.intr_q.head, wait_entry) {
692 if (!uss820dci_xfer_do_fifo(xfer)) {
693 /* queue has been modified */
700 uss820dci_wait_suspend(struct uss820dci_softc *sc, uint8_t on)
705 scr = USS820_READ_1(sc, USS820_SCR);
706 scratch = USS820_READ_1(sc, USS820_SCRATCH);
709 scr |= USS820_SCR_IE_SUSP;
710 scratch &= ~USS820_SCRATCH_IE_RESUME;
712 scr &= ~USS820_SCR_IE_SUSP;
713 scratch |= USS820_SCRATCH_IE_RESUME;
716 USS820_WRITE_1(sc, USS820_SCR, scr);
717 USS820_WRITE_1(sc, USS820_SCRATCH, scratch);
721 uss820dci_interrupt(struct uss820dci_softc *sc)
726 USB_BUS_LOCK(&sc->sc_bus);
728 ssr = USS820_READ_1(sc, USS820_SSR);
730 ssr &= (USS820_SSR_SUSPEND |
734 /* acknowledge all interrupts */
736 uss820dci_update_shared_1(sc, USS820_SSR, 0, 0);
738 /* check for any bus state change interrupts */
744 if (ssr & USS820_SSR_RESET) {
745 sc->sc_flags.status_bus_reset = 1;
746 sc->sc_flags.status_suspend = 0;
747 sc->sc_flags.change_suspend = 0;
748 sc->sc_flags.change_connect = 1;
750 /* disable resume interrupt */
751 uss820dci_wait_suspend(sc, 1);
756 * If "RESUME" and "SUSPEND" is set at the same time
757 * we interpret that like "RESUME". Resume is set when
758 * there is at least 3 milliseconds of inactivity on
761 if (ssr & USS820_SSR_RESUME) {
762 if (sc->sc_flags.status_suspend) {
763 sc->sc_flags.status_suspend = 0;
764 sc->sc_flags.change_suspend = 1;
765 /* disable resume interrupt */
766 uss820dci_wait_suspend(sc, 1);
769 } else if (ssr & USS820_SSR_SUSPEND) {
770 if (!sc->sc_flags.status_suspend) {
771 sc->sc_flags.status_suspend = 1;
772 sc->sc_flags.change_suspend = 1;
773 /* enable resume interrupt */
774 uss820dci_wait_suspend(sc, 0);
780 DPRINTF("real bus interrupt 0x%02x\n", ssr);
782 /* complete root HUB interrupt endpoint */
783 uss820dci_root_intr(sc);
786 /* acknowledge all SBI interrupts */
787 uss820dci_update_shared_1(sc, USS820_SBI, 0, 0);
789 /* acknowledge all SBI1 interrupts */
790 uss820dci_update_shared_1(sc, USS820_SBI1, 0, 0);
792 /* poll all active transfers */
793 uss820dci_interrupt_poll(sc);
795 USB_BUS_UNLOCK(&sc->sc_bus);
799 uss820dci_setup_standard_chain_sub(struct uss820_std_temp *temp)
801 struct uss820dci_td *td;
803 /* get current Transfer Descriptor */
807 /* prepare for next TD */
808 temp->td_next = td->obj_next;
810 /* fill out the Transfer Descriptor */
811 td->func = temp->func;
813 td->offset = temp->offset;
814 td->remainder = temp->len;
817 td->short_pkt = temp->short_pkt;
818 td->alt_next = temp->setup_alt_next;
822 uss820dci_setup_standard_chain(struct usb2_xfer *xfer)
824 struct uss820_std_temp temp;
825 struct uss820dci_softc *sc;
826 struct uss820dci_td *td;
830 DPRINTFN(9, "addr=%d endpt=%d sumlen=%d speed=%d\n",
831 xfer->address, UE_GET_ADDR(xfer->endpoint),
832 xfer->sumlen, usb2_get_speed(xfer->xroot->udev));
834 temp.max_frame_size = xfer->max_frame_size;
836 td = xfer->td_start[0];
837 xfer->td_transfer_first = td;
838 xfer->td_transfer_cache = td;
843 temp.td_next = xfer->td_start[0];
845 temp.setup_alt_next = xfer->flags_int.short_frames_ok;
847 sc = USS820_DCI_BUS2SC(xfer->xroot->bus);
848 ep_no = (xfer->endpoint & UE_ADDR);
850 /* check if we should prepend a setup message */
852 if (xfer->flags_int.control_xfr) {
853 if (xfer->flags_int.control_hdr) {
855 temp.func = &uss820dci_setup_rx;
856 temp.len = xfer->frlengths[0];
857 temp.pc = xfer->frbuffers + 0;
858 temp.short_pkt = temp.len ? 1 : 0;
859 /* check for last frame */
860 if (xfer->nframes == 1) {
861 /* no STATUS stage yet, SETUP is last */
862 if (xfer->flags_int.control_act)
863 temp.setup_alt_next = 0;
866 uss820dci_setup_standard_chain_sub(&temp);
873 if (x != xfer->nframes) {
874 if (xfer->endpoint & UE_DIR_IN) {
875 temp.func = &uss820dci_data_tx;
877 temp.func = &uss820dci_data_rx;
880 /* setup "pc" pointer */
881 temp.pc = xfer->frbuffers + x;
883 while (x != xfer->nframes) {
885 /* DATA0 / DATA1 message */
887 temp.len = xfer->frlengths[x];
891 if (x == xfer->nframes) {
892 if (xfer->flags_int.control_xfr) {
893 if (xfer->flags_int.control_act) {
894 temp.setup_alt_next = 0;
897 temp.setup_alt_next = 0;
902 /* make sure that we send an USB packet */
908 /* regular data transfer */
910 temp.short_pkt = (xfer->flags.force_short_xfer) ? 0 : 1;
913 uss820dci_setup_standard_chain_sub(&temp);
915 if (xfer->flags_int.isochronous_xfr) {
916 temp.offset += temp.len;
918 /* get next Page Cache pointer */
919 temp.pc = xfer->frbuffers + x;
923 /* check for control transfer */
924 if (xfer->flags_int.control_xfr) {
927 /* always setup a valid "pc" pointer for status and sync */
928 temp.pc = xfer->frbuffers + 0;
931 temp.setup_alt_next = 0;
933 /* check if we should append a status stage */
934 if (!xfer->flags_int.control_act) {
937 * Send a DATA1 message and invert the current
938 * endpoint direction.
940 if (xfer->endpoint & UE_DIR_IN) {
941 temp.func = &uss820dci_data_rx;
944 temp.func = &uss820dci_data_tx;
950 uss820dci_setup_standard_chain_sub(&temp);
952 /* we need a SYNC point after TX */
953 temp.func = &uss820dci_data_tx_sync;
954 uss820dci_setup_standard_chain_sub(&temp);
958 /* must have at least one frame! */
960 xfer->td_transfer_last = td;
964 uss820dci_timeout(void *arg)
966 struct usb2_xfer *xfer = arg;
968 DPRINTF("xfer=%p\n", xfer);
970 USB_BUS_LOCK_ASSERT(xfer->xroot->bus, MA_OWNED);
972 /* transfer is transferred */
973 uss820dci_device_done(xfer, USB_ERR_TIMEOUT);
977 uss820dci_intr_set(struct usb2_xfer *xfer, uint8_t set)
979 struct uss820dci_softc *sc = USS820_DCI_BUS2SC(xfer->xroot->bus);
980 uint8_t ep_no = (xfer->endpoint & UE_ADDR);
984 DPRINTFN(15, "endpoint 0x%02x\n", xfer->endpoint);
987 ep_reg = USS820_SBIE1;
989 ep_reg = USS820_SBIE;
993 ep_no = 1 << (2 * ep_no);
995 if (xfer->flags_int.control_xfr) {
996 if (xfer->flags_int.control_hdr) {
997 ep_no <<= 1; /* RX interrupt only */
999 ep_no |= (ep_no << 1); /* RX and TX interrupt */
1002 if (!(xfer->endpoint & UE_DIR_IN)) {
1006 temp = USS820_READ_1(sc, ep_reg);
1012 USS820_WRITE_1(sc, ep_reg, temp);
1016 uss820dci_start_standard_chain(struct usb2_xfer *xfer)
1021 if (uss820dci_xfer_do_fifo(xfer)) {
1024 * Only enable the endpoint interrupt when we are
1025 * actually waiting for data, hence we are dealing
1026 * with level triggered interrupts !
1028 uss820dci_intr_set(xfer, 1);
1030 /* put transfer on interrupt queue */
1031 usb2_transfer_enqueue(&xfer->xroot->bus->intr_q, xfer);
1033 /* start timeout, if any */
1034 if (xfer->timeout != 0) {
1035 usb2_transfer_timeout_ms(xfer,
1036 &uss820dci_timeout, xfer->timeout);
1042 uss820dci_root_intr(struct uss820dci_softc *sc)
1046 USB_BUS_LOCK_ASSERT(&sc->sc_bus, MA_OWNED);
1049 sc->sc_hub_idata[0] = 0x02; /* we only have one port */
1051 uhub_root_intr(&sc->sc_bus, sc->sc_hub_idata,
1052 sizeof(sc->sc_hub_idata));
1056 uss820dci_standard_done_sub(struct usb2_xfer *xfer)
1058 struct uss820dci_td *td;
1064 td = xfer->td_transfer_cache;
1067 len = td->remainder;
1069 if (xfer->aframes != xfer->nframes) {
1071 * Verify the length and subtract
1072 * the remainder from "frlengths[]":
1074 if (len > xfer->frlengths[xfer->aframes]) {
1077 xfer->frlengths[xfer->aframes] -= len;
1080 /* Check for transfer error */
1082 /* the transfer is finished */
1087 /* Check for short transfer */
1089 if (xfer->flags_int.short_frames_ok) {
1090 /* follow alt next */
1097 /* the transfer is finished */
1105 /* this USB frame is complete */
1111 /* update transfer cache */
1113 xfer->td_transfer_cache = td;
1116 USB_ERR_STALLED : USB_ERR_NORMAL_COMPLETION);
1120 uss820dci_standard_done(struct usb2_xfer *xfer)
1122 usb2_error_t err = 0;
1124 DPRINTFN(13, "xfer=%p pipe=%p transfer done\n",
1129 xfer->td_transfer_cache = xfer->td_transfer_first;
1131 if (xfer->flags_int.control_xfr) {
1133 if (xfer->flags_int.control_hdr) {
1135 err = uss820dci_standard_done_sub(xfer);
1139 if (xfer->td_transfer_cache == NULL) {
1143 while (xfer->aframes != xfer->nframes) {
1145 err = uss820dci_standard_done_sub(xfer);
1148 if (xfer->td_transfer_cache == NULL) {
1153 if (xfer->flags_int.control_xfr &&
1154 !xfer->flags_int.control_act) {
1156 err = uss820dci_standard_done_sub(xfer);
1159 uss820dci_device_done(xfer, err);
1162 /*------------------------------------------------------------------------*
1163 * uss820dci_device_done
1165 * NOTE: this function can be called more than one time on the
1166 * same USB transfer!
1167 *------------------------------------------------------------------------*/
1169 uss820dci_device_done(struct usb2_xfer *xfer, usb2_error_t error)
1171 USB_BUS_LOCK_ASSERT(xfer->xroot->bus, MA_OWNED);
1173 DPRINTFN(2, "xfer=%p, pipe=%p, error=%d\n",
1174 xfer, xfer->pipe, error);
1176 if (xfer->flags_int.usb2_mode == USB_MODE_DEVICE) {
1177 uss820dci_intr_set(xfer, 0);
1179 /* dequeue transfer and start next transfer */
1180 usb2_transfer_done(xfer, error);
1184 uss820dci_set_stall(struct usb2_device *udev, struct usb2_xfer *xfer,
1185 struct usb2_pipe *pipe)
1187 struct uss820dci_softc *sc;
1193 USB_BUS_LOCK_ASSERT(udev->bus, MA_OWNED);
1195 DPRINTFN(5, "pipe=%p\n", pipe);
1198 /* cancel any ongoing transfers */
1199 uss820dci_device_done(xfer, USB_ERR_STALLED);
1201 /* set FORCESTALL */
1202 sc = USS820_DCI_BUS2SC(udev->bus);
1203 ep_no = (pipe->edesc->bEndpointAddress & UE_ADDR);
1204 ep_dir = (pipe->edesc->bEndpointAddress & (UE_DIR_IN | UE_DIR_OUT));
1205 ep_type = (pipe->edesc->bmAttributes & UE_XFERTYPE);
1207 if (ep_type == UE_CONTROL) {
1208 /* should not happen */
1211 USS820_WRITE_1(sc, USS820_EPINDEX, ep_no);
1213 if (ep_dir == UE_DIR_IN) {
1214 temp = USS820_EPCON_TXSTL;
1216 temp = USS820_EPCON_RXSTL;
1218 uss820dci_update_shared_1(sc, USS820_EPCON, 0xFF, temp);
1222 uss820dci_clear_stall_sub(struct uss820dci_softc *sc,
1223 uint8_t ep_no, uint8_t ep_type, uint8_t ep_dir)
1227 if (ep_type == UE_CONTROL) {
1228 /* clearing stall is not needed */
1231 /* select endpoint index */
1232 USS820_WRITE_1(sc, USS820_EPINDEX, ep_no);
1234 /* clear stall and disable I/O transfers */
1235 if (ep_dir == UE_DIR_IN) {
1236 temp = 0xFF ^ (USS820_EPCON_TXOE |
1237 USS820_EPCON_TXSTL);
1239 temp = 0xFF ^ (USS820_EPCON_RXIE |
1240 USS820_EPCON_RXSTL);
1242 uss820dci_update_shared_1(sc, USS820_EPCON, temp, 0);
1244 if (ep_dir == UE_DIR_IN) {
1245 /* reset data toggle */
1246 USS820_WRITE_1(sc, USS820_TXSTAT,
1247 USS820_TXSTAT_TXSOVW);
1250 temp = USS820_READ_1(sc, USS820_TXCON);
1251 temp |= USS820_TXCON_TXCLR;
1252 USS820_WRITE_1(sc, USS820_TXCON, temp);
1253 temp &= ~USS820_TXCON_TXCLR;
1254 USS820_WRITE_1(sc, USS820_TXCON, temp);
1257 /* reset data toggle */
1258 uss820dci_update_shared_1(sc, USS820_RXSTAT,
1259 0, USS820_RXSTAT_RXSOVW);
1262 temp = USS820_READ_1(sc, USS820_RXCON);
1263 temp |= USS820_RXCON_RXCLR;
1264 temp &= ~USS820_RXCON_RXFFRC;
1265 USS820_WRITE_1(sc, USS820_RXCON, temp);
1266 temp &= ~USS820_RXCON_RXCLR;
1267 USS820_WRITE_1(sc, USS820_RXCON, temp);
1272 uss820dci_clear_stall(struct usb2_device *udev, struct usb2_pipe *pipe)
1274 struct uss820dci_softc *sc;
1275 struct usb2_endpoint_descriptor *ed;
1277 USB_BUS_LOCK_ASSERT(udev->bus, MA_OWNED);
1279 DPRINTFN(5, "pipe=%p\n", pipe);
1282 if (udev->flags.usb2_mode != USB_MODE_DEVICE) {
1287 sc = USS820_DCI_BUS2SC(udev->bus);
1289 /* get endpoint descriptor */
1292 /* reset endpoint */
1293 uss820dci_clear_stall_sub(sc,
1294 (ed->bEndpointAddress & UE_ADDR),
1295 (ed->bmAttributes & UE_XFERTYPE),
1296 (ed->bEndpointAddress & (UE_DIR_IN | UE_DIR_OUT)));
1300 uss820dci_init(struct uss820dci_softc *sc)
1302 const struct usb2_hw_ep_profile *pf;
1308 /* set up the bus structure */
1309 sc->sc_bus.usbrev = USB_REV_1_1;
1310 sc->sc_bus.methods = &uss820dci_bus_methods;
1312 USB_BUS_LOCK(&sc->sc_bus);
1314 /* we always have VBUS */
1315 sc->sc_flags.status_vbus = 1;
1317 /* reset the chip */
1318 USS820_WRITE_1(sc, USS820_SCR, USS820_SCR_SRESET);
1320 USS820_WRITE_1(sc, USS820_SCR, 0);
1322 /* wait for reset to complete */
1325 temp = USS820_READ_1(sc, USS820_MCSR);
1327 if (temp & USS820_MCSR_INIT) {
1331 USB_BUS_UNLOCK(&sc->sc_bus);
1332 return (USB_ERR_INVAL);
1334 /* wait a little for things to stabilise */
1339 uss820dci_pull_down(sc);
1341 /* wait 10ms for pulldown to stabilise */
1342 usb2_pause_mtx(&sc->sc_bus.bus_mtx, hz / 100);
1344 /* check hardware revision */
1345 temp = USS820_READ_1(sc, USS820_REV);
1348 USB_BUS_UNLOCK(&sc->sc_bus);
1349 return (USB_ERR_INVAL);
1351 /* enable interrupts */
1352 USS820_WRITE_1(sc, USS820_SCR,
1354 USS820_SCR_IE_RESET |
1355 /* USS820_SCR_RWUPE | */
1356 USS820_SCR_IE_SUSP |
1359 /* enable interrupts */
1360 USS820_WRITE_1(sc, USS820_SCRATCH,
1361 USS820_SCRATCH_IE_RESUME);
1363 /* enable features */
1364 USS820_WRITE_1(sc, USS820_MCSR,
1365 USS820_MCSR_BDFEAT |
1368 sc->sc_flags.mcsr_feat = 1;
1370 /* disable interrupts */
1371 USS820_WRITE_1(sc, USS820_SBIE, 0);
1373 /* disable interrupts */
1374 USS820_WRITE_1(sc, USS820_SBIE1, 0);
1376 /* disable all endpoints */
1377 for (n = 0; n != USS820_EP_MAX; n++) {
1379 /* select endpoint */
1380 USS820_WRITE_1(sc, USS820_EPINDEX, n);
1382 /* disable endpoint */
1383 uss820dci_update_shared_1(sc, USS820_EPCON, 0, 0);
1387 * Initialise default values for some registers that cannot be
1388 * changed during operation!
1390 for (n = 0; n != USS820_EP_MAX; n++) {
1392 uss820dci_get_hw_ep_profile(NULL, &pf, n);
1394 /* the maximum frame sizes should be the same */
1395 if (pf->max_in_frame_size != pf->max_out_frame_size) {
1396 DPRINTF("Max frame size mismatch %u != %u\n",
1397 pf->max_in_frame_size, pf->max_out_frame_size);
1399 if (pf->support_isochronous) {
1400 if (pf->max_in_frame_size <= 64) {
1401 temp = (USS820_TXCON_FFSZ_16_64 |
1402 USS820_TXCON_TXISO |
1404 } else if (pf->max_in_frame_size <= 256) {
1405 temp = (USS820_TXCON_FFSZ_64_256 |
1406 USS820_TXCON_TXISO |
1408 } else if (pf->max_in_frame_size <= 512) {
1409 temp = (USS820_TXCON_FFSZ_8_512 |
1410 USS820_TXCON_TXISO |
1412 } else { /* 1024 bytes */
1413 temp = (USS820_TXCON_FFSZ_32_1024 |
1414 USS820_TXCON_TXISO |
1418 if ((pf->max_in_frame_size <= 8) &&
1419 (sc->sc_flags.mcsr_feat)) {
1420 temp = (USS820_TXCON_FFSZ_8_512 |
1422 } else if (pf->max_in_frame_size <= 16) {
1423 temp = (USS820_TXCON_FFSZ_16_64 |
1425 } else if ((pf->max_in_frame_size <= 32) &&
1426 (sc->sc_flags.mcsr_feat)) {
1427 temp = (USS820_TXCON_FFSZ_32_1024 |
1429 } else { /* 64 bytes */
1430 temp = (USS820_TXCON_FFSZ_64_256 |
1435 /* need to configure the chip early */
1437 USS820_WRITE_1(sc, USS820_EPINDEX, n);
1438 USS820_WRITE_1(sc, USS820_TXCON, temp);
1439 USS820_WRITE_1(sc, USS820_RXCON, temp);
1441 if (pf->support_control) {
1442 temp = USS820_EPCON_CTLEP |
1443 USS820_EPCON_RXSPM |
1445 USS820_EPCON_RXEPEN |
1447 USS820_EPCON_TXEPEN;
1449 temp = USS820_EPCON_RXEPEN | USS820_EPCON_TXEPEN;
1452 uss820dci_update_shared_1(sc, USS820_EPCON, 0xFF, temp);
1455 USB_BUS_UNLOCK(&sc->sc_bus);
1457 /* catch any lost interrupts */
1459 uss820dci_do_poll(&sc->sc_bus);
1461 return (0); /* success */
1465 uss820dci_uninit(struct uss820dci_softc *sc)
1469 USB_BUS_LOCK(&sc->sc_bus);
1471 /* disable all interrupts */
1472 temp = USS820_READ_1(sc, USS820_SCR);
1473 temp &= ~USS820_SCR_T_IRQ;
1474 USS820_WRITE_1(sc, USS820_SCR, temp);
1476 sc->sc_flags.port_powered = 0;
1477 sc->sc_flags.status_vbus = 0;
1478 sc->sc_flags.status_bus_reset = 0;
1479 sc->sc_flags.status_suspend = 0;
1480 sc->sc_flags.change_suspend = 0;
1481 sc->sc_flags.change_connect = 1;
1483 uss820dci_pull_down(sc);
1484 USB_BUS_UNLOCK(&sc->sc_bus);
1488 uss820dci_suspend(struct uss820dci_softc *sc)
1494 uss820dci_resume(struct uss820dci_softc *sc)
1500 uss820dci_do_poll(struct usb2_bus *bus)
1502 struct uss820dci_softc *sc = USS820_DCI_BUS2SC(bus);
1504 USB_BUS_LOCK(&sc->sc_bus);
1505 uss820dci_interrupt_poll(sc);
1506 USB_BUS_UNLOCK(&sc->sc_bus);
1509 /*------------------------------------------------------------------------*
1510 * at91dci bulk support
1511 *------------------------------------------------------------------------*/
1513 uss820dci_device_bulk_open(struct usb2_xfer *xfer)
1519 uss820dci_device_bulk_close(struct usb2_xfer *xfer)
1521 uss820dci_device_done(xfer, USB_ERR_CANCELLED);
1525 uss820dci_device_bulk_enter(struct usb2_xfer *xfer)
1531 uss820dci_device_bulk_start(struct usb2_xfer *xfer)
1534 uss820dci_setup_standard_chain(xfer);
1535 uss820dci_start_standard_chain(xfer);
1538 struct usb2_pipe_methods uss820dci_device_bulk_methods =
1540 .open = uss820dci_device_bulk_open,
1541 .close = uss820dci_device_bulk_close,
1542 .enter = uss820dci_device_bulk_enter,
1543 .start = uss820dci_device_bulk_start,
1546 /*------------------------------------------------------------------------*
1547 * at91dci control support
1548 *------------------------------------------------------------------------*/
1550 uss820dci_device_ctrl_open(struct usb2_xfer *xfer)
1556 uss820dci_device_ctrl_close(struct usb2_xfer *xfer)
1558 uss820dci_device_done(xfer, USB_ERR_CANCELLED);
1562 uss820dci_device_ctrl_enter(struct usb2_xfer *xfer)
1568 uss820dci_device_ctrl_start(struct usb2_xfer *xfer)
1571 uss820dci_setup_standard_chain(xfer);
1572 uss820dci_start_standard_chain(xfer);
1575 struct usb2_pipe_methods uss820dci_device_ctrl_methods =
1577 .open = uss820dci_device_ctrl_open,
1578 .close = uss820dci_device_ctrl_close,
1579 .enter = uss820dci_device_ctrl_enter,
1580 .start = uss820dci_device_ctrl_start,
1583 /*------------------------------------------------------------------------*
1584 * at91dci interrupt support
1585 *------------------------------------------------------------------------*/
1587 uss820dci_device_intr_open(struct usb2_xfer *xfer)
1593 uss820dci_device_intr_close(struct usb2_xfer *xfer)
1595 uss820dci_device_done(xfer, USB_ERR_CANCELLED);
1599 uss820dci_device_intr_enter(struct usb2_xfer *xfer)
1605 uss820dci_device_intr_start(struct usb2_xfer *xfer)
1608 uss820dci_setup_standard_chain(xfer);
1609 uss820dci_start_standard_chain(xfer);
1612 struct usb2_pipe_methods uss820dci_device_intr_methods =
1614 .open = uss820dci_device_intr_open,
1615 .close = uss820dci_device_intr_close,
1616 .enter = uss820dci_device_intr_enter,
1617 .start = uss820dci_device_intr_start,
1620 /*------------------------------------------------------------------------*
1621 * at91dci full speed isochronous support
1622 *------------------------------------------------------------------------*/
1624 uss820dci_device_isoc_fs_open(struct usb2_xfer *xfer)
1630 uss820dci_device_isoc_fs_close(struct usb2_xfer *xfer)
1632 uss820dci_device_done(xfer, USB_ERR_CANCELLED);
1636 uss820dci_device_isoc_fs_enter(struct usb2_xfer *xfer)
1638 struct uss820dci_softc *sc = USS820_DCI_BUS2SC(xfer->xroot->bus);
1642 DPRINTFN(6, "xfer=%p next=%d nframes=%d\n",
1643 xfer, xfer->pipe->isoc_next, xfer->nframes);
1645 /* get the current frame index - we don't need the high bits */
1647 nframes = USS820_READ_1(sc, USS820_SOFL);
1650 * check if the frame index is within the window where the
1651 * frames will be inserted
1653 temp = (nframes - xfer->pipe->isoc_next) & USS820_SOFL_MASK;
1655 if ((xfer->pipe->is_synced == 0) ||
1656 (temp < xfer->nframes)) {
1658 * If there is data underflow or the pipe queue is
1659 * empty we schedule the transfer a few frames ahead
1660 * of the current frame position. Else two isochronous
1661 * transfers might overlap.
1663 xfer->pipe->isoc_next = (nframes + 3) & USS820_SOFL_MASK;
1664 xfer->pipe->is_synced = 1;
1665 DPRINTFN(3, "start next=%d\n", xfer->pipe->isoc_next);
1668 * compute how many milliseconds the insertion is ahead of the
1669 * current frame position:
1671 temp = (xfer->pipe->isoc_next - nframes) & USS820_SOFL_MASK;
1674 * pre-compute when the isochronous transfer will be finished:
1676 xfer->isoc_time_complete =
1677 usb2_isoc_time_expand(&sc->sc_bus, nframes) + temp +
1680 /* compute frame number for next insertion */
1681 xfer->pipe->isoc_next += xfer->nframes;
1684 uss820dci_setup_standard_chain(xfer);
1688 uss820dci_device_isoc_fs_start(struct usb2_xfer *xfer)
1690 /* start TD chain */
1691 uss820dci_start_standard_chain(xfer);
1694 struct usb2_pipe_methods uss820dci_device_isoc_fs_methods =
1696 .open = uss820dci_device_isoc_fs_open,
1697 .close = uss820dci_device_isoc_fs_close,
1698 .enter = uss820dci_device_isoc_fs_enter,
1699 .start = uss820dci_device_isoc_fs_start,
1702 /*------------------------------------------------------------------------*
1703 * at91dci root control support
1704 *------------------------------------------------------------------------*
1705 * Simulate a hardware HUB by handling all the necessary requests.
1706 *------------------------------------------------------------------------*/
1708 static const struct usb2_device_descriptor uss820dci_devd = {
1709 .bLength = sizeof(struct usb2_device_descriptor),
1710 .bDescriptorType = UDESC_DEVICE,
1711 .bcdUSB = {0x00, 0x02},
1712 .bDeviceClass = UDCLASS_HUB,
1713 .bDeviceSubClass = UDSUBCLASS_HUB,
1714 .bDeviceProtocol = UDPROTO_HSHUBSTT,
1715 .bMaxPacketSize = 64,
1716 .bcdDevice = {0x00, 0x01},
1719 .bNumConfigurations = 1,
1722 static const struct usb2_device_qualifier uss820dci_odevd = {
1723 .bLength = sizeof(struct usb2_device_qualifier),
1724 .bDescriptorType = UDESC_DEVICE_QUALIFIER,
1725 .bcdUSB = {0x00, 0x02},
1726 .bDeviceClass = UDCLASS_HUB,
1727 .bDeviceSubClass = UDSUBCLASS_HUB,
1728 .bDeviceProtocol = UDPROTO_FSHUB,
1729 .bMaxPacketSize0 = 0,
1730 .bNumConfigurations = 0,
1733 static const struct uss820dci_config_desc uss820dci_confd = {
1735 .bLength = sizeof(struct usb2_config_descriptor),
1736 .bDescriptorType = UDESC_CONFIG,
1737 .wTotalLength[0] = sizeof(uss820dci_confd),
1739 .bConfigurationValue = 1,
1740 .iConfiguration = 0,
1741 .bmAttributes = UC_SELF_POWERED,
1745 .bLength = sizeof(struct usb2_interface_descriptor),
1746 .bDescriptorType = UDESC_INTERFACE,
1748 .bInterfaceClass = UICLASS_HUB,
1749 .bInterfaceSubClass = UISUBCLASS_HUB,
1750 .bInterfaceProtocol = UIPROTO_HSHUBSTT,
1754 .bLength = sizeof(struct usb2_endpoint_descriptor),
1755 .bDescriptorType = UDESC_ENDPOINT,
1756 .bEndpointAddress = (UE_DIR_IN | USS820_DCI_INTR_ENDPT),
1757 .bmAttributes = UE_INTERRUPT,
1758 .wMaxPacketSize[0] = 8,
1763 static const struct usb2_hub_descriptor_min uss820dci_hubd = {
1764 .bDescLength = sizeof(uss820dci_hubd),
1765 .bDescriptorType = UDESC_HUB,
1767 .wHubCharacteristics[0] =
1768 (UHD_PWR_NO_SWITCH | UHD_OC_INDIVIDUAL) & 0xFF,
1769 .wHubCharacteristics[1] =
1770 (UHD_PWR_NO_SWITCH | UHD_OC_INDIVIDUAL) >> 8,
1771 .bPwrOn2PwrGood = 50,
1772 .bHubContrCurrent = 0,
1773 .DeviceRemovable = {0}, /* port is removable */
1776 #define STRING_LANG \
1777 0x09, 0x04, /* American English */
1779 #define STRING_VENDOR \
1780 'A', 0, 'G', 0, 'E', 0, 'R', 0, 'E', 0
1782 #define STRING_PRODUCT \
1783 'D', 0, 'C', 0, 'I', 0, ' ', 0, 'R', 0, \
1784 'o', 0, 'o', 0, 't', 0, ' ', 0, 'H', 0, \
1787 USB_MAKE_STRING_DESC(STRING_LANG, uss820dci_langtab);
1788 USB_MAKE_STRING_DESC(STRING_VENDOR, uss820dci_vendor);
1789 USB_MAKE_STRING_DESC(STRING_PRODUCT, uss820dci_product);
1792 uss820dci_roothub_exec(struct usb2_device *udev,
1793 struct usb2_device_request *req, const void **pptr, uint16_t *plength)
1795 struct uss820dci_softc *sc = USS820_DCI_BUS2SC(udev->bus);
1802 USB_BUS_LOCK_ASSERT(&sc->sc_bus, MA_OWNED);
1805 ptr = (const void *)&sc->sc_hub_temp;
1809 value = UGETW(req->wValue);
1810 index = UGETW(req->wIndex);
1812 /* demultiplex the control request */
1814 switch (req->bmRequestType) {
1815 case UT_READ_DEVICE:
1816 switch (req->bRequest) {
1817 case UR_GET_DESCRIPTOR:
1818 goto tr_handle_get_descriptor;
1820 goto tr_handle_get_config;
1822 goto tr_handle_get_status;
1828 case UT_WRITE_DEVICE:
1829 switch (req->bRequest) {
1830 case UR_SET_ADDRESS:
1831 goto tr_handle_set_address;
1833 goto tr_handle_set_config;
1834 case UR_CLEAR_FEATURE:
1835 goto tr_valid; /* nop */
1836 case UR_SET_DESCRIPTOR:
1837 goto tr_valid; /* nop */
1838 case UR_SET_FEATURE:
1844 case UT_WRITE_ENDPOINT:
1845 switch (req->bRequest) {
1846 case UR_CLEAR_FEATURE:
1847 switch (UGETW(req->wValue)) {
1848 case UF_ENDPOINT_HALT:
1849 goto tr_handle_clear_halt;
1850 case UF_DEVICE_REMOTE_WAKEUP:
1851 goto tr_handle_clear_wakeup;
1856 case UR_SET_FEATURE:
1857 switch (UGETW(req->wValue)) {
1858 case UF_ENDPOINT_HALT:
1859 goto tr_handle_set_halt;
1860 case UF_DEVICE_REMOTE_WAKEUP:
1861 goto tr_handle_set_wakeup;
1866 case UR_SYNCH_FRAME:
1867 goto tr_valid; /* nop */
1873 case UT_READ_ENDPOINT:
1874 switch (req->bRequest) {
1876 goto tr_handle_get_ep_status;
1882 case UT_WRITE_INTERFACE:
1883 switch (req->bRequest) {
1884 case UR_SET_INTERFACE:
1885 goto tr_handle_set_interface;
1886 case UR_CLEAR_FEATURE:
1887 goto tr_valid; /* nop */
1888 case UR_SET_FEATURE:
1894 case UT_READ_INTERFACE:
1895 switch (req->bRequest) {
1896 case UR_GET_INTERFACE:
1897 goto tr_handle_get_interface;
1899 goto tr_handle_get_iface_status;
1905 case UT_WRITE_CLASS_INTERFACE:
1906 case UT_WRITE_VENDOR_INTERFACE:
1910 case UT_READ_CLASS_INTERFACE:
1911 case UT_READ_VENDOR_INTERFACE:
1915 case UT_WRITE_CLASS_DEVICE:
1916 switch (req->bRequest) {
1917 case UR_CLEAR_FEATURE:
1919 case UR_SET_DESCRIPTOR:
1920 case UR_SET_FEATURE:
1927 case UT_WRITE_CLASS_OTHER:
1928 switch (req->bRequest) {
1929 case UR_CLEAR_FEATURE:
1930 goto tr_handle_clear_port_feature;
1931 case UR_SET_FEATURE:
1932 goto tr_handle_set_port_feature;
1933 case UR_CLEAR_TT_BUFFER:
1943 case UT_READ_CLASS_OTHER:
1944 switch (req->bRequest) {
1945 case UR_GET_TT_STATE:
1946 goto tr_handle_get_tt_state;
1948 goto tr_handle_get_port_status;
1954 case UT_READ_CLASS_DEVICE:
1955 switch (req->bRequest) {
1956 case UR_GET_DESCRIPTOR:
1957 goto tr_handle_get_class_descriptor;
1959 goto tr_handle_get_class_status;
1970 tr_handle_get_descriptor:
1971 switch (value >> 8) {
1976 len = sizeof(uss820dci_devd);
1977 ptr = (const void *)&uss820dci_devd;
1983 len = sizeof(uss820dci_confd);
1984 ptr = (const void *)&uss820dci_confd;
1987 switch (value & 0xff) {
1988 case 0: /* Language table */
1989 len = sizeof(uss820dci_langtab);
1990 ptr = (const void *)&uss820dci_langtab;
1993 case 1: /* Vendor */
1994 len = sizeof(uss820dci_vendor);
1995 ptr = (const void *)&uss820dci_vendor;
1998 case 2: /* Product */
1999 len = sizeof(uss820dci_product);
2000 ptr = (const void *)&uss820dci_product;
2011 tr_handle_get_config:
2013 sc->sc_hub_temp.wValue[0] = sc->sc_conf;
2016 tr_handle_get_status:
2018 USETW(sc->sc_hub_temp.wValue, UDS_SELF_POWERED);
2021 tr_handle_set_address:
2022 if (value & 0xFF00) {
2025 sc->sc_rt_addr = value;
2028 tr_handle_set_config:
2032 sc->sc_conf = value;
2035 tr_handle_get_interface:
2037 sc->sc_hub_temp.wValue[0] = 0;
2040 tr_handle_get_tt_state:
2041 tr_handle_get_class_status:
2042 tr_handle_get_iface_status:
2043 tr_handle_get_ep_status:
2045 USETW(sc->sc_hub_temp.wValue, 0);
2049 tr_handle_set_interface:
2050 tr_handle_set_wakeup:
2051 tr_handle_clear_wakeup:
2052 tr_handle_clear_halt:
2055 tr_handle_clear_port_feature:
2059 DPRINTFN(9, "UR_CLEAR_PORT_FEATURE on port %d\n", index);
2062 case UHF_PORT_SUSPEND:
2063 uss820dci_wakeup_peer(sc);
2066 case UHF_PORT_ENABLE:
2067 sc->sc_flags.port_enabled = 0;
2071 case UHF_PORT_INDICATOR:
2072 case UHF_C_PORT_ENABLE:
2073 case UHF_C_PORT_OVER_CURRENT:
2074 case UHF_C_PORT_RESET:
2077 case UHF_PORT_POWER:
2078 sc->sc_flags.port_powered = 0;
2079 uss820dci_pull_down(sc);
2081 case UHF_C_PORT_CONNECTION:
2082 sc->sc_flags.change_connect = 0;
2084 case UHF_C_PORT_SUSPEND:
2085 sc->sc_flags.change_suspend = 0;
2088 err = USB_ERR_IOERROR;
2093 tr_handle_set_port_feature:
2097 DPRINTFN(9, "UR_SET_PORT_FEATURE\n");
2100 case UHF_PORT_ENABLE:
2101 sc->sc_flags.port_enabled = 1;
2103 case UHF_PORT_SUSPEND:
2104 case UHF_PORT_RESET:
2106 case UHF_PORT_INDICATOR:
2109 case UHF_PORT_POWER:
2110 sc->sc_flags.port_powered = 1;
2113 err = USB_ERR_IOERROR;
2118 tr_handle_get_port_status:
2120 DPRINTFN(9, "UR_GET_PORT_STATUS\n");
2125 if (sc->sc_flags.status_vbus) {
2126 uss820dci_pull_up(sc);
2128 uss820dci_pull_down(sc);
2131 /* Select FULL-speed and Device Side Mode */
2133 value = UPS_PORT_MODE_DEVICE;
2135 if (sc->sc_flags.port_powered) {
2136 value |= UPS_PORT_POWER;
2138 if (sc->sc_flags.port_enabled) {
2139 value |= UPS_PORT_ENABLED;
2141 if (sc->sc_flags.status_vbus &&
2142 sc->sc_flags.status_bus_reset) {
2143 value |= UPS_CURRENT_CONNECT_STATUS;
2145 if (sc->sc_flags.status_suspend) {
2146 value |= UPS_SUSPEND;
2148 USETW(sc->sc_hub_temp.ps.wPortStatus, value);
2152 if (sc->sc_flags.change_connect) {
2153 value |= UPS_C_CONNECT_STATUS;
2155 if (sc->sc_flags.change_suspend) {
2156 value |= UPS_C_SUSPEND;
2158 USETW(sc->sc_hub_temp.ps.wPortChange, value);
2159 len = sizeof(sc->sc_hub_temp.ps);
2162 tr_handle_get_class_descriptor:
2166 ptr = (const void *)&uss820dci_hubd;
2167 len = sizeof(uss820dci_hubd);
2171 err = USB_ERR_STALLED;
2180 uss820dci_xfer_setup(struct usb2_setup_params *parm)
2182 const struct usb2_hw_ep_profile *pf;
2183 struct uss820dci_softc *sc;
2184 struct usb2_xfer *xfer;
2190 sc = USS820_DCI_BUS2SC(parm->udev->bus);
2191 xfer = parm->curr_xfer;
2194 * NOTE: This driver does not use any of the parameters that
2195 * are computed from the following values. Just set some
2196 * reasonable dummies:
2198 parm->hc_max_packet_size = 0x500;
2199 parm->hc_max_packet_count = 1;
2200 parm->hc_max_frame_size = 0x500;
2202 usb2_transfer_setup_sub(parm);
2205 * compute maximum number of TDs
2207 if (parm->methods == &uss820dci_device_ctrl_methods) {
2209 ntd = xfer->nframes + 1 /* STATUS */ + 1 /* SYNC */ ;
2211 } else if (parm->methods == &uss820dci_device_bulk_methods) {
2213 ntd = xfer->nframes + 1 /* SYNC */ ;
2215 } else if (parm->methods == &uss820dci_device_intr_methods) {
2217 ntd = xfer->nframes + 1 /* SYNC */ ;
2219 } else if (parm->methods == &uss820dci_device_isoc_fs_methods) {
2221 ntd = xfer->nframes + 1 /* SYNC */ ;
2229 * check if "usb2_transfer_setup_sub" set an error
2235 * allocate transfer descriptors
2244 ep_no = xfer->endpoint & UE_ADDR;
2245 uss820dci_get_hw_ep_profile(parm->udev, &pf, ep_no);
2248 /* should not happen */
2249 parm->err = USB_ERR_INVAL;
2258 parm->size[0] += ((-parm->size[0]) & (USB_HOST_ALIGN - 1));
2260 for (n = 0; n != ntd; n++) {
2262 struct uss820dci_td *td;
2266 td = USB_ADD_BYTES(parm->buf, parm->size[0]);
2269 td->io_tag = sc->sc_io_tag;
2270 td->io_hdl = sc->sc_io_hdl;
2271 td->max_packet_size = xfer->max_packet_size;
2272 td->rx_stat_reg = USS820_GET_REG(sc, USS820_RXSTAT);
2273 td->tx_stat_reg = USS820_GET_REG(sc, USS820_TXSTAT);
2274 td->rx_flag_reg = USS820_GET_REG(sc, USS820_RXFLG);
2275 td->tx_flag_reg = USS820_GET_REG(sc, USS820_TXFLG);
2276 td->rx_fifo_reg = USS820_GET_REG(sc, USS820_RXDAT);
2277 td->tx_fifo_reg = USS820_GET_REG(sc, USS820_TXDAT);
2278 td->rx_count_low_reg = USS820_GET_REG(sc, USS820_RXCNTL);
2279 td->rx_count_high_reg = USS820_GET_REG(sc, USS820_RXCNTH);
2280 td->tx_count_low_reg = USS820_GET_REG(sc, USS820_TXCNTL);
2281 td->tx_count_high_reg = USS820_GET_REG(sc, USS820_TXCNTH);
2282 td->rx_cntl_reg = USS820_GET_REG(sc, USS820_RXCON);
2283 td->tx_cntl_reg = USS820_GET_REG(sc, USS820_TXCON);
2284 td->pend_reg = USS820_GET_REG(sc, USS820_PEND);
2285 td->ep_reg = USS820_GET_REG(sc, USS820_EPINDEX);
2286 td->ep_index = ep_no;
2287 if (pf->support_multi_buffer &&
2288 (parm->methods != &uss820dci_device_ctrl_methods)) {
2289 td->support_multi_buffer = 1;
2291 td->obj_next = last_obj;
2295 parm->size[0] += sizeof(*td);
2298 xfer->td_start[0] = last_obj;
2302 uss820dci_xfer_unsetup(struct usb2_xfer *xfer)
2308 uss820dci_pipe_init(struct usb2_device *udev, struct usb2_endpoint_descriptor *edesc,
2309 struct usb2_pipe *pipe)
2311 struct uss820dci_softc *sc = USS820_DCI_BUS2SC(udev->bus);
2313 DPRINTFN(2, "pipe=%p, addr=%d, endpt=%d, mode=%d (%d)\n",
2314 pipe, udev->address,
2315 edesc->bEndpointAddress, udev->flags.usb2_mode,
2318 if (udev->device_index != sc->sc_rt_addr) {
2320 if (udev->flags.usb2_mode != USB_MODE_DEVICE) {
2324 if (udev->speed != USB_SPEED_FULL) {
2328 switch (edesc->bmAttributes & UE_XFERTYPE) {
2330 pipe->methods = &uss820dci_device_ctrl_methods;
2333 pipe->methods = &uss820dci_device_intr_methods;
2335 case UE_ISOCHRONOUS:
2336 pipe->methods = &uss820dci_device_isoc_fs_methods;
2339 pipe->methods = &uss820dci_device_bulk_methods;
2348 struct usb2_bus_methods uss820dci_bus_methods =
2350 .pipe_init = &uss820dci_pipe_init,
2351 .xfer_setup = &uss820dci_xfer_setup,
2352 .xfer_unsetup = &uss820dci_xfer_unsetup,
2353 .get_hw_ep_profile = &uss820dci_get_hw_ep_profile,
2354 .set_stall = &uss820dci_set_stall,
2355 .clear_stall = &uss820dci_clear_stall,
2356 .roothub_exec = &uss820dci_roothub_exec,