Lines Matching defs:usb
44 * "cvmx-usb.c" defines a set of low level USB functions to help
58 #include <asm/octeon/cvmx-usb.h>
72 #include "cvmx-usb.h"
99 extra debug stuff to the usb specific version and I won't use the normal
229 if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_CALLS)) \
230 cvmx_dprintf("%*s%s: called\n", 2*usb->indent++, "", __FUNCTION__);
234 if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_CALLS)) \
235 cvmx_dprintf("%*s%s: param %s = " format "\n", 2*usb->indent, "", __FUNCTION__, #param, param);
241 if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_CALLS)) \
242 cvmx_dprintf("%*s%s: returned %s(%d)\n", 2*--usb->indent, "", __FUNCTION__, #v, r); \
249 if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_CALLS)) \
250 cvmx_dprintf("%*s%s: returned\n", 2*--usb->indent, "", __FUNCTION__); \
263 c.u32 = __cvmx_usb_read_csr32(usb, address); \
281 c.u32 = __cvmx_usb_read_csr32(usb, address);\
283 __cvmx_usb_write_csr32(usb, address, c.u32);\
295 * @param usb USB block this access is for
300 static inline uint32_t __cvmx_usb_read_csr32(cvmx_usb_internal_state_t *usb,
305 if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_CSRS))
321 * @param usb USB block this access is for
325 static inline void __cvmx_usb_write_csr32(cvmx_usb_internal_state_t *usb,
329 if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_CSRS))
336 cvmx_read64_uint64(CVMX_USBNX_DMA0_INB_CHN0(usb->index));
345 * @param usb USB block this access is for
350 static inline uint64_t __cvmx_usb_read_csr64(cvmx_usb_internal_state_t *usb,
355 if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_CSRS))
370 * @param usb USB block this access is for
374 static inline void __cvmx_usb_write_csr64(cvmx_usb_internal_state_t *usb,
378 if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_CSRS))
420 * @param usb USB block this access is for
425 static inline int __cvmx_usb_pipe_needs_split(cvmx_usb_internal_state_t *usb, cvmx_usb_pipe_t *pipe)
427 return ((pipe->device_speed != CVMX_USB_SPEED_HIGH) && (usb->usbcx_hprt.s.prtspd == CVMX_USB_SPEED_HIGH));
452 * support one usb port, but some support two ports.
459 * @return Number of port, zero if usb isn't supported
487 * Allocate a usb transaction for use
489 * @param usb USB device state populated by
494 static inline cvmx_usb_transaction_t *__cvmx_usb_alloc_transaction(cvmx_usb_internal_state_t *usb)
497 t = usb->free_transaction_head;
500 usb->free_transaction_head = t->next;
501 if (!usb->free_transaction_head)
502 usb->free_transaction_tail = NULL;
504 else if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_INFO))
517 * Free a usb transaction
519 * @param usb USB device state populated by
524 static inline void __cvmx_usb_free_transaction(cvmx_usb_internal_state_t *usb,
530 if (usb->free_transaction_tail)
531 usb->free_transaction_tail->next = transaction;
533 usb->free_transaction_head = transaction;
534 usb->free_transaction_tail = transaction;
613 cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
615 usb->init_flags = flags;
622 if (sizeof(*state) < sizeof(*usb))
624 /* At first allow 0-1 for the usb port number */
661 memset(usb, 0, sizeof(*usb));
662 usb->init_flags = flags;
667 usb->index = usb_port_number;
670 usb->free_transaction_head = NULL;
671 usb->free_transaction_tail = NULL;
673 __cvmx_usb_free_transaction(usb, usb->transaction + i);
675 __cvmx_usb_append_pipe(&usb->free_pipes, usb->pipe + i);
683 usbn_clk_ctl.u64 = __cvmx_usb_read_csr64(usb, CVMX_USBNX_CLK_CTL(usb->index));
691 if (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_CLOCK_XO_GND)
745 __cvmx_usb_write_csr64(usb, CVMX_USBNX_CLK_CTL(usb->index),
749 __cvmx_usb_write_csr64(usb, CVMX_USBNX_CLK_CTL(usb->index),
756 __cvmx_usb_write_csr64(usb, CVMX_USBNX_CLK_CTL(usb->index),
762 usbn_usbp_ctl_status.u64 = __cvmx_usb_read_csr64(usb, CVMX_USBNX_USBP_CTL_STATUS(usb->index));
764 __cvmx_usb_write_csr64(usb, CVMX_USBNX_USBP_CTL_STATUS(usb->index),
771 __cvmx_usb_write_csr64(usb, CVMX_USBNX_USBP_CTL_STATUS(usb->index),
776 __cvmx_usb_write_csr64(usb, CVMX_USBNX_CLK_CTL(usb->index),
782 __cvmx_usb_write_csr64(usb, CVMX_USBNX_USBP_CTL_STATUS(usb->index),
789 __cvmx_usb_write_csr64(usb, CVMX_USBNX_CLK_CTL(usb->index),
793 __cvmx_usb_write_csr64(usb, CVMX_USBNX_CLK_CTL(usb->index),
815 usb->init_flags |= CVMX_USB_INITIALIZE_FLAGS_NO_DMA;
817 usbcx_gahbcfg.s.dmaen = !(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_NO_DMA);
818 if (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_NO_DMA)
819 usb->idle_hardware_channels = 0x1; /* Only use one channel with non DMA */
821 usb->idle_hardware_channels = 0xf7; /* CN5XXX have an errata with channel 3 */
823 usb->idle_hardware_channels = 0xff;
828 __cvmx_usb_write_csr32(usb, CVMX_USBCX_GAHBCFG(usb->index),
838 usbcx_gusbcfg.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_GUSBCFG(usb->index));
843 __cvmx_usb_write_csr32(usb, CVMX_USBCX_GUSBCFG(usb->index),
854 usbcx_gintmsk.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_GINTMSK(usb->index));
860 if (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_NO_DMA)
862 __cvmx_usb_write_csr32(usb, CVMX_USBCX_GINTMSK(usb->index),
867 __cvmx_usb_write_csr32(usb, CVMX_USBCX_HCINTMSKX(channel, usb->index), 0);
872 if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_INFO))
873 cvmx_dprintf("%s: USB%d is in host mode\n", __FUNCTION__, usb->index);
877 USB_SET_FIELD32(CVMX_USBCX_GINTMSK(usb->index), cvmx_usbcx_gintmsk_t,
879 USB_SET_FIELD32(CVMX_USBCX_GINTMSK(usb->index), cvmx_usbcx_gintmsk_t,
885 usbcx_hcfg.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HCFG(usb->index));
888 __cvmx_usb_write_csr32(usb, CVMX_USBCX_HCFG(usb->index), usbcx_hcfg.u32);
892 USB_SET_FIELD32(CVMX_USBCX_HPRT(usb->index), cvmx_usbcx_hprt_t, prtpwr, 1);
898 cvmx_error_enable_group(CVMX_ERROR_GROUP_USB, usb->index);
921 cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
927 if (usb->idle_pipes.head ||
928 usb->active_pipes[CVMX_USB_TRANSFER_ISOCHRONOUS].head ||
929 usb->active_pipes[CVMX_USB_TRANSFER_INTERRUPT].head ||
930 usb->active_pipes[CVMX_USB_TRANSFER_CONTROL].head ||
931 usb->active_pipes[CVMX_USB_TRANSFER_BULK].head)
935 cvmx_error_disable_group(CVMX_ERROR_GROUP_USB, usb->index);
939 usbn_clk_ctl.u64 = __cvmx_usb_read_csr64(usb, CVMX_USBNX_CLK_CTL(usb->index));
945 __cvmx_usb_write_csr64(usb, CVMX_USBNX_CLK_CTL(usb->index),
967 cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
972 usb->usbcx_hprt.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HPRT(usb->index));
976 if (usb->usbcx_hprt.s.prtena)
980 if (!usb->usbcx_hprt.s.prtconnsts)
982 if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_INFO))
983 cvmx_dprintf("%s: USB%d Nothing plugged into the port\n", __FUNCTION__, usb->index);
988 USB_SET_FIELD32(CVMX_USBCX_HPRT(usb->index), cvmx_usbcx_hprt_t, prtrst, 1);
995 USB_SET_FIELD32(CVMX_USBCX_HPRT(usb->index), cvmx_usbcx_hprt_t, prtrst, 0);
998 if (CVMX_WAIT_FOR_FIELD32(CVMX_USBCX_HPRT(usb->index), cvmx_usbcx_hprt_t,
1001 if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_INFO))
1008 usb->usbcx_hprt.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HPRT(usb->index));
1009 if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_INFO))
1010 cvmx_dprintf("%s: USB%d is in %s speed mode\n", __FUNCTION__, usb->index,
1011 (usb->usbcx_hprt.s.prtspd == CVMX_USB_SPEED_HIGH) ? "high" :
1012 (usb->usbcx_hprt.s.prtspd == CVMX_USB_SPEED_FULL) ? "full" :
1015 usbcx_ghwcfg3.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_GHWCFG3(usb->index));
1019 USB_SET_FIELD32(CVMX_USBCX_GRXFSIZ(usb->index), cvmx_usbcx_grxfsiz_t,
1026 siz.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_GNPTXFSIZ(usb->index));
1029 __cvmx_usb_write_csr32(usb, CVMX_USBCX_GNPTXFSIZ(usb->index), siz.u32);
1035 siz.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HPTXFSIZ(usb->index));
1038 __cvmx_usb_write_csr32(usb, CVMX_USBCX_HPTXFSIZ(usb->index), siz.u32);
1041 USB_SET_FIELD32(CVMX_USBCX_GRSTCTL(usb->index), cvmx_usbcx_grstctl_t, txfnum, 0x10);
1042 USB_SET_FIELD32(CVMX_USBCX_GRSTCTL(usb->index), cvmx_usbcx_grstctl_t, txfflsh, 1);
1043 CVMX_WAIT_FOR_FIELD32(CVMX_USBCX_GRSTCTL(usb->index), cvmx_usbcx_grstctl_t,
1045 USB_SET_FIELD32(CVMX_USBCX_GRSTCTL(usb->index), cvmx_usbcx_grstctl_t, rxfflsh, 1);
1046 CVMX_WAIT_FOR_FIELD32(CVMX_USBCX_GRSTCTL(usb->index), cvmx_usbcx_grstctl_t,
1070 cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
1076 USB_SET_FIELD32(CVMX_USBCX_HPRT(usb->index), cvmx_usbcx_hprt_t, prtena, 1);
1086 * determine if the usb port has anything connected, is enabled,
1102 cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
1109 usbc_hprt.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HPRT(usb->index));
1115 result.connect_change = (result.connected != usb->port_status.connected);
1117 if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_CALLS))
1119 2*(--usb->indent), "", __FUNCTION__,
1147 cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
1150 usb->port_status = port_status;
1162 * @param usb USB device state populated by
1169 static inline int __cvmx_usb_get_submit_handle(cvmx_usb_internal_state_t *usb,
1172 return ((unsigned long)transaction - (unsigned long)usb->transaction) /
1181 * @param usb USB device state populated by
1187 static inline int __cvmx_usb_get_pipe_handle(cvmx_usb_internal_state_t *usb,
1190 return ((unsigned long)pipe - (unsigned long)usb->pipe) / sizeof(*pipe);
1258 cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
1302 pipe = usb->free_pipes.head;
1305 __cvmx_usb_remove_pipe(&usb->free_pipes, pipe);
1321 if (__cvmx_usb_pipe_needs_split(usb, pipe))
1325 pipe->next_tx_frame = ((usb->frame_number+7)&~7) + pipe->interval;
1330 pipe->next_tx_frame = usb->frame_number + pipe->interval;
1337 __cvmx_usb_append_pipe(&usb->idle_pipes, pipe);
1342 CVMX_USB_RETURN(__cvmx_usb_get_pipe_handle(usb, pipe));
1355 * @param usb USB device state populated by
1358 static void __cvmx_usb_poll_rx_fifo(cvmx_usb_internal_state_t *usb)
1367 CVMX_USB_LOG_PARAM("%p", usb);
1369 rx_status.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_GRXSTSPH(usb->index));
1383 address = __cvmx_usb_read_csr64(usb, CVMX_USBNX_DMA0_INB_CHN0(usb->index) + channel*8);
1385 __cvmx_usb_write_csr64(usb, CVMX_USBNX_DMA0_INB_CHN0(usb->index) + channel*8, address + bytes);
1390 *ptr++ = __cvmx_usb_read_csr32(usb, USB_FIFO_ADDRESS(channel, usb->index));
1403 * @param usb USB device state populated by
1411 static int __cvmx_usb_fill_tx_hw(cvmx_usb_internal_state_t *usb, cvmx_usb_tx_fifo_t *fifo, int available)
1414 CVMX_USB_LOG_PARAM("%p", usb);
1424 uint64_t csr_address = USB_FIFO_ADDRESS(fifo->entry[i].channel, usb->index) ^ 4;
1448 cvmx_read64_uint64(CVMX_USBNX_DMA0_INB_CHN0(usb->index));
1458 cvmx_read64_uint64(CVMX_USBNX_DMA0_INB_CHN0(usb->index));
1467 * @param usb USB device state populated by
1470 static void __cvmx_usb_poll_tx_fifo(cvmx_usb_internal_state_t *usb)
1473 CVMX_USB_LOG_PARAM("%p", usb);
1475 if (usb->periodic.head != usb->periodic.tail)
1478 tx_status.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HPTXSTS(usb->index));
1479 if (__cvmx_usb_fill_tx_hw(usb, &usb->periodic, tx_status.s.ptxfspcavail))
1480 USB_SET_FIELD32(CVMX_USBCX_GINTMSK(usb->index), cvmx_usbcx_gintmsk_t, ptxfempmsk, 1);
1482 USB_SET_FIELD32(CVMX_USBCX_GINTMSK(usb->index), cvmx_usbcx_gintmsk_t, ptxfempmsk, 0);
1485 if (usb->nonperiodic.head != usb->nonperiodic.tail)
1488 tx_status.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_GNPTXSTS(usb->index));
1489 if (__cvmx_usb_fill_tx_hw(usb, &usb->nonperiodic, tx_status.s.nptxfspcavail))
1490 USB_SET_FIELD32(CVMX_USBCX_GINTMSK(usb->index), cvmx_usbcx_gintmsk_t, nptxfempmsk, 1);
1492 USB_SET_FIELD32(CVMX_USBCX_GINTMSK(usb->index), cvmx_usbcx_gintmsk_t, nptxfempmsk, 0);
1503 * @param usb USB device state populated by
1507 static void __cvmx_usb_fill_tx_fifo(cvmx_usb_internal_state_t *usb, int channel)
1515 CVMX_USB_LOG_PARAM("%p", usb);
1519 hcchar.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HCCHARX(channel, usb->index));
1524 usbc_hcsplt.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HCSPLTX(channel, usb->index));
1529 usbc_hctsiz.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HCTSIZX(channel, usb->index));
1535 fifo = &usb->periodic;
1537 fifo = &usb->nonperiodic;
1540 fifo->entry[fifo->head].address = __cvmx_usb_read_csr64(usb, CVMX_USBNX_DMA0_OUTB_CHN0(usb->index) + channel*8);
1546 __cvmx_usb_poll_tx_fifo(usb);
1557 * @param usb USB device state populated by
1562 static void __cvmx_usb_start_channel_control(cvmx_usb_internal_state_t *usb,
1573 CVMX_USB_LOG_PARAM("%p", usb);
1577 usbc_hctsiz.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HCTSIZX(channel, usb->index));
1589 USB_SET_FIELD32(CVMX_USBCX_HCCHARX(channel, usb->index), cvmx_usbcx_hccharx_t, epdir, CVMX_USB_DIRECTION_OUT);
1592 __cvmx_usb_write_csr64(usb, CVMX_USBNX_DMA0_OUTB_CHN0(usb->index) + channel*8, transaction->control_header);
1598 USB_SET_FIELD32(CVMX_USBCX_HCCHARX(channel, usb->index), cvmx_usbcx_hccharx_t, epdir, CVMX_USB_DIRECTION_OUT);
1599 USB_SET_FIELD32(CVMX_USBCX_HCSPLTX(channel, usb->index), cvmx_usbcx_hcspltx_t, compsplt, 1);
1603 if (__cvmx_usb_pipe_needs_split(usb, pipe))
1610 USB_SET_FIELD32(CVMX_USBCX_HCCHARX(channel, usb->index),
1620 USB_SET_FIELD32(CVMX_USBCX_HCCHARX(channel, usb->index),
1625 USB_SET_FIELD32(CVMX_USBCX_HCSPLTX(channel, usb->index), cvmx_usbcx_hcspltx_t, compsplt, 1);
1630 USB_SET_FIELD32(CVMX_USBCX_HCCHARX(channel, usb->index), cvmx_usbcx_hccharx_t, epdir,
1638 USB_SET_FIELD32(CVMX_USBCX_HCCHARX(channel, usb->index), cvmx_usbcx_hccharx_t, epdir,
1642 USB_SET_FIELD32(CVMX_USBCX_HCSPLTX(channel, usb->index), cvmx_usbcx_hcspltx_t, compsplt, 1);
1660 else if ((packets_to_transfer>1) && (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_NO_DMA))
1679 __cvmx_usb_write_csr32(usb, CVMX_USBCX_HCTSIZX(channel, usb->index), usbc_hctsiz.u32);
1688 * @param usb USB device state populated by
1693 static void __cvmx_usb_start_channel(cvmx_usb_internal_state_t *usb,
1700 CVMX_USB_LOG_PARAM("%p", usb);
1704 if (cvmx_unlikely((usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_TRANSFERS) ||
1707 __FUNCTION__, channel, __cvmx_usb_get_pipe_handle(usb, pipe),
1708 __cvmx_usb_get_submit_handle(usb, transaction),
1715 usb->pipe_for_channel[channel] = pipe;
1720 usb->idle_hardware_channels &= ~(1<<channel);
1729 usbc_hcint.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HCINTX(channel, usb->index));
1730 __cvmx_usb_write_csr32(usb, CVMX_USBCX_HCINTX(channel, usb->index), usbc_hcint.u32);
1734 if (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_NO_DMA)
1741 if (__cvmx_usb_pipe_needs_split(usb, pipe))
1751 __cvmx_usb_write_csr32(usb, CVMX_USBCX_HCINTMSKX(channel, usb->index), usbc_hcintmsk.u32);
1754 usbc_haintmsk.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HAINTMSK(usb->index));
1756 __cvmx_usb_write_csr32(usb, CVMX_USBCX_HAINTMSK(usb->index), usbc_haintmsk.u32);
1764 __cvmx_usb_write_csr64(usb, CVMX_USBNX_DMA0_OUTB_CHN0(usb->index) + channel*8, dma_address);
1765 __cvmx_usb_write_csr64(usb, CVMX_USBNX_DMA0_INB_CHN0(usb->index) + channel*8, dma_address);
1782 if (__cvmx_usb_pipe_needs_split(usb, pipe))
1790 pipe->split_sc_frame = (usb->frame_number + 1) & 0x7f;
1792 pipe->split_sc_frame = (usb->frame_number + 2) & 0x7f;
1856 else if ((packets_to_transfer>1) && (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_NO_DMA))
1881 __cvmx_usb_write_csr32(usb, CVMX_USBCX_HCSPLTX(channel, usb->index), usbc_hcsplt.u32);
1882 __cvmx_usb_write_csr32(usb, CVMX_USBCX_HCTSIZX(channel, usb->index), usbc_hctsiz.u32);
1890 usbc_hcchar.s.oddfrm = usb->frame_number&1;
1896 if (__cvmx_usb_pipe_needs_split(usb, pipe))
1912 __cvmx_usb_write_csr32(usb, CVMX_USBCX_HCCHARX(channel, usb->index), usbc_hcchar.u32);
1919 __cvmx_usb_start_channel_control(usb, channel, pipe);
1925 if (!__cvmx_usb_pipe_needs_split(usb, pipe))
1932 USB_SET_FIELD32(CVMX_USBCX_HCTSIZX(channel, usb->index), cvmx_usbcx_hctsizx_t, pid, 0);
1934 USB_SET_FIELD32(CVMX_USBCX_HCTSIZX(channel, usb->index), cvmx_usbcx_hctsizx_t, pid, 3);
1940 cvmx_usbcx_hctsizx_t usbc_hctsiz = {.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HCTSIZX(channel, usb->index))};
1945 if (__cvmx_usb_pipe_needs_split(usb, pipe))
1946 usb->active_split = transaction;
1947 USB_SET_FIELD32(CVMX_USBCX_HCCHARX(channel, usb->index), cvmx_usbcx_hccharx_t, chena, 1);
1948 if (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_NO_DMA)
1949 __cvmx_usb_fill_tx_fifo(usb, channel);
1957 * @param usb USB device state populated by
1965 static cvmx_usb_pipe_t *__cvmx_usb_find_ready_pipe(cvmx_usb_internal_state_t *usb, cvmx_usb_pipe_list_t *list, uint64_t current_frame)
1973 (!usb->active_split || (usb->active_split == pipe->head)))
1990 * @param usb USB device state populated by
1994 static void __cvmx_usb_schedule(cvmx_usb_internal_state_t *usb, int is_sof)
2002 CVMX_USB_LOG_PARAM("%p", usb);
2004 if (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_NO_DMA)
2007 cvmx_usbcx_hfnum_t hfnum = {.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HFNUM(usb->index))};
2008 cvmx_usbcx_hfir_t hfir = {.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HFIR(usb->index))};
2013 while (usb->idle_hardware_channels)
2016 CVMX_CLZ(channel, usb->idle_hardware_channels);
2020 if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_INFO))
2032 pipe = __cvmx_usb_find_ready_pipe(usb, usb->active_pipes + CVMX_USB_TRANSFER_ISOCHRONOUS, usb->frame_number);
2034 pipe = __cvmx_usb_find_ready_pipe(usb, usb->active_pipes + CVMX_USB_TRANSFER_INTERRUPT, usb->frame_number);
2038 pipe = __cvmx_usb_find_ready_pipe(usb, usb->active_pipes + CVMX_USB_TRANSFER_CONTROL, usb->frame_number);
2040 pipe = __cvmx_usb_find_ready_pipe(usb, usb->active_pipes + CVMX_USB_TRANSFER_BULK, usb->frame_number);
2048 if (cvmx_unlikely((usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_TRANSFERS) ||
2072 __FUNCTION__, __cvmx_usb_get_pipe_handle(usb, pipe),
2073 __cvmx_usb_get_submit_handle(usb, transaction),
2078 __cvmx_usb_start_channel(usb, channel, pipe);
2087 pipe = usb->active_pipes[ttype].head;
2090 if (pipe->next_tx_frame > usb->frame_number)
2098 USB_SET_FIELD32(CVMX_USBCX_GINTMSK(usb->index), cvmx_usbcx_gintmsk_t, sofmsk, need_sof);
2107 * @param usb USB device state populated by
2116 static void __cvmx_usb_perform_callback(cvmx_usb_internal_state_t *usb,
2122 cvmx_usb_callback_func_t callback = usb->callback[reason];
2123 void *user_data = usb->callback_data[reason];
2129 pipe_handle = __cvmx_usb_get_pipe_handle(usb, pipe);
2133 submit_handle = __cvmx_usb_get_submit_handle(usb, transaction);
2146 if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_CALLBACKS))
2147 cvmx_dprintf("%*s%s: calling callback %p(usb=%p, complete_code=%s, "
2149 2*usb->indent, "", __FUNCTION__, callback, usb,
2153 callback((cvmx_usb_state_t *)usb, reason, complete_code, pipe_handle, submit_handle,
2156 if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_CALLBACKS))
2157 cvmx_dprintf("%*s%s: callback %p complete\n", 2*usb->indent, "",
2167 * @param usb USB device state populated by
2175 static void __cvmx_usb_perform_complete(cvmx_usb_internal_state_t * usb,
2181 CVMX_USB_LOG_PARAM("%p", usb);
2187 if (usb->active_split == transaction)
2188 usb->active_split = NULL;
2221 __cvmx_usb_remove_pipe(usb->active_pipes + pipe->transfer_type, pipe);
2222 __cvmx_usb_append_pipe(&usb->idle_pipes, pipe);
2225 __cvmx_usb_perform_callback(usb, pipe, transaction,
2228 __cvmx_usb_free_transaction(usb, transaction);
2236 * Submit a usb transaction to a pipe. Called for all types
2239 * @param usb
2261 static int __cvmx_usb_submit_transaction(cvmx_usb_internal_state_t *usb,
2276 cvmx_usb_pipe_t *pipe = usb->pipe + pipe_handle;
2287 transaction = __cvmx_usb_alloc_transaction(usb);
2314 if (pipe->next_tx_frame < usb->frame_number)
2315 pipe->next_tx_frame = usb->frame_number + pipe->interval -
2316 (usb->frame_number - pipe->next_tx_frame) % pipe->interval;
2319 __cvmx_usb_remove_pipe(&usb->idle_pipes, pipe);
2320 __cvmx_usb_append_pipe(usb->active_pipes + pipe->transfer_type, pipe);
2324 submit_handle = __cvmx_usb_get_submit_handle(usb, transaction);
2328 __cvmx_usb_schedule(usb, 0);
2371 cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
2385 submit_handle = __cvmx_usb_submit_transaction(usb, pipe_handle,
2440 cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
2454 submit_handle = __cvmx_usb_submit_transaction(usb, pipe_handle,
2514 cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
2535 submit_handle = __cvmx_usb_submit_transaction(usb, pipe_handle,
2607 cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
2633 submit_handle = __cvmx_usb_submit_transaction(usb, pipe_handle,
2672 cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
2673 cvmx_usb_pipe_t *pipe = usb->pipe + pipe_handle;
2689 transaction = usb->transaction + submit_handle;
2702 usb->pipe_for_channel[pipe->channel] = NULL;
2707 usbc_hcchar.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HCCHARX(pipe->channel, usb->index));
2712 __cvmx_usb_write_csr32(usb, CVMX_USBCX_HCCHARX(pipe->channel, usb->index), usbc_hcchar.u32);
2715 __cvmx_usb_perform_complete(usb, pipe, transaction, CVMX_USB_COMPLETE_CANCEL);
2737 cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
2738 cvmx_usb_pipe_t *pipe = usb->pipe + pipe_handle;
2754 __cvmx_usb_get_submit_handle(usb, pipe->head));
2779 cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
2780 cvmx_usb_pipe_t *pipe = usb->pipe + pipe_handle;
2797 __cvmx_usb_remove_pipe(&usb->idle_pipes, pipe);
2798 __cvmx_usb_append_pipe(&usb->free_pipes, pipe);
2824 cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
2836 usb->callback[reason] = callback;
2837 usb->callback_data[reason] = user_data;
2858 cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
2864 usbc_hfnum.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HFNUM(usb->index));
2878 * @param usb USB device
2883 static int __cvmx_usb_poll_channel(cvmx_usb_internal_state_t *usb, int channel)
2895 CVMX_USB_LOG_PARAM("%p", usb);
2899 usbc_hcint.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HCINTX(channel, usb->index));
2916 if (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_NO_DMA)
2918 usbc_hcchar.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HCCHARX(channel, usb->index));
2925 __cvmx_usb_write_csr32(usb, CVMX_USBCX_HCCHARX(channel, usb->index), usbc_hcchar.u32);
2939 __cvmx_usb_write_csr32(usb, CVMX_USBCX_HCINTMSKX(channel, usb->index), hcintmsk.u32);
2941 __cvmx_usb_write_csr32(usb, CVMX_USBCX_HCCHARX(channel, usb->index), usbc_hcchar.u32);
2950 cvmx_dprintf("USB%d: Channel %d interrupt without halt\n", usb->index, channel);
2964 __cvmx_usb_write_csr32(usb, CVMX_USBCX_HCINTMSKX(channel, usb->index), 0);
2965 usb->idle_hardware_channels |= (1<<channel);
2968 pipe = usb->pipe_for_channel[channel];
2978 usb->pipe_for_channel[channel] = NULL;
2983 usbc_hcchar.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HCCHARX(channel, usb->index));
2984 usbc_hctsiz.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HCTSIZX(channel, usb->index));
3023 if (cvmx_unlikely((usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_TRANSFERS) ||
3027 __cvmx_usb_get_pipe_handle(usb, pipe),
3028 __cvmx_usb_get_submit_handle(usb, transaction),
3059 __cvmx_usb_perform_complete(usb, pipe, transaction, CVMX_USB_COMPLETE_STALL);
3071 __cvmx_usb_perform_complete(usb, pipe, transaction, CVMX_USB_COMPLETE_XACTERR);
3076 if (usb->active_split == transaction)
3077 usb->active_split = NULL;
3083 if (pipe->next_tx_frame < usb->frame_number)
3084 pipe->next_tx_frame = usb->frame_number + pipe->interval -
3085 (usb->frame_number - pipe->next_tx_frame) % pipe->interval;
3091 __cvmx_usb_perform_complete(usb, pipe, transaction, CVMX_USB_COMPLETE_BABBLEERR);
3104 if (!__cvmx_usb_pipe_needs_split(usb, pipe))
3110 __cvmx_usb_perform_complete(usb, pipe, transaction, CVMX_USB_COMPLETE_SUCCESS);
3148 __cvmx_usb_perform_complete(usb, pipe, transaction, CVMX_USB_COMPLETE_ERROR);
3152 if (__cvmx_usb_pipe_needs_split(usb, pipe))
3173 if (__cvmx_usb_pipe_needs_split(usb, pipe))
3205 if (__cvmx_usb_pipe_needs_split(usb, pipe))
3208 __cvmx_usb_perform_complete(usb, pipe, transaction, CVMX_USB_COMPLETE_SUCCESS);
3211 __cvmx_usb_perform_complete(usb, pipe, transaction, CVMX_USB_COMPLETE_SUCCESS);
3221 if (__cvmx_usb_pipe_needs_split(usb, pipe))
3233 __cvmx_usb_perform_complete(usb, pipe, transaction, CVMX_USB_COMPLETE_SUCCESS);
3248 __cvmx_usb_perform_complete(usb, pipe, transaction, CVMX_USB_COMPLETE_SUCCESS);
3253 if (__cvmx_usb_pipe_needs_split(usb, pipe))
3267 __cvmx_usb_perform_complete(usb, pipe, transaction, CVMX_USB_COMPLETE_SUCCESS);
3280 __cvmx_usb_perform_complete(usb, pipe, transaction, CVMX_USB_COMPLETE_SUCCESS);
3290 __cvmx_usb_perform_complete(usb, pipe, transaction, CVMX_USB_COMPLETE_SUCCESS);
3298 if (usb->active_split == transaction)
3299 usb->active_split = NULL;
3307 if (pipe->next_tx_frame < usb->frame_number)
3308 pipe->next_tx_frame = usb->frame_number + pipe->interval -
3309 (usb->frame_number - pipe->next_tx_frame) % pipe->interval;
3314 port = cvmx_usb_get_status((cvmx_usb_state_t *)usb);
3324 __cvmx_usb_perform_complete(usb, pipe, transaction, CVMX_USB_COMPLETE_ERROR);
3347 cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
3349 CVMX_PREFETCH(usb, 0);
3350 CVMX_PREFETCH(usb, 1*128);
3351 CVMX_PREFETCH(usb, 2*128);
3352 CVMX_PREFETCH(usb, 3*128);
3353 CVMX_PREFETCH(usb, 4*128);
3359 usbc_hfnum.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HFNUM(usb->index));
3360 if ((usb->frame_number&0x3fff) > usbc_hfnum.s.frnum)
3361 usb->frame_number += 0x4000;
3362 usb->frame_number &= ~0x3fffull;
3363 usb->frame_number |= usbc_hfnum.s.frnum;
3366 usbc_gintsts.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_GINTSTS(usb->index));
3369 __cvmx_usb_write_csr32(usb, CVMX_USBCX_GINTSTS(usb->index), usbc_gintsts.u32);
3377 if (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_NO_DMA)
3378 __cvmx_usb_poll_rx_fifo(usb);
3383 if (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_NO_DMA)
3384 __cvmx_usb_poll_tx_fifo(usb);
3401 __cvmx_usb_perform_callback(usb, NULL, NULL,
3405 usbc_hprt.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HPRT(usb->index));
3407 __cvmx_usb_write_csr32(usb, CVMX_USBCX_HPRT(usb->index), usbc_hprt.u32);
3421 usbc_haint.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HAINT(usb->index));
3427 __cvmx_usb_poll_channel(usb, channel);
3432 __cvmx_usb_schedule(usb, usbc_gintsts.s.sof);
3442 cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
3443 cvmx_usb_pipe_t *pipe = usb->pipe + endpoint_num;
3450 cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
3451 cvmx_usb_pipe_t *pipe = usb->pipe + endpoint_num;