Lines Matching defs:usb
48 #include <linux/usb.h>
51 #include <linux/usb/hcd.h>
391 c.u32 = cvmx_usb_read_csr32(usb, address); \
393 cvmx_usb_write_csr32(usb, address, c.u32); \
519 * @usb: USB block this access is for
524 static inline u32 cvmx_usb_read_csr32(struct octeon_hcd *usb, u64 address)
534 * @usb: USB block this access is for
538 static inline void cvmx_usb_write_csr32(struct octeon_hcd *usb,
542 cvmx_read64_uint64(CVMX_USBNX_DMA0_INB_CHN0(usb->index));
549 * @usb: USB block this access is for
554 static inline int cvmx_usb_pipe_needs_split(struct octeon_hcd *usb,
558 usb->usbcx_hprt.s.prtspd == CVMX_USB_SPEED_HIGH;
576 static int cvmx_wait_tx_rx(struct octeon_hcd *usb, int fflsh_type)
579 u64 address = CVMX_USBCX_GRSTCTL(usb->index);
585 c.u32 = cvmx_usb_read_csr32(usb, address);
602 static void cvmx_fifo_setup(struct octeon_hcd *usb)
608 usbcx_ghwcfg3.u32 = cvmx_usb_read_csr32(usb,
609 CVMX_USBCX_GHWCFG3(usb->index));
615 USB_SET_FIELD32(CVMX_USBCX_GRXFSIZ(usb->index), cvmx_usbcx_grxfsiz,
623 npsiz.u32 = cvmx_usb_read_csr32(usb, CVMX_USBCX_GNPTXFSIZ(usb->index));
626 cvmx_usb_write_csr32(usb, CVMX_USBCX_GNPTXFSIZ(usb->index), npsiz.u32);
633 psiz.u32 = cvmx_usb_read_csr32(usb, CVMX_USBCX_HPTXFSIZ(usb->index));
636 cvmx_usb_write_csr32(usb, CVMX_USBCX_HPTXFSIZ(usb->index), psiz.u32);
639 USB_SET_FIELD32(CVMX_USBCX_GRSTCTL(usb->index),
641 USB_SET_FIELD32(CVMX_USBCX_GRSTCTL(usb->index),
643 cvmx_wait_tx_rx(usb, 0);
644 USB_SET_FIELD32(CVMX_USBCX_GRSTCTL(usb->index),
646 cvmx_wait_tx_rx(usb, 1);
654 * @usb: USB device state populated by cvmx_usb_initialize().
658 static int cvmx_usb_shutdown(struct octeon_hcd *usb)
663 if (!list_empty(&usb->idle_pipes) ||
664 !list_empty(&usb->active_pipes[CVMX_USB_TRANSFER_ISOCHRONOUS]) ||
665 !list_empty(&usb->active_pipes[CVMX_USB_TRANSFER_INTERRUPT]) ||
666 !list_empty(&usb->active_pipes[CVMX_USB_TRANSFER_CONTROL]) ||
667 !list_empty(&usb->active_pipes[CVMX_USB_TRANSFER_BULK]))
671 usbn_clk_ctl.u64 = cvmx_read64_uint64(CVMX_USBNX_CLK_CTL(usb->index));
677 cvmx_write64_uint64(CVMX_USBNX_CLK_CTL(usb->index), usbn_clk_ctl.u64);
687 * @usb: Pointer to struct octeon_hcd.
692 struct octeon_hcd *usb)
714 usbn_clk_ctl.u64 = cvmx_read64_uint64(CVMX_USBNX_CLK_CTL(usb->index));
724 if (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_CLOCK_XO_GND) {
739 switch (usb->init_flags &
776 cvmx_write64_uint64(CVMX_USBNX_CLK_CTL(usb->index), usbn_clk_ctl.u64);
780 cvmx_write64_uint64(CVMX_USBNX_CLK_CTL(usb->index), usbn_clk_ctl.u64);
789 cvmx_write64_uint64(CVMX_USBNX_CLK_CTL(usb->index), usbn_clk_ctl.u64);
798 cvmx_read64_uint64(CVMX_USBNX_USBP_CTL_STATUS(usb->index));
800 cvmx_write64_uint64(CVMX_USBNX_USBP_CTL_STATUS(usb->index),
809 cvmx_write64_uint64(CVMX_USBNX_USBP_CTL_STATUS(usb->index),
816 cvmx_write64_uint64(CVMX_USBNX_CLK_CTL(usb->index), usbn_clk_ctl.u64);
823 cvmx_write64_uint64(CVMX_USBNX_USBP_CTL_STATUS(usb->index),
832 cvmx_write64_uint64(CVMX_USBNX_CLK_CTL(usb->index), usbn_clk_ctl.u64);
835 cvmx_write64_uint64(CVMX_USBNX_CLK_CTL(usb->index), usbn_clk_ctl.u64);
857 usbcx_gahbcfg.s.dmaen = !(usb->init_flags &
863 cvmx_usb_write_csr32(usb, CVMX_USBCX_GAHBCFG(usb->index),
873 usbcx_gusbcfg.u32 = cvmx_usb_read_csr32(usb,
874 CVMX_USBCX_GUSBCFG(usb->index));
879 cvmx_usb_write_csr32(usb, CVMX_USBCX_GUSBCFG(usb->index),
888 usbcx_gintmsk.u32 = cvmx_usb_read_csr32(usb,
889 CVMX_USBCX_GINTMSK(usb->index));
895 if (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_NO_DMA)
897 cvmx_usb_write_csr32(usb, CVMX_USBCX_GINTMSK(usb->index),
904 cvmx_usb_write_csr32(usb,
905 CVMX_USBCX_HCINTMSKX(channel, usb->index),
914 USB_SET_FIELD32(CVMX_USBCX_GINTMSK(usb->index),
916 USB_SET_FIELD32(CVMX_USBCX_GINTMSK(usb->index),
923 usbcx_hcfg.u32 = cvmx_usb_read_csr32(usb, CVMX_USBCX_HCFG(usb->index));
926 cvmx_usb_write_csr32(usb, CVMX_USBCX_HCFG(usb->index), usbcx_hcfg.u32);
928 cvmx_fifo_setup(usb);
935 usbc_gintsts.u32 = cvmx_usb_read_csr32(usb,
936 CVMX_USBCX_GINTSTS(usb->index));
937 cvmx_usb_write_csr32(usb, CVMX_USBCX_GINTSTS(usb->index),
947 cvmx_usb_shutdown(usb);
956 * @usb: USB device state populated by cvmx_usb_initialize().
958 static void cvmx_usb_reset_port(struct octeon_hcd *usb)
960 usb->usbcx_hprt.u32 = cvmx_usb_read_csr32(usb,
961 CVMX_USBCX_HPRT(usb->index));
964 USB_SET_FIELD32(CVMX_USBCX_HPRT(usb->index), cvmx_usbcx_hprt,
974 USB_SET_FIELD32(CVMX_USBCX_HPRT(usb->index), cvmx_usbcx_hprt,
981 usb->usbcx_hprt.u32 = cvmx_usb_read_csr32(usb,
982 CVMX_USBCX_HPRT(usb->index));
991 * @usb: USB device state populated by cvmx_usb_initialize().
995 static int cvmx_usb_disable(struct octeon_hcd *usb)
998 USB_SET_FIELD32(CVMX_USBCX_HPRT(usb->index), cvmx_usbcx_hprt,
1005 * determine if the usb port has anything connected, is enabled,
1010 * @usb: USB device state populated by cvmx_usb_initialize().
1014 static struct cvmx_usb_port_status cvmx_usb_get_status(struct octeon_hcd *usb)
1021 usbc_hprt.u32 = cvmx_usb_read_csr32(usb, CVMX_USBCX_HPRT(usb->index));
1028 result.connected != usb->port_status.connected;
1038 * @usb: USB device state populated by cvmx_usb_initialize().
1085 static struct cvmx_usb_pipe *cvmx_usb_open_pipe(struct octeon_hcd *usb,
1122 if (cvmx_usb_pipe_needs_split(usb, pipe)) {
1125 pipe->next_tx_frame = ((usb->frame_number + 7) & ~7) +
1129 pipe->next_tx_frame = usb->frame_number + pipe->interval;
1136 list_add_tail(&pipe->node, &usb->idle_pipes);
1151 * @usb: USB device state populated by cvmx_usb_initialize().
1153 static void cvmx_usb_poll_rx_fifo(struct octeon_hcd *usb)
1161 rx_status.u32 = cvmx_usb_read_csr32(usb,
1162 CVMX_USBCX_GRXSTSPH(usb->index));
1176 address = cvmx_read64_uint64(CVMX_USBNX_DMA0_INB_CHN0(usb->index) +
1180 cvmx_write64_uint64(CVMX_USBNX_DMA0_INB_CHN0(usb->index) + channel * 8,
1185 *ptr++ = cvmx_usb_read_csr32(usb,
1186 USB_FIFO_ADDRESS(channel, usb->index));
1196 * @usb: USB device state populated by cvmx_usb_initialize().
1203 static int cvmx_usb_fill_tx_hw(struct octeon_hcd *usb,
1214 usb->index) ^ 4;
1238 cvmx_read64_uint64(CVMX_USBNX_DMA0_INB_CHN0(usb->index));
1247 cvmx_read64_uint64(CVMX_USBNX_DMA0_INB_CHN0(usb->index));
1255 * @usb: USB device state populated by cvmx_usb_initialize().
1257 static void cvmx_usb_poll_tx_fifo(struct octeon_hcd *usb)
1259 if (usb->periodic.head != usb->periodic.tail) {
1262 tx_status.u32 = cvmx_usb_read_csr32(usb,
1263 CVMX_USBCX_HPTXSTS(usb->index));
1264 if (cvmx_usb_fill_tx_hw(usb, &usb->periodic,
1266 USB_SET_FIELD32(CVMX_USBCX_GINTMSK(usb->index),
1269 USB_SET_FIELD32(CVMX_USBCX_GINTMSK(usb->index),
1273 if (usb->nonperiodic.head != usb->nonperiodic.tail) {
1276 tx_status.u32 = cvmx_usb_read_csr32(usb,
1277 CVMX_USBCX_GNPTXSTS(usb->index));
1278 if (cvmx_usb_fill_tx_hw(usb, &usb->nonperiodic,
1280 USB_SET_FIELD32(CVMX_USBCX_GINTMSK(usb->index),
1283 USB_SET_FIELD32(CVMX_USBCX_GINTMSK(usb->index),
1291 * @usb: USB device state populated by cvmx_usb_initialize().
1294 static void cvmx_usb_fill_tx_fifo(struct octeon_hcd *usb, int channel)
1302 hcchar.u32 = cvmx_usb_read_csr32(usb,
1303 CVMX_USBCX_HCCHARX(channel, usb->index));
1308 usbc_hcsplt.u32 = cvmx_usb_read_csr32(usb,
1309 CVMX_USBCX_HCSPLTX(channel, usb->index));
1317 usbc_hctsiz.u32 = cvmx_usb_read_csr32(usb,
1318 CVMX_USBCX_HCTSIZX(channel, usb->index));
1324 fifo = &usb->periodic;
1326 fifo = &usb->nonperiodic;
1330 cvmx_read64_uint64(CVMX_USBNX_DMA0_OUTB_CHN0(usb->index) +
1337 cvmx_usb_poll_tx_fifo(usb);
1344 * @usb: USB device state populated by cvmx_usb_initialize().
1348 static void cvmx_usb_start_channel_control(struct octeon_hcd *usb,
1352 struct usb_hcd *hcd = octeon_to_hcd(usb);
1364 usbc_hctsiz.u32 = cvmx_usb_read_csr32(usb,
1365 CVMX_USBCX_HCTSIZX(channel, usb->index));
1376 USB_SET_FIELD32(CVMX_USBCX_HCCHARX(channel, usb->index),
1383 cvmx_write64_uint64(CVMX_USBNX_DMA0_OUTB_CHN0(usb->index) +
1391 USB_SET_FIELD32(CVMX_USBCX_HCCHARX(channel, usb->index),
1395 USB_SET_FIELD32(CVMX_USBCX_HCSPLTX(channel, usb->index),
1400 if (cvmx_usb_pipe_needs_split(usb, pipe)) {
1406 USB_SET_FIELD32(CVMX_USBCX_HCCHARX(channel, usb->index),
1416 USB_SET_FIELD32(CVMX_USBCX_HCCHARX(channel, usb->index),
1421 USB_SET_FIELD32(CVMX_USBCX_HCSPLTX(channel, usb->index),
1427 USB_SET_FIELD32(CVMX_USBCX_HCCHARX(channel, usb->index),
1436 USB_SET_FIELD32(CVMX_USBCX_HCCHARX(channel, usb->index),
1441 USB_SET_FIELD32(CVMX_USBCX_HCSPLTX(channel, usb->index),
1465 (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_NO_DMA)) {
1485 cvmx_usb_write_csr32(usb, CVMX_USBCX_HCTSIZX(channel, usb->index),
1492 * @usb: USB device state populated by cvmx_usb_initialize().
1496 static void cvmx_usb_start_channel(struct octeon_hcd *usb, int channel,
1507 usb->pipe_for_channel[channel] = pipe;
1512 usb->idle_hardware_channels &= ~(1 << channel);
1521 usbc_hcint.u32 = cvmx_usb_read_csr32(usb,
1522 CVMX_USBCX_HCINTX(channel, usb->index));
1524 cvmx_usb_write_csr32(usb,
1525 CVMX_USBCX_HCINTX(channel, usb->index),
1530 if (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_NO_DMA) {
1539 if (cvmx_usb_pipe_needs_split(usb, pipe)) {
1551 cvmx_usb_write_csr32(usb,
1552 CVMX_USBCX_HCINTMSKX(channel, usb->index),
1556 usbc_haintmsk.u32 = cvmx_usb_read_csr32(usb,
1557 CVMX_USBCX_HAINTMSK(usb->index));
1559 cvmx_usb_write_csr32(usb, CVMX_USBCX_HAINTMSK(usb->index),
1575 reg = CVMX_USBNX_DMA0_OUTB_CHN0(usb->index);
1577 reg = CVMX_USBNX_DMA0_INB_CHN0(usb->index);
1602 if (cvmx_usb_pipe_needs_split(usb, pipe)) {
1612 (usb->frame_number + 1) & 0x7f;
1615 (usb->frame_number + 2) & 0x7f;
1708 (usb->init_flags &
1740 cvmx_usb_write_csr32(usb,
1741 CVMX_USBCX_HCSPLTX(channel, usb->index),
1743 cvmx_usb_write_csr32(usb,
1744 CVMX_USBCX_HCTSIZX(channel, usb->index),
1756 usbc_hcchar.s.oddfrm = usb->frame_number & 1;
1764 if (cvmx_usb_pipe_needs_split(usb, pipe))
1781 cvmx_usb_write_csr32(usb,
1782 CVMX_USBCX_HCCHARX(channel, usb->index),
1789 cvmx_usb_start_channel_control(usb, channel, pipe);
1795 if (!cvmx_usb_pipe_needs_split(usb, pipe)) {
1804 usb->index),
1809 usb->index),
1817 cvmx_usb_read_csr32(usb,
1819 usb->index))
1825 if (cvmx_usb_pipe_needs_split(usb, pipe))
1826 usb->active_split = transaction;
1827 USB_SET_FIELD32(CVMX_USBCX_HCCHARX(channel, usb->index),
1829 if (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_NO_DMA)
1830 cvmx_usb_fill_tx_fifo(usb, channel);
1835 * @usb: USB device state populated by cvmx_usb_initialize().
1840 static struct cvmx_usb_pipe *cvmx_usb_find_ready_pipe(struct octeon_hcd *usb,
1843 struct list_head *list = usb->active_pipes + xfer_type;
1844 u64 current_frame = usb->frame_number;
1856 (!usb->active_split || (usb->active_split == t))) {
1864 static struct cvmx_usb_pipe *cvmx_usb_next_pipe(struct octeon_hcd *usb,
1876 pipe = cvmx_usb_find_ready_pipe(usb,
1880 pipe = cvmx_usb_find_ready_pipe(usb,
1885 pipe = cvmx_usb_find_ready_pipe(usb, CVMX_USB_TRANSFER_CONTROL);
1888 return cvmx_usb_find_ready_pipe(usb, CVMX_USB_TRANSFER_BULK);
1895 * @usb: USB device state populated by cvmx_usb_initialize().
1898 static void cvmx_usb_schedule(struct octeon_hcd *usb, int is_sof)
1905 if (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_NO_DMA) {
1911 .u32 = cvmx_usb_read_csr32(usb,
1912 CVMX_USBCX_HFNUM(usb->index))
1916 .u32 = cvmx_usb_read_csr32(usb,
1917 CVMX_USBCX_HFIR(usb->index))
1924 while (usb->idle_hardware_channels) {
1926 channel = __fls(usb->idle_hardware_channels);
1930 pipe = cvmx_usb_next_pipe(usb, is_sof);
1934 cvmx_usb_start_channel(usb, channel, pipe);
1945 list_for_each_entry(pipe, &usb->active_pipes[ttype], node) {
1946 if (pipe->next_tx_frame > usb->frame_number) {
1952 USB_SET_FIELD32(CVMX_USBCX_GINTMSK(usb->index),
1956 static void octeon_usb_urb_complete_callback(struct octeon_hcd *usb,
1964 struct usb_hcd *hcd = octeon_to_hcd(usb);
2039 usb_hcd_unlink_urb_from_ep(octeon_to_hcd(usb), urb);
2040 spin_unlock(&usb->lock);
2041 usb_hcd_giveback_urb(octeon_to_hcd(usb), urb, urb->status);
2042 spin_lock(&usb->lock);
2049 * @usb: USB device state populated by cvmx_usb_initialize().
2056 static void cvmx_usb_complete(struct octeon_hcd *usb,
2062 if (usb->active_split == transaction)
2063 usb->active_split = NULL;
2094 list_move_tail(&pipe->node, &usb->idle_pipes);
2095 octeon_usb_urb_complete_callback(usb, complete_code, pipe,
2103 * Submit a usb transaction to a pipe. Called for all types
2106 * @usb:
2125 struct octeon_hcd *usb,
2164 &usb->active_pipes[pipe->transfer_type]);
2170 cvmx_usb_schedule(usb, 0);
2179 * @usb: USB device state populated by cvmx_usb_initialize().
2186 struct octeon_hcd *usb,
2190 return cvmx_usb_submit_transaction(usb, pipe, CVMX_USB_TRANSFER_BULK,
2203 * @usb: USB device state populated by cvmx_usb_initialize().
2210 struct octeon_hcd *usb,
2214 return cvmx_usb_submit_transaction(usb, pipe,
2228 * @usb: USB device state populated by cvmx_usb_initialize().
2235 struct octeon_hcd *usb,
2246 return cvmx_usb_submit_transaction(usb, pipe,
2259 * @usb: USB device state populated by cvmx_usb_initialize().
2266 struct octeon_hcd *usb,
2273 return cvmx_usb_submit_transaction(usb, pipe,
2290 * @usb: USB device state populated by cvmx_usb_initialize().
2296 static int cvmx_usb_cancel(struct octeon_hcd *usb,
2308 usb->pipe_for_channel[pipe->channel] = NULL;
2313 usbc_hcchar.u32 = cvmx_usb_read_csr32(usb,
2315 usb->index));
2322 cvmx_usb_write_csr32(usb,
2324 usb->index),
2328 cvmx_usb_complete(usb, pipe, transaction, CVMX_USB_STATUS_CANCEL);
2336 * @usb: USB device state populated by cvmx_usb_initialize().
2341 static int cvmx_usb_cancel_all(struct octeon_hcd *usb,
2348 int result = cvmx_usb_cancel(usb, pipe, transaction);
2359 * @usb: USB device state populated by cvmx_usb_initialize().
2365 static int cvmx_usb_close_pipe(struct octeon_hcd *usb,
2382 * @usb: USB device state populated by cvmx_usb_initialize().
2386 static int cvmx_usb_get_frame_number(struct octeon_hcd *usb)
2390 usbc_hfnum.u32 = cvmx_usb_read_csr32(usb, CVMX_USBCX_HFNUM(usb->index));
2395 static void cvmx_usb_transfer_control(struct octeon_hcd *usb,
2406 cvmx_usb_complete(usb, pipe, transaction,
2411 if (cvmx_usb_pipe_needs_split(usb, pipe)) {
2434 if (cvmx_usb_pipe_needs_split(usb, pipe)) {
2466 if (cvmx_usb_pipe_needs_split(usb, pipe))
2470 cvmx_usb_complete(usb, pipe, transaction,
2474 cvmx_usb_complete(usb, pipe, transaction, CVMX_USB_STATUS_OK);
2479 static void cvmx_usb_transfer_bulk(struct octeon_hcd *usb,
2491 if (cvmx_usb_pipe_needs_split(usb, pipe)) {
2499 cvmx_usb_complete(usb, pipe, transaction,
2508 cvmx_usb_complete(usb, pipe, transaction,
2513 static void cvmx_usb_transfer_intr(struct octeon_hcd *usb,
2519 if (cvmx_usb_pipe_needs_split(usb, pipe)) {
2528 cvmx_usb_complete(usb, pipe, transaction,
2534 cvmx_usb_complete(usb, pipe, transaction, CVMX_USB_STATUS_OK);
2538 static void cvmx_usb_transfer_isoc(struct octeon_hcd *usb,
2545 if (cvmx_usb_pipe_needs_split(usb, pipe)) {
2560 cvmx_usb_complete(usb, pipe, transaction,
2574 cvmx_usb_complete(usb, pipe, transaction,
2583 cvmx_usb_complete(usb, pipe, transaction, CVMX_USB_STATUS_OK);
2590 * @usb: USB device
2595 static int cvmx_usb_poll_channel(struct octeon_hcd *usb, int channel)
2597 struct usb_hcd *hcd = octeon_to_hcd(usb);
2610 usbc_hcint.u32 = cvmx_usb_read_csr32(usb,
2611 CVMX_USBCX_HCINTX(channel, usb->index));
2613 if (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_NO_DMA) {
2614 usbc_hcchar.u32 = cvmx_usb_read_csr32(usb,
2616 usb->index));
2624 cvmx_usb_write_csr32(usb,
2626 usb->index),
2641 cvmx_usb_write_csr32(usb,
2642 CVMX_USBCX_HCINTMSKX(channel, usb->index),
2645 cvmx_usb_write_csr32(usb,
2646 CVMX_USBCX_HCCHARX(channel, usb->index),
2656 usb->index, channel);
2670 cvmx_usb_write_csr32(usb, CVMX_USBCX_HCINTMSKX(channel, usb->index), 0);
2671 usb->idle_hardware_channels |= (1 << channel);
2674 pipe = usb->pipe_for_channel[channel];
2687 usb->pipe_for_channel[channel] = NULL;
2694 usbc_hcchar.u32 = cvmx_usb_read_csr32(usb,
2695 CVMX_USBCX_HCCHARX(channel, usb->index));
2696 usbc_hctsiz.u32 = cvmx_usb_read_csr32(usb,
2697 CVMX_USBCX_HCTSIZX(channel, usb->index));
2779 cvmx_usb_complete(usb, pipe, transaction,
2792 cvmx_usb_complete(usb, pipe, transaction,
2800 cvmx_usb_complete(usb, pipe, transaction,
2804 cvmx_usb_complete(usb, pipe, transaction,
2808 cvmx_usb_complete(usb, pipe, transaction,
2817 if (!cvmx_usb_pipe_needs_split(usb, pipe)) {
2825 cvmx_usb_complete(usb, pipe,
2861 cvmx_usb_transfer_control(usb, pipe, transaction,
2867 cvmx_usb_transfer_bulk(usb, pipe, transaction,
2872 cvmx_usb_transfer_intr(usb, pipe, transaction,
2877 cvmx_usb_transfer_isoc(usb, pipe, transaction,
2887 if (usb->active_split == transaction)
2888 usb->active_split = NULL;
2898 if (pipe->next_tx_frame < usb->frame_number)
2899 pipe->next_tx_frame = usb->frame_number +
2901 (usb->frame_number - pipe->next_tx_frame) %
2906 port = cvmx_usb_get_status(usb);
2915 cvmx_usb_complete(usb, pipe, transaction,
2922 static void octeon_usb_port_callback(struct octeon_hcd *usb)
2924 spin_unlock(&usb->lock);
2925 usb_hcd_poll_rh_status(octeon_to_hcd(usb));
2926 spin_lock(&usb->lock);
2935 * @usb: USB device state populated by cvmx_usb_initialize().
2939 static int cvmx_usb_poll(struct octeon_hcd *usb)
2944 prefetch_range(usb, sizeof(*usb));
2947 usbc_hfnum.u32 = cvmx_usb_read_csr32(usb, CVMX_USBCX_HFNUM(usb->index));
2948 if ((usb->frame_number & 0x3fff) > usbc_hfnum.s.frnum)
2949 usb->frame_number += 0x4000;
2950 usb->frame_number &= ~0x3fffull;
2951 usb->frame_number |= usbc_hfnum.s.frnum;
2954 usbc_gintsts.u32 = cvmx_usb_read_csr32(usb,
2955 CVMX_USBCX_GINTSTS(usb->index));
2958 cvmx_usb_write_csr32(usb, CVMX_USBCX_GINTSTS(usb->index),
2969 if (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_NO_DMA)
2970 cvmx_usb_poll_rx_fifo(usb);
2974 if (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_NO_DMA)
2975 cvmx_usb_poll_tx_fifo(usb);
2993 octeon_usb_port_callback(usb);
2996 cvmx_usb_read_csr32(usb, CVMX_USBCX_HPRT(usb->index));
2998 cvmx_usb_write_csr32(usb, CVMX_USBCX_HPRT(usb->index),
3016 usbc_haint.u32 = cvmx_usb_read_csr32(usb,
3017 CVMX_USBCX_HAINT(usb->index));
3022 cvmx_usb_poll_channel(usb, channel);
3027 cvmx_usb_schedule(usb, usbc_gintsts.s.sof);
3040 struct octeon_hcd *usb = hcd_to_octeon(hcd);
3043 spin_lock_irqsave(&usb->lock, flags);
3044 cvmx_usb_poll(usb);
3045 spin_unlock_irqrestore(&usb->lock, flags);
3062 struct octeon_hcd *usb = hcd_to_octeon(hcd);
3064 return cvmx_usb_get_frame_number(usb);
3071 struct octeon_hcd *usb = hcd_to_octeon(hcd);
3081 spin_lock_irqsave(&usb->lock, flags);
3085 spin_unlock_irqrestore(&usb->lock, flags);
3127 * Start at this device and work our way up the usb
3151 pipe = cvmx_usb_open_pipe(usb, usb_pipedevice(urb->pipe),
3165 spin_unlock_irqrestore(&usb->lock, flags);
3202 transaction = cvmx_usb_submit_isochronous(usb,
3218 transaction = cvmx_usb_submit_interrupt(usb, pipe, urb);
3224 transaction = cvmx_usb_submit_control(usb, pipe, urb);
3230 transaction = cvmx_usb_submit_bulk(usb, pipe, urb);
3235 spin_unlock_irqrestore(&usb->lock, flags);
3240 spin_unlock_irqrestore(&usb->lock, flags);
3248 struct octeon_hcd *usb = hcd_to_octeon(hcd);
3255 spin_lock_irqsave(&usb->lock, flags);
3262 cvmx_usb_cancel(usb, urb->ep->hcpriv, urb->hcpriv);
3265 spin_unlock_irqrestore(&usb->lock, flags);
3276 struct octeon_hcd *usb = hcd_to_octeon(hcd);
3280 spin_lock_irqsave(&usb->lock, flags);
3281 cvmx_usb_cancel_all(usb, pipe);
3282 if (cvmx_usb_close_pipe(usb, pipe))
3284 spin_unlock_irqrestore(&usb->lock, flags);
3291 struct octeon_hcd *usb = hcd_to_octeon(hcd);
3295 spin_lock_irqsave(&usb->lock, flags);
3296 port_status = cvmx_usb_get_status(usb);
3297 spin_unlock_irqrestore(&usb->lock, flags);
3306 struct octeon_hcd *usb = hcd_to_octeon(hcd);
3335 spin_lock_irqsave(&usb->lock, flags);
3336 cvmx_usb_disable(usb);
3337 spin_unlock_irqrestore(&usb->lock, flags);
3354 spin_lock_irqsave(&usb->lock, flags);
3355 usb->port_status = cvmx_usb_get_status(usb);
3356 spin_unlock_irqrestore(&usb->lock, flags);
3363 spin_lock_irqsave(&usb->lock, flags);
3364 usb->port_status = cvmx_usb_get_status(usb);
3365 spin_unlock_irqrestore(&usb->lock, flags);
3373 spin_lock_irqsave(&usb->lock, flags);
3374 usb->port_status = cvmx_usb_get_status(usb);
3375 spin_unlock_irqrestore(&usb->lock, flags);
3388 spin_lock_irqsave(&usb->lock, flags);
3389 usb->port_status = cvmx_usb_get_status(usb);
3390 spin_unlock_irqrestore(&usb->lock, flags);
3420 spin_lock_irqsave(&usb->lock, flags);
3421 usb_port_status = cvmx_usb_get_status(usb);
3422 spin_unlock_irqrestore(&usb->lock, flags);
3485 spin_lock_irqsave(&usb->lock, flags);
3486 USB_SET_FIELD32(CVMX_USBCX_HPRT(usb->index),
3488 spin_unlock_irqrestore(&usb->lock, flags);
3492 spin_lock_irqsave(&usb->lock, flags);
3493 cvmx_usb_reset_port(usb);
3494 spin_unlock_irqrestore(&usb->lock, flags);
3539 struct octeon_hcd *usb;
3639 usb = (struct octeon_hcd *)hcd->hcd_priv;
3641 spin_lock_init(&usb->lock);
3643 usb->init_flags = initialize_flags;
3646 usb->index = usb_num;
3647 INIT_LIST_HEAD(&usb->idle_pipes);
3648 for (i = 0; i < ARRAY_SIZE(usb->active_pipes); i++)
3649 INIT_LIST_HEAD(&usb->active_pipes[i]);
3653 usb->init_flags |= CVMX_USB_INITIALIZE_FLAGS_NO_DMA;
3655 usb->idle_hardware_channels = 0x1;
3658 usb->idle_hardware_channels = 0xf7;
3660 usb->idle_hardware_channels = 0xff;
3663 status = cvmx_usb_initialize(dev, usb);
3688 struct octeon_hcd *usb = hcd_to_octeon(hcd);
3692 spin_lock_irqsave(&usb->lock, flags);
3693 status = cvmx_usb_shutdown(usb);
3694 spin_unlock_irqrestore(&usb->lock, flags);