1 /***********************license start***************
2 * Copyright (c) 2003-2010 Cavium Networks (support@cavium.com). All rights
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions are
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
13 * * Redistributions in binary form must reproduce the above
14 * copyright notice, this list of conditions and the following
15 * disclaimer in the documentation and/or other materials provided
16 * with the distribution.
18 * * Neither the name of Cavium Networks nor the names of
19 * its contributors may be used to endorse or promote products
20 * derived from this software without specific prior written
23 * This Software, including technical data, may be subject to U.S. export control
24 * laws, including the U.S. Export Administration Act and its associated
25 * regulations, and may be subject to export or import regulations in other
28 * TO THE MAXIMUM EXTENT PERMITTED BY LAW, THE SOFTWARE IS PROVIDED "AS IS"
29 * AND WITH ALL FAULTS AND CAVIUM NETWORKS MAKES NO PROMISES, REPRESENTATIONS OR
30 * WARRANTIES, EITHER EXPRESS, IMPLIED, STATUTORY, OR OTHERWISE, WITH RESPECT TO
31 * THE SOFTWARE, INCLUDING ITS CONDITION, ITS CONFORMITY TO ANY REPRESENTATION OR
32 * DESCRIPTION, OR THE EXISTENCE OF ANY LATENT OR PATENT DEFECTS, AND CAVIUM
33 * SPECIFICALLY DISCLAIMS ALL IMPLIED (IF ANY) WARRANTIES OF TITLE,
34 * MERCHANTABILITY, NONINFRINGEMENT, FITNESS FOR A PARTICULAR PURPOSE, LACK OF
35 * VIRUSES, ACCURACY OR COMPLETENESS, QUIET ENJOYMENT, QUIET POSSESSION OR
36 * CORRESPONDENCE TO DESCRIPTION. THE ENTIRE RISK ARISING OUT OF USE OR
37 * PERFORMANCE OF THE SOFTWARE LIES WITH YOU.
38 ***********************license end**************************************/
44 * "cvmx-usb.c" defines a set of low level USB functions to help
45 * developers create Octeon USB drivers for various operating
46 * systems. These functions provide a generic API to the Octeon
47 * USB blocks, hiding the internal hardware specific
50 * <hr>$Revision: 32636 $<hr>
52 #ifdef CVMX_BUILD_FOR_LINUX_KERNEL
53 #include <asm/octeon/cvmx.h>
54 #include <asm/octeon/cvmx-clock.h>
55 #include <asm/octeon/cvmx-sysinfo.h>
56 #include <asm/octeon/cvmx-usbnx-defs.h>
57 #include <asm/octeon/cvmx-usbcx-defs.h>
58 #include <asm/octeon/cvmx-usb.h>
59 #include <asm/octeon/cvmx-helper.h>
60 #include <asm/octeon/cvmx-helper-board.h>
61 #include <asm/octeon/cvmx-swap.h>
63 /* Do not use cvmx-error.h for now. When the cvmx-error.h is properly
64 * ported, remove the above #if 0, and all #ifdef __CVMX_ERROR_H__ within
66 #include <asm/octeon/cvmx-error.h>
70 #include "cvmx-clock.h"
71 #include "cvmx-sysinfo.h"
73 #include "cvmx-helper.h"
74 #include "cvmx-helper-board.h"
75 #include "cvmx-csr-db.h"
76 #include "cvmx-swap.h"
77 #include "cvmx-error.h"
80 #define MAX_RETRIES 3 /* Maximum number of times to retry failed transactions */
81 #define MAX_PIPES 32 /* Maximum number of pipes that can be open at once */
82 #define MAX_TRANSACTIONS 256 /* Maximum number of outstanding transactions across all pipes */
83 #define MAX_CHANNELS 8 /* Maximum number of hardware channels supported by the USB block */
84 #define MAX_USB_ADDRESS 127 /* The highest valid USB device address */
85 #define MAX_USB_ENDPOINT 15 /* The highest valid USB endpoint number */
86 #define MAX_USB_HUB_PORT 15 /* The highest valid port number on a hub */
87 #define MAX_TRANSFER_BYTES ((1<<19)-1) /* The low level hardware can transfer a maximum of this number of bytes in each transfer. The field is 19 bits wide */
88 #define MAX_TRANSFER_PACKETS ((1<<10)-1) /* The low level hardware can transfer a maximum of this number of packets in each transfer. The field is 10 bits wide */
89 #define ALLOW_CSR_DECODES 0 /* CSR decoding when CVMX_USB_INITIALIZE_FLAGS_DEBUG_CSRS is set
90 enlarges the code a lot. This define overrides the ability to do CSR
91 decoding since it isn't necessary 99% of the time. Change this to a
92 one if you need CSR decoding */
94 /* These defines disable the normal read and write csr. This is so I can add
95 extra debug stuff to the usb specific version and I won't use the normal
97 #define cvmx_read_csr use_cvmx_usb_read_csr64_instead_of_cvmx_read_csr
98 #define cvmx_write_csr use_cvmx_usb_write_csr64_instead_of_cvmx_write_csr
102 __CVMX_USB_TRANSACTION_FLAGS_IN_USE = 1<<16,
103 } cvmx_usb_transaction_flags_t;
106 * Logical transactions may take numerous low level
107 * transactions, especially when splits are concerned. This
108 * enum represents all of the possible stages a transaction can
109 * be in. Note that split completes are always even. This is so
110 * the NAK handler can backup to the previous low level
111 * transaction with a simple clearing of bit 0.
115 CVMX_USB_STAGE_NON_CONTROL,
116 CVMX_USB_STAGE_NON_CONTROL_SPLIT_COMPLETE,
117 CVMX_USB_STAGE_SETUP,
118 CVMX_USB_STAGE_SETUP_SPLIT_COMPLETE,
120 CVMX_USB_STAGE_DATA_SPLIT_COMPLETE,
121 CVMX_USB_STAGE_STATUS,
122 CVMX_USB_STAGE_STATUS_SPLIT_COMPLETE,
126 * This structure describes each pending USB transaction
127 * regardless of type. These are linked together to form a list
128 * of pending requests for a pipe.
130 typedef struct cvmx_usb_transaction
132 struct cvmx_usb_transaction *prev; /**< Transaction before this one in the pipe */
133 struct cvmx_usb_transaction *next; /**< Transaction after this one in the pipe */
134 cvmx_usb_transfer_t type; /**< Type of transaction, duplicated of the pipe */
135 cvmx_usb_transaction_flags_t flags; /**< State flags for this transaction */
136 uint64_t buffer; /**< User's physical buffer address to read/write */
137 int buffer_length; /**< Size of the user's buffer in bytes */
138 uint64_t control_header; /**< For control transactions, physical address of the 8 byte standard header */
139 int iso_start_frame; /**< For ISO transactions, the starting frame number */
140 int iso_number_packets; /**< For ISO transactions, the number of packets in the request */
141 cvmx_usb_iso_packet_t *iso_packets; /**< For ISO transactions, the sub packets in the request */
145 int actual_bytes; /**< Actual bytes transfer for this transaction */
146 cvmx_usb_stage_t stage; /**< For control transactions, the current stage */
147 cvmx_usb_callback_func_t callback; /**< User's callback function when complete */
148 void *callback_data; /**< User's data */
149 } cvmx_usb_transaction_t;
152 * A pipe represents a virtual connection between Octeon and some
153 * USB device. It contains a list of pending request to the device.
155 typedef struct cvmx_usb_pipe
157 struct cvmx_usb_pipe *prev; /**< Pipe before this one in the list */
158 struct cvmx_usb_pipe *next; /**< Pipe after this one in the list */
159 cvmx_usb_transaction_t *head; /**< The first pending transaction */
160 cvmx_usb_transaction_t *tail; /**< The last pending transaction */
161 uint64_t interval; /**< For periodic pipes, the interval between packets in frames */
162 uint64_t next_tx_frame; /**< The next frame this pipe is allowed to transmit on */
163 cvmx_usb_pipe_flags_t flags; /**< State flags for this pipe */
164 cvmx_usb_speed_t device_speed; /**< Speed of device connected to this pipe */
165 cvmx_usb_transfer_t transfer_type; /**< Type of transaction supported by this pipe */
166 cvmx_usb_direction_t transfer_dir; /**< IN or OUT. Ignored for Control */
167 int multi_count; /**< Max packet in a row for the device */
168 uint16_t max_packet; /**< The device's maximum packet size in bytes */
169 uint8_t device_addr; /**< USB device address at other end of pipe */
170 uint8_t endpoint_num; /**< USB endpoint number at other end of pipe */
171 uint8_t hub_device_addr; /**< Hub address this device is connected to */
172 uint8_t hub_port; /**< Hub port this device is connected to */
173 uint8_t pid_toggle; /**< This toggles between 0/1 on every packet send to track the data pid needed */
174 uint8_t channel; /**< Hardware DMA channel for this pipe */
175 int8_t split_sc_frame; /**< The low order bits of the frame number the split complete should be sent on */
180 cvmx_usb_pipe_t *head; /**< Head of the list, or NULL if empty */
181 cvmx_usb_pipe_t *tail; /**< Tail if the list, or NULL if empty */
182 } cvmx_usb_pipe_list_t;
191 } entry[MAX_CHANNELS+1];
194 } cvmx_usb_tx_fifo_t;
197 * The state of the USB block is stored in this structure
201 int init_flags; /**< Flags passed to initialize */
202 int index; /**< Which USB block this is for */
203 int idle_hardware_channels; /**< Bit set for every idle hardware channel */
204 cvmx_usbcx_hprt_t usbcx_hprt; /**< Stored port status so we don't need to read a CSR to determine splits */
205 cvmx_usb_pipe_t *pipe_for_channel[MAX_CHANNELS]; /**< Map channels to pipes */
206 cvmx_usb_transaction_t *free_transaction_head; /**< List of free transactions head */
207 cvmx_usb_transaction_t *free_transaction_tail; /**< List of free transactions tail */
208 cvmx_usb_pipe_t pipe[MAX_PIPES]; /**< Storage for pipes */
209 cvmx_usb_transaction_t transaction[MAX_TRANSACTIONS]; /**< Storage for transactions */
210 cvmx_usb_callback_func_t callback[__CVMX_USB_CALLBACK_END]; /**< User global callbacks */
211 void *callback_data[__CVMX_USB_CALLBACK_END]; /**< User data for each callback */
212 int indent; /**< Used by debug output to indent functions */
213 cvmx_usb_port_status_t port_status; /**< Last port status used for change notification */
214 cvmx_usb_pipe_list_t free_pipes; /**< List of all pipes that are currently closed */
215 cvmx_usb_pipe_list_t idle_pipes; /**< List of open pipes that have no transactions */
216 cvmx_usb_pipe_list_t active_pipes[4]; /**< Active pipes indexed by transfer type */
217 uint64_t frame_number; /**< Increments every SOF interrupt for time keeping */
218 cvmx_usb_transaction_t *active_split; /**< Points to the current active split, or NULL */
219 cvmx_usb_tx_fifo_t periodic;
220 cvmx_usb_tx_fifo_t nonperiodic;
221 } cvmx_usb_internal_state_t;
223 /* This macro logs out whenever a function is called if debugging is on */
224 #define CVMX_USB_LOG_CALLED() \
225 if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_CALLS)) \
226 cvmx_dprintf("%*s%s: called\n", 2*usb->indent++, "", __FUNCTION__);
228 /* This macro logs out each function parameter if debugging is on */
229 #define CVMX_USB_LOG_PARAM(format, param) \
230 if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_CALLS)) \
231 cvmx_dprintf("%*s%s: param %s = " format "\n", 2*usb->indent, "", __FUNCTION__, #param, param);
233 /* This macro logs out when a function returns a value */
234 #define CVMX_USB_RETURN(v) \
237 if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_CALLS)) \
238 cvmx_dprintf("%*s%s: returned %s(%d)\n", 2*--usb->indent, "", __FUNCTION__, #v, r); \
242 /* This macro logs out when a function doesn't return a value */
243 #define CVMX_USB_RETURN_NOTHING() \
245 if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_CALLS)) \
246 cvmx_dprintf("%*s%s: returned\n", 2*--usb->indent, "", __FUNCTION__); \
250 /* This macro spins on a field waiting for it to reach a value */
251 #define CVMX_WAIT_FOR_FIELD32(address, type, field, op, value, timeout_usec)\
254 uint64_t done = cvmx_get_cycle() + (uint64_t)timeout_usec * \
255 cvmx_clock_get_rate(CVMX_CLOCK_CORE) / 1000000; \
259 c.u32 = __cvmx_usb_read_csr32(usb, address); \
260 if (c.s.field op (value)) { \
263 } else if (cvmx_get_cycle() > done) { \
272 /* This macro logically sets a single field in a CSR. It does the sequence
273 read, modify, and write */
274 #define USB_SET_FIELD32(address, type, field, value)\
277 c.u32 = __cvmx_usb_read_csr32(usb, address);\
279 __cvmx_usb_write_csr32(usb, address, c.u32);\
282 /* Returns the IO address to push/pop stuff data from the FIFOs */
283 #define USB_FIFO_ADDRESS(channel, usb_index) (CVMX_USBCX_GOTGCTL(usb_index) + ((channel)+1)*0x1000)
287 * Read a USB 32bit CSR. It performs the necessary address swizzle
288 * for 32bit CSRs and logs the value in a readable format if
291 * @param usb USB block this access is for
292 * @param address 64bit address to read
294 * @return Result of the read
296 static inline uint32_t __cvmx_usb_read_csr32(cvmx_usb_internal_state_t *usb,
299 uint32_t result = cvmx_read64_uint32(address ^ 4);
300 #if ALLOW_CSR_DECODES
301 if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_CSRS))
303 cvmx_dprintf("Read: ");
304 cvmx_csr_db_decode(cvmx_get_proc_id(), address, result);
313 * Write a USB 32bit CSR. It performs the necessary address
314 * swizzle for 32bit CSRs and logs the value in a readable format
315 * if debugging is on.
317 * @param usb USB block this access is for
318 * @param address 64bit address to write
319 * @param value Value to write
321 static inline void __cvmx_usb_write_csr32(cvmx_usb_internal_state_t *usb,
322 uint64_t address, uint32_t value)
324 #if ALLOW_CSR_DECODES
325 if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_CSRS))
327 cvmx_dprintf("Write: ");
328 cvmx_csr_db_decode(cvmx_get_proc_id(), address, value);
331 cvmx_write64_uint32(address ^ 4, value);
332 cvmx_read64_uint64(CVMX_USBNX_DMA0_INB_CHN0(usb->index));
338 * Read a USB 64bit CSR. It logs the value in a readable format if
341 * @param usb USB block this access is for
342 * @param address 64bit address to read
344 * @return Result of the read
346 static inline uint64_t __cvmx_usb_read_csr64(cvmx_usb_internal_state_t *usb,
349 uint64_t result = cvmx_read64_uint64(address);
350 #if ALLOW_CSR_DECODES
351 if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_CSRS))
353 cvmx_dprintf("Read: ");
354 cvmx_csr_db_decode(cvmx_get_proc_id(), address, result);
363 * Write a USB 64bit CSR. It logs the value in a readable format
364 * if debugging is on.
366 * @param usb USB block this access is for
367 * @param address 64bit address to write
368 * @param value Value to write
370 static inline void __cvmx_usb_write_csr64(cvmx_usb_internal_state_t *usb,
371 uint64_t address, uint64_t value)
373 #if ALLOW_CSR_DECODES
374 if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_CSRS))
376 cvmx_dprintf("Write: ");
377 cvmx_csr_db_decode(cvmx_get_proc_id(), address, value);
380 cvmx_write64_uint64(address, value);
386 * Utility function to convert complete codes into strings
388 * @param complete_code
391 * @return Human readable string
393 static const char *__cvmx_usb_complete_to_string(cvmx_usb_complete_t complete_code)
395 switch (complete_code)
397 case CVMX_USB_COMPLETE_SUCCESS: return "SUCCESS";
398 case CVMX_USB_COMPLETE_SHORT: return "SHORT";
399 case CVMX_USB_COMPLETE_CANCEL: return "CANCEL";
400 case CVMX_USB_COMPLETE_ERROR: return "ERROR";
401 case CVMX_USB_COMPLETE_STALL: return "STALL";
402 case CVMX_USB_COMPLETE_XACTERR: return "XACTERR";
403 case CVMX_USB_COMPLETE_DATATGLERR: return "DATATGLERR";
404 case CVMX_USB_COMPLETE_BABBLEERR: return "BABBLEERR";
405 case CVMX_USB_COMPLETE_FRAMEERR: return "FRAMEERR";
407 return "Update __cvmx_usb_complete_to_string";
413 * Return non zero if this pipe connects to a non HIGH speed
414 * device through a high speed hub.
416 * @param usb USB block this access is for
417 * @param pipe Pipe to check
419 * @return Non zero if we need to do split transactions
421 static inline int __cvmx_usb_pipe_needs_split(cvmx_usb_internal_state_t *usb, cvmx_usb_pipe_t *pipe)
423 return ((pipe->device_speed != CVMX_USB_SPEED_HIGH) && (usb->usbcx_hprt.s.prtspd == CVMX_USB_SPEED_HIGH));
429 * Trivial utility function to return the correct PID for a pipe
431 * @param pipe pipe to check
433 * @return PID for pipe
435 static inline int __cvmx_usb_get_data_pid(cvmx_usb_pipe_t *pipe)
437 if (pipe->pid_toggle)
438 return 2; /* Data1 */
440 return 0; /* Data0 */
445 * Return the number of USB ports supported by this Octeon
446 * chip. If the chip doesn't support USB, or is not supported
447 * by this API, a zero will be returned. Most Octeon chips
448 * support one usb port, but some support two ports.
449 * cvmx_usb_initialize() must be called on independent
450 * cvmx_usb_state_t structures.
452 * This utilizes cvmx_helper_board_usb_get_num_ports()
453 * to get any board specific variations.
455 * @return Number of port, zero if usb isn't supported
457 int cvmx_usb_get_num_ports(void)
461 if (OCTEON_IS_MODEL(OCTEON_CN56XX))
463 else if (OCTEON_IS_MODEL(OCTEON_CN52XX))
465 else if (OCTEON_IS_MODEL(OCTEON_CN50XX))
467 else if (OCTEON_IS_MODEL(OCTEON_CN31XX))
469 else if (OCTEON_IS_MODEL(OCTEON_CN30XX))
474 return __cvmx_helper_board_usb_get_num_ports(arch_ports);
476 #ifdef CVMX_BUILD_FOR_LINUX_KERNEL
477 EXPORT_SYMBOL(cvmx_usb_get_num_ports);
483 * Allocate a usb transaction for use
485 * @param usb USB device state populated by
486 * cvmx_usb_initialize().
488 * @return Transaction or NULL
490 static inline cvmx_usb_transaction_t *__cvmx_usb_alloc_transaction(cvmx_usb_internal_state_t *usb)
492 cvmx_usb_transaction_t *t;
493 t = usb->free_transaction_head;
496 usb->free_transaction_head = t->next;
497 if (!usb->free_transaction_head)
498 usb->free_transaction_tail = NULL;
500 else if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_INFO))
501 cvmx_dprintf("%s: Failed to allocate a transaction\n", __FUNCTION__);
504 memset(t, 0, sizeof(*t));
505 t->flags = __CVMX_USB_TRANSACTION_FLAGS_IN_USE;
513 * Free a usb transaction
515 * @param usb USB device state populated by
516 * cvmx_usb_initialize().
518 * Transaction to free
520 static inline void __cvmx_usb_free_transaction(cvmx_usb_internal_state_t *usb,
521 cvmx_usb_transaction_t *transaction)
523 transaction->flags = 0;
524 transaction->prev = NULL;
525 transaction->next = NULL;
526 if (usb->free_transaction_tail)
527 usb->free_transaction_tail->next = transaction;
529 usb->free_transaction_head = transaction;
530 usb->free_transaction_tail = transaction;
536 * Add a pipe to the tail of a list
537 * @param list List to add pipe to
538 * @param pipe Pipe to add
540 static inline void __cvmx_usb_append_pipe(cvmx_usb_pipe_list_t *list, cvmx_usb_pipe_t *pipe)
543 pipe->prev = list->tail;
545 list->tail->next = pipe;
554 * Remove a pipe from a list
555 * @param list List to remove pipe from
556 * @param pipe Pipe to remove
558 static inline void __cvmx_usb_remove_pipe(cvmx_usb_pipe_list_t *list, cvmx_usb_pipe_t *pipe)
560 if (list->head == pipe)
562 list->head = pipe->next;
565 list->head->prev = NULL;
569 else if (list->tail == pipe)
571 list->tail = pipe->prev;
572 list->tail->next = NULL;
577 pipe->prev->next = pipe->next;
578 pipe->next->prev = pipe->prev;
586 * Initialize a USB port for use. This must be called before any
587 * other access to the Octeon USB port is made. The port starts
588 * off in the disabled state.
590 * @param state Pointer to an empty cvmx_usb_state_t structure
591 * that will be populated by the initialize call.
592 * This structure is then passed to all other USB
594 * @param usb_port_number
595 * Which Octeon USB port to initialize.
596 * @param flags Flags to control hardware initialization. See
597 * cvmx_usb_initialize_flags_t for the flag
598 * definitions. Some flags are mandatory.
600 * @return CVMX_USB_SUCCESS or a negative error code defined in
603 cvmx_usb_status_t cvmx_usb_initialize(cvmx_usb_state_t *state,
605 cvmx_usb_initialize_flags_t flags)
607 cvmx_usbnx_clk_ctl_t usbn_clk_ctl;
608 cvmx_usbnx_usbp_ctl_status_t usbn_usbp_ctl_status;
609 cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
611 usb->init_flags = flags;
612 CVMX_USB_LOG_CALLED();
613 CVMX_USB_LOG_PARAM("%p", state);
614 CVMX_USB_LOG_PARAM("%d", usb_port_number);
615 CVMX_USB_LOG_PARAM("0x%x", flags);
617 /* Make sure that state is large enough to store the internal state */
618 if (sizeof(*state) < sizeof(*usb))
619 CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
620 /* At first allow 0-1 for the usb port number */
621 if ((usb_port_number < 0) || (usb_port_number > 1))
622 CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
623 /* For all chips except 52XX there is only one port */
624 if (!OCTEON_IS_MODEL(OCTEON_CN52XX) && (usb_port_number > 0))
625 CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
626 /* Try to determine clock type automatically */
627 if ((flags & (CVMX_USB_INITIALIZE_FLAGS_CLOCK_XO_XI |
628 CVMX_USB_INITIALIZE_FLAGS_CLOCK_XO_GND)) == 0)
630 if (__cvmx_helper_board_usb_get_clock_type() == USB_CLOCK_TYPE_CRYSTAL_12)
631 flags |= CVMX_USB_INITIALIZE_FLAGS_CLOCK_XO_XI; /* Only 12 MHZ crystals are supported */
633 flags |= CVMX_USB_INITIALIZE_FLAGS_CLOCK_XO_GND;
636 if (flags & CVMX_USB_INITIALIZE_FLAGS_CLOCK_XO_GND)
638 /* Check for auto ref clock frequency */
639 if (!(flags & CVMX_USB_INITIALIZE_FLAGS_CLOCK_MHZ_MASK))
640 switch (__cvmx_helper_board_usb_get_clock_type())
642 case USB_CLOCK_TYPE_REF_12:
643 flags |= CVMX_USB_INITIALIZE_FLAGS_CLOCK_12MHZ;
645 case USB_CLOCK_TYPE_REF_24:
646 flags |= CVMX_USB_INITIALIZE_FLAGS_CLOCK_24MHZ;
648 case USB_CLOCK_TYPE_REF_48:
649 flags |= CVMX_USB_INITIALIZE_FLAGS_CLOCK_48MHZ;
652 CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
657 memset(usb, 0, sizeof(usb));
658 usb->init_flags = flags;
660 /* Initialize the USB state structure */
663 usb->index = usb_port_number;
665 /* Initialize the transaction double linked list */
666 usb->free_transaction_head = NULL;
667 usb->free_transaction_tail = NULL;
668 for (i=0; i<MAX_TRANSACTIONS; i++)
669 __cvmx_usb_free_transaction(usb, usb->transaction + i);
670 for (i=0; i<MAX_PIPES; i++)
671 __cvmx_usb_append_pipe(&usb->free_pipes, usb->pipe + i);
674 /* Power On Reset and PHY Initialization */
676 /* 1. Wait for DCOK to assert (nothing to do) */
677 /* 2a. Write USBN0/1_CLK_CTL[POR] = 1 and
678 USBN0/1_CLK_CTL[HRST,PRST,HCLK_RST] = 0 */
679 usbn_clk_ctl.u64 = __cvmx_usb_read_csr64(usb, CVMX_USBNX_CLK_CTL(usb->index));
680 usbn_clk_ctl.s.por = 1;
681 usbn_clk_ctl.s.hrst = 0;
682 usbn_clk_ctl.s.prst = 0;
683 usbn_clk_ctl.s.hclk_rst = 0;
684 usbn_clk_ctl.s.enable = 0;
685 /* 2b. Select the USB reference clock/crystal parameters by writing
686 appropriate values to USBN0/1_CLK_CTL[P_C_SEL, P_RTYPE, P_COM_ON] */
687 if (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_CLOCK_XO_GND)
689 /* The USB port uses 12/24/48MHz 2.5V board clock
690 source at USB_XO. USB_XI should be tied to GND.
691 Most Octeon evaluation boards require this setting */
692 if (OCTEON_IS_MODEL(OCTEON_CN3XXX))
694 usbn_clk_ctl.cn31xx.p_rclk = 1; /* From CN31XX,CN30XX manual */
695 usbn_clk_ctl.cn31xx.p_xenbn = 0;
697 else if (OCTEON_IS_MODEL(OCTEON_CN56XX) || OCTEON_IS_MODEL(OCTEON_CN50XX))
698 usbn_clk_ctl.cn56xx.p_rtype = 2; /* From CN56XX,CN50XX manual */
700 usbn_clk_ctl.cn52xx.p_rtype = 1; /* From CN52XX manual */
702 switch (flags & CVMX_USB_INITIALIZE_FLAGS_CLOCK_MHZ_MASK)
704 case CVMX_USB_INITIALIZE_FLAGS_CLOCK_12MHZ:
705 usbn_clk_ctl.s.p_c_sel = 0;
707 case CVMX_USB_INITIALIZE_FLAGS_CLOCK_24MHZ:
708 usbn_clk_ctl.s.p_c_sel = 1;
710 case CVMX_USB_INITIALIZE_FLAGS_CLOCK_48MHZ:
711 usbn_clk_ctl.s.p_c_sel = 2;
717 /* The USB port uses a 12MHz crystal as clock source
718 at USB_XO and USB_XI */
719 if (OCTEON_IS_MODEL(OCTEON_CN3XXX))
721 usbn_clk_ctl.cn31xx.p_rclk = 1; /* From CN31XX,CN30XX manual */
722 usbn_clk_ctl.cn31xx.p_xenbn = 1;
724 else if (OCTEON_IS_MODEL(OCTEON_CN56XX) || OCTEON_IS_MODEL(OCTEON_CN50XX))
725 usbn_clk_ctl.cn56xx.p_rtype = 0; /* From CN56XX,CN50XX manual */
727 usbn_clk_ctl.cn52xx.p_rtype = 0; /* From CN52XX manual */
729 usbn_clk_ctl.s.p_c_sel = 0;
731 /* 2c. Select the HCLK via writing USBN0/1_CLK_CTL[DIVIDE, DIVIDE2] and
732 setting USBN0/1_CLK_CTL[ENABLE] = 1. Divide the core clock down such
733 that USB is as close as possible to 125Mhz */
735 int divisor = (cvmx_clock_get_rate(CVMX_CLOCK_CORE)+125000000-1)/125000000;
736 if (divisor < 4) /* Lower than 4 doesn't seem to work properly */
738 usbn_clk_ctl.s.divide = divisor;
739 usbn_clk_ctl.s.divide2 = 0;
741 __cvmx_usb_write_csr64(usb, CVMX_USBNX_CLK_CTL(usb->index),
743 /* 2d. Write USBN0/1_CLK_CTL[HCLK_RST] = 1 */
744 usbn_clk_ctl.s.hclk_rst = 1;
745 __cvmx_usb_write_csr64(usb, CVMX_USBNX_CLK_CTL(usb->index),
747 /* 2e. Wait 64 core-clock cycles for HCLK to stabilize */
749 /* 3. Program the power-on reset field in the USBN clock-control register:
750 USBN_CLK_CTL[POR] = 0 */
751 usbn_clk_ctl.s.por = 0;
752 __cvmx_usb_write_csr64(usb, CVMX_USBNX_CLK_CTL(usb->index),
754 /* 4. Wait 1 ms for PHY clock to start */
755 cvmx_wait_usec(1000);
756 /* 5. Program the Reset input from automatic test equipment field in the
757 USBP control and status register: USBN_USBP_CTL_STATUS[ATE_RESET] = 1 */
758 usbn_usbp_ctl_status.u64 = __cvmx_usb_read_csr64(usb, CVMX_USBNX_USBP_CTL_STATUS(usb->index));
759 usbn_usbp_ctl_status.s.ate_reset = 1;
760 __cvmx_usb_write_csr64(usb, CVMX_USBNX_USBP_CTL_STATUS(usb->index),
761 usbn_usbp_ctl_status.u64);
762 /* 6. Wait 10 cycles */
764 /* 7. Clear ATE_RESET field in the USBN clock-control register:
765 USBN_USBP_CTL_STATUS[ATE_RESET] = 0 */
766 usbn_usbp_ctl_status.s.ate_reset = 0;
767 __cvmx_usb_write_csr64(usb, CVMX_USBNX_USBP_CTL_STATUS(usb->index),
768 usbn_usbp_ctl_status.u64);
769 /* 8. Program the PHY reset field in the USBN clock-control register:
770 USBN_CLK_CTL[PRST] = 1 */
771 usbn_clk_ctl.s.prst = 1;
772 __cvmx_usb_write_csr64(usb, CVMX_USBNX_CLK_CTL(usb->index),
774 /* 9. Program the USBP control and status register to select host or
775 device mode. USBN_USBP_CTL_STATUS[HST_MODE] = 0 for host, = 1 for
777 usbn_usbp_ctl_status.s.hst_mode = 0;
778 __cvmx_usb_write_csr64(usb, CVMX_USBNX_USBP_CTL_STATUS(usb->index),
779 usbn_usbp_ctl_status.u64);
782 /* 11. Program the hreset_n field in the USBN clock-control register:
783 USBN_CLK_CTL[HRST] = 1 */
784 usbn_clk_ctl.s.hrst = 1;
785 __cvmx_usb_write_csr64(usb, CVMX_USBNX_CLK_CTL(usb->index),
787 /* 12. Proceed to USB core initialization */
788 usbn_clk_ctl.s.enable = 1;
789 __cvmx_usb_write_csr64(usb, CVMX_USBNX_CLK_CTL(usb->index),
793 /* USB Core Initialization */
795 /* 1. Read USBC_GHWCFG1, USBC_GHWCFG2, USBC_GHWCFG3, USBC_GHWCFG4 to
796 determine USB core configuration parameters. */
798 /* 2. Program the following fields in the global AHB configuration
799 register (USBC_GAHBCFG)
800 DMA mode, USBC_GAHBCFG[DMAEn]: 1 = DMA mode, 0 = slave mode
801 Burst length, USBC_GAHBCFG[HBSTLEN] = 0
802 Nonperiodic TxFIFO empty level (slave mode only),
803 USBC_GAHBCFG[NPTXFEMPLVL]
804 Periodic TxFIFO empty level (slave mode only),
805 USBC_GAHBCFG[PTXFEMPLVL]
806 Global interrupt mask, USBC_GAHBCFG[GLBLINTRMSK] = 1 */
808 cvmx_usbcx_gahbcfg_t usbcx_gahbcfg;
809 /* Due to an errata, CN31XX doesn't support DMA */
810 if (OCTEON_IS_MODEL(OCTEON_CN31XX))
811 usb->init_flags |= CVMX_USB_INITIALIZE_FLAGS_NO_DMA;
812 usbcx_gahbcfg.u32 = 0;
813 usbcx_gahbcfg.s.dmaen = !(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_NO_DMA);
814 if (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_NO_DMA)
815 usb->idle_hardware_channels = 0x1; /* Only use one channel with non DMA */
816 else if (OCTEON_IS_MODEL(OCTEON_CN5XXX))
817 usb->idle_hardware_channels = 0xf7; /* CN5XXX have an errata with channel 3 */
819 usb->idle_hardware_channels = 0xff;
820 usbcx_gahbcfg.s.hbstlen = 0;
821 usbcx_gahbcfg.s.nptxfemplvl = 1;
822 usbcx_gahbcfg.s.ptxfemplvl = 1;
823 usbcx_gahbcfg.s.glblintrmsk = 1;
824 __cvmx_usb_write_csr32(usb, CVMX_USBCX_GAHBCFG(usb->index),
827 /* 3. Program the following fields in USBC_GUSBCFG register.
828 HS/FS timeout calibration, USBC_GUSBCFG[TOUTCAL] = 0
829 ULPI DDR select, USBC_GUSBCFG[DDRSEL] = 0
830 USB turnaround time, USBC_GUSBCFG[USBTRDTIM] = 0x5
831 PHY low-power clock select, USBC_GUSBCFG[PHYLPWRCLKSEL] = 0 */
833 cvmx_usbcx_gusbcfg_t usbcx_gusbcfg;
834 usbcx_gusbcfg.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_GUSBCFG(usb->index));
835 usbcx_gusbcfg.s.toutcal = 0;
836 usbcx_gusbcfg.s.ddrsel = 0;
837 usbcx_gusbcfg.s.usbtrdtim = 0x5;
838 usbcx_gusbcfg.s.phylpwrclksel = 0;
839 __cvmx_usb_write_csr32(usb, CVMX_USBCX_GUSBCFG(usb->index),
842 /* 4. The software must unmask the following bits in the USBC_GINTMSK
844 OTG interrupt mask, USBC_GINTMSK[OTGINTMSK] = 1
845 Mode mismatch interrupt mask, USBC_GINTMSK[MODEMISMSK] = 1 */
847 cvmx_usbcx_gintmsk_t usbcx_gintmsk;
850 usbcx_gintmsk.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_GINTMSK(usb->index));
851 usbcx_gintmsk.s.otgintmsk = 1;
852 usbcx_gintmsk.s.modemismsk = 1;
853 usbcx_gintmsk.s.hchintmsk = 1;
854 usbcx_gintmsk.s.sofmsk = 0;
855 /* We need RX FIFO interrupts if we don't have DMA */
856 if (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_NO_DMA)
857 usbcx_gintmsk.s.rxflvlmsk = 1;
858 __cvmx_usb_write_csr32(usb, CVMX_USBCX_GINTMSK(usb->index),
861 /* Disable all channel interrupts. We'll enable them per channel later */
862 for (channel=0; channel<8; channel++)
863 __cvmx_usb_write_csr32(usb, CVMX_USBCX_HCINTMSKX(channel, usb->index), 0);
867 /* Host Port Initialization */
868 if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_INFO))
869 cvmx_dprintf("%s: USB%d is in host mode\n", __FUNCTION__, usb->index);
871 /* 1. Program the host-port interrupt-mask field to unmask,
872 USBC_GINTMSK[PRTINT] = 1 */
873 USB_SET_FIELD32(CVMX_USBCX_GINTMSK(usb->index), cvmx_usbcx_gintmsk_t,
875 USB_SET_FIELD32(CVMX_USBCX_GINTMSK(usb->index), cvmx_usbcx_gintmsk_t,
877 /* 2. Program the USBC_HCFG register to select full-speed host or
880 cvmx_usbcx_hcfg_t usbcx_hcfg;
881 usbcx_hcfg.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HCFG(usb->index));
882 usbcx_hcfg.s.fslssupp = 0;
883 usbcx_hcfg.s.fslspclksel = 0;
884 __cvmx_usb_write_csr32(usb, CVMX_USBCX_HCFG(usb->index), usbcx_hcfg.u32);
886 /* 3. Program the port power bit to drive VBUS on the USB,
887 USBC_HPRT[PRTPWR] = 1 */
888 USB_SET_FIELD32(CVMX_USBCX_HPRT(usb->index), cvmx_usbcx_hprt_t, prtpwr, 1);
890 /* Steps 4-15 from the manual are done later in the port enable */
893 #ifdef __CVMX_ERROR_H__
894 cvmx_error_enable_group(CVMX_ERROR_GROUP_USB, usb->index);
896 CVMX_USB_RETURN(CVMX_USB_SUCCESS);
898 #ifdef CVMX_BUILD_FOR_LINUX_KERNEL
899 EXPORT_SYMBOL(cvmx_usb_initialize);
904 * Shutdown a USB port after a call to cvmx_usb_initialize().
905 * The port should be disabled with all pipes closed when this
906 * function is called.
908 * @param state USB device state populated by
909 * cvmx_usb_initialize().
911 * @return CVMX_USB_SUCCESS or a negative error code defined in
914 cvmx_usb_status_t cvmx_usb_shutdown(cvmx_usb_state_t *state)
916 cvmx_usbnx_clk_ctl_t usbn_clk_ctl;
917 cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
919 CVMX_USB_LOG_CALLED();
920 CVMX_USB_LOG_PARAM("%p", state);
922 /* Make sure all pipes are closed */
923 if (usb->idle_pipes.head ||
924 usb->active_pipes[CVMX_USB_TRANSFER_ISOCHRONOUS].head ||
925 usb->active_pipes[CVMX_USB_TRANSFER_INTERRUPT].head ||
926 usb->active_pipes[CVMX_USB_TRANSFER_CONTROL].head ||
927 usb->active_pipes[CVMX_USB_TRANSFER_BULK].head)
928 CVMX_USB_RETURN(CVMX_USB_BUSY);
930 #ifdef __CVMX_ERROR_H__
931 cvmx_error_disable_group(CVMX_ERROR_GROUP_USB, usb->index);
934 /* Disable the clocks and put them in power on reset */
935 usbn_clk_ctl.u64 = __cvmx_usb_read_csr64(usb, CVMX_USBNX_CLK_CTL(usb->index));
936 usbn_clk_ctl.s.enable = 1;
937 usbn_clk_ctl.s.por = 1;
938 usbn_clk_ctl.s.hclk_rst = 1;
939 usbn_clk_ctl.s.prst = 0;
940 usbn_clk_ctl.s.hrst = 0;
941 __cvmx_usb_write_csr64(usb, CVMX_USBNX_CLK_CTL(usb->index),
943 CVMX_USB_RETURN(CVMX_USB_SUCCESS);
945 #ifdef CVMX_BUILD_FOR_LINUX_KERNEL
946 EXPORT_SYMBOL(cvmx_usb_shutdown);
951 * Enable a USB port. After this call succeeds, the USB port is
952 * online and servicing requests.
954 * @param state USB device state populated by
955 * cvmx_usb_initialize().
957 * @return CVMX_USB_SUCCESS or a negative error code defined in
960 cvmx_usb_status_t cvmx_usb_enable(cvmx_usb_state_t *state)
962 cvmx_usbcx_ghwcfg3_t usbcx_ghwcfg3;
963 cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
965 CVMX_USB_LOG_CALLED();
966 CVMX_USB_LOG_PARAM("%p", state);
968 usb->usbcx_hprt.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HPRT(usb->index));
970 /* If the port is already enabled the just return. We don't need to do
972 if (usb->usbcx_hprt.s.prtena)
973 CVMX_USB_RETURN(CVMX_USB_SUCCESS);
975 /* If there is nothing plugged into the port then fail immediately */
976 if (!usb->usbcx_hprt.s.prtconnsts)
978 if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_INFO))
979 cvmx_dprintf("%s: USB%d Nothing plugged into the port\n", __FUNCTION__, usb->index);
980 CVMX_USB_RETURN(CVMX_USB_TIMEOUT);
983 /* Program the port reset bit to start the reset process */
984 USB_SET_FIELD32(CVMX_USBCX_HPRT(usb->index), cvmx_usbcx_hprt_t, prtrst, 1);
986 /* Wait at least 50ms (high speed), or 10ms (full speed) for the reset
987 process to complete. */
988 cvmx_wait_usec(50000);
990 /* Program the port reset bit to 0, USBC_HPRT[PRTRST] = 0 */
991 USB_SET_FIELD32(CVMX_USBCX_HPRT(usb->index), cvmx_usbcx_hprt_t, prtrst, 0);
993 /* Wait for the USBC_HPRT[PRTENA]. */
994 if (CVMX_WAIT_FOR_FIELD32(CVMX_USBCX_HPRT(usb->index), cvmx_usbcx_hprt_t,
995 prtena, ==, 1, 100000))
997 if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_INFO))
998 cvmx_dprintf("%s: Timeout waiting for the port to finish reset\n",
1000 CVMX_USB_RETURN(CVMX_USB_TIMEOUT);
1003 /* Read the port speed field to get the enumerated speed, USBC_HPRT[PRTSPD]. */
1004 usb->usbcx_hprt.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HPRT(usb->index));
1005 if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_INFO))
1006 cvmx_dprintf("%s: USB%d is in %s speed mode\n", __FUNCTION__, usb->index,
1007 (usb->usbcx_hprt.s.prtspd == CVMX_USB_SPEED_HIGH) ? "high" :
1008 (usb->usbcx_hprt.s.prtspd == CVMX_USB_SPEED_FULL) ? "full" :
1011 usbcx_ghwcfg3.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_GHWCFG3(usb->index));
1013 /* 13. Program the USBC_GRXFSIZ register to select the size of the receive
1015 USB_SET_FIELD32(CVMX_USBCX_GRXFSIZ(usb->index), cvmx_usbcx_grxfsiz_t,
1016 rxfdep, usbcx_ghwcfg3.s.dfifodepth / 4);
1017 /* 14. Program the USBC_GNPTXFSIZ register to select the size and the
1018 start address of the non- periodic transmit FIFO for nonperiodic
1019 transactions (50%). */
1021 cvmx_usbcx_gnptxfsiz_t siz;
1022 siz.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_GNPTXFSIZ(usb->index));
1023 siz.s.nptxfdep = usbcx_ghwcfg3.s.dfifodepth / 2;
1024 siz.s.nptxfstaddr = usbcx_ghwcfg3.s.dfifodepth / 4;
1025 __cvmx_usb_write_csr32(usb, CVMX_USBCX_GNPTXFSIZ(usb->index), siz.u32);
1027 /* 15. Program the USBC_HPTXFSIZ register to select the size and start
1028 address of the periodic transmit FIFO for periodic transactions (25%). */
1030 cvmx_usbcx_hptxfsiz_t siz;
1031 siz.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HPTXFSIZ(usb->index));
1032 siz.s.ptxfsize = usbcx_ghwcfg3.s.dfifodepth / 4;
1033 siz.s.ptxfstaddr = 3 * usbcx_ghwcfg3.s.dfifodepth / 4;
1034 __cvmx_usb_write_csr32(usb, CVMX_USBCX_HPTXFSIZ(usb->index), siz.u32);
1036 /* Flush all FIFOs */
1037 USB_SET_FIELD32(CVMX_USBCX_GRSTCTL(usb->index), cvmx_usbcx_grstctl_t, txfnum, 0x10);
1038 USB_SET_FIELD32(CVMX_USBCX_GRSTCTL(usb->index), cvmx_usbcx_grstctl_t, txfflsh, 1);
1039 CVMX_WAIT_FOR_FIELD32(CVMX_USBCX_GRSTCTL(usb->index), cvmx_usbcx_grstctl_t,
1040 txfflsh, ==, 0, 100);
1041 USB_SET_FIELD32(CVMX_USBCX_GRSTCTL(usb->index), cvmx_usbcx_grstctl_t, rxfflsh, 1);
1042 CVMX_WAIT_FOR_FIELD32(CVMX_USBCX_GRSTCTL(usb->index), cvmx_usbcx_grstctl_t,
1043 rxfflsh, ==, 0, 100);
1045 CVMX_USB_RETURN(CVMX_USB_SUCCESS);
1047 #ifdef CVMX_BUILD_FOR_LINUX_KERNEL
1048 EXPORT_SYMBOL(cvmx_usb_enable);
1053 * Disable a USB port. After this call the USB port will not
1054 * generate data transfers and will not generate events.
1055 * Transactions in process will fail and call their
1056 * associated callbacks.
1058 * @param state USB device state populated by
1059 * cvmx_usb_initialize().
1061 * @return CVMX_USB_SUCCESS or a negative error code defined in
1062 * cvmx_usb_status_t.
1064 cvmx_usb_status_t cvmx_usb_disable(cvmx_usb_state_t *state)
1066 cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
1068 CVMX_USB_LOG_CALLED();
1069 CVMX_USB_LOG_PARAM("%p", state);
1071 /* Disable the port */
1072 USB_SET_FIELD32(CVMX_USBCX_HPRT(usb->index), cvmx_usbcx_hprt_t, prtena, 1);
1073 CVMX_USB_RETURN(CVMX_USB_SUCCESS);
1075 #ifdef CVMX_BUILD_FOR_LINUX_KERNEL
1076 EXPORT_SYMBOL(cvmx_usb_disable);
1081 * Get the current state of the USB port. Use this call to
1082 * determine if the usb port has anything connected, is enabled,
1083 * or has some sort of error condition. The return value of this
1084 * call has "changed" bits to signal of the value of some fields
1085 * have changed between calls. These "changed" fields are based
1086 * on the last call to cvmx_usb_set_status(). In order to clear
1087 * them, you must update the status through cvmx_usb_set_status().
1089 * @param state USB device state populated by
1090 * cvmx_usb_initialize().
1092 * @return Port status information
1094 cvmx_usb_port_status_t cvmx_usb_get_status(cvmx_usb_state_t *state)
1096 cvmx_usbcx_hprt_t usbc_hprt;
1097 cvmx_usb_port_status_t result;
1098 cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
1100 memset(&result, 0, sizeof(result));
1102 CVMX_USB_LOG_CALLED();
1103 CVMX_USB_LOG_PARAM("%p", state);
1105 usbc_hprt.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HPRT(usb->index));
1106 result.port_enabled = usbc_hprt.s.prtena;
1107 result.port_over_current = usbc_hprt.s.prtovrcurract;
1108 result.port_powered = usbc_hprt.s.prtpwr;
1109 result.port_speed = usbc_hprt.s.prtspd;
1110 result.connected = usbc_hprt.s.prtconnsts;
1111 result.connect_change = (result.connected != usb->port_status.connected);
1113 if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_CALLS))
1114 cvmx_dprintf("%*s%s: returned port enabled=%d, over_current=%d, powered=%d, speed=%d, connected=%d, connect_change=%d\n",
1115 2*(--usb->indent), "", __FUNCTION__,
1116 result.port_enabled,
1117 result.port_over_current,
1118 result.port_powered,
1121 result.connect_change);
1124 #ifdef CVMX_BUILD_FOR_LINUX_KERNEL
1125 EXPORT_SYMBOL(cvmx_usb_get_status);
1130 * Set the current state of the USB port. The status is used as
1131 * a reference for the "changed" bits returned by
1132 * cvmx_usb_get_status(). Other than serving as a reference, the
1133 * status passed to this function is not used. No fields can be
1134 * changed through this call.
1136 * @param state USB device state populated by
1137 * cvmx_usb_initialize().
1138 * @param port_status
1139 * Port status to set, most like returned by cvmx_usb_get_status()
1141 void cvmx_usb_set_status(cvmx_usb_state_t *state, cvmx_usb_port_status_t port_status)
1143 cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
1144 CVMX_USB_LOG_CALLED();
1145 CVMX_USB_LOG_PARAM("%p", state);
1146 usb->port_status = port_status;
1147 CVMX_USB_RETURN_NOTHING();
1149 #ifdef CVMX_BUILD_FOR_LINUX_KERNEL
1150 EXPORT_SYMBOL(cvmx_usb_set_status);
1156 * Convert a USB transaction into a handle
1158 * @param usb USB device state populated by
1159 * cvmx_usb_initialize().
1160 * @param transaction
1161 * Transaction to get handle for
1165 static inline int __cvmx_usb_get_submit_handle(cvmx_usb_internal_state_t *usb,
1166 cvmx_usb_transaction_t *transaction)
1168 return ((unsigned long)transaction - (unsigned long)usb->transaction) /
1169 sizeof(*transaction);
1175 * Convert a USB pipe into a handle
1177 * @param usb USB device state populated by
1178 * cvmx_usb_initialize().
1179 * @param pipe Pipe to get handle for
1183 static inline int __cvmx_usb_get_pipe_handle(cvmx_usb_internal_state_t *usb,
1184 cvmx_usb_pipe_t *pipe)
1186 return ((unsigned long)pipe - (unsigned long)usb->pipe) / sizeof(*pipe);
1191 * Open a virtual pipe between the host and a USB device. A pipe
1192 * must be opened before data can be transferred between a device
1195 * @param state USB device state populated by
1196 * cvmx_usb_initialize().
1197 * @param flags Optional pipe flags defined in
1198 * cvmx_usb_pipe_flags_t.
1199 * @param device_addr
1200 * USB device address to open the pipe to
1202 * @param endpoint_num
1203 * USB endpoint number to open the pipe to
1205 * @param device_speed
1206 * The speed of the device the pipe is going
1207 * to. This must match the device's speed,
1208 * which may be different than the port speed.
1209 * @param max_packet The maximum packet length the device can
1210 * transmit/receive (low speed=0-8, full
1211 * speed=0-1023, high speed=0-1024). This value
1212 * comes from the standard endpoint descriptor
1213 * field wMaxPacketSize bits <10:0>.
1214 * @param transfer_type
1215 * The type of transfer this pipe is for.
1216 * @param transfer_dir
1217 * The direction the pipe is in. This is not
1218 * used for control pipes.
1219 * @param interval For ISOCHRONOUS and INTERRUPT transfers,
1220 * this is how often the transfer is scheduled
1221 * for. All other transfers should specify
1222 * zero. The units are in frames (8000/sec at
1223 * high speed, 1000/sec for full speed).
1224 * @param multi_count
1225 * For high speed devices, this is the maximum
1226 * allowed number of packet per microframe.
1227 * Specify zero for non high speed devices. This
1228 * value comes from the standard endpoint descriptor
1229 * field wMaxPacketSize bits <12:11>.
1230 * @param hub_device_addr
1231 * Hub device address this device is connected
1232 * to. Devices connected directly to Octeon
1233 * use zero. This is only used when the device
1234 * is full/low speed behind a high speed hub.
1235 * The address will be of the high speed hub,
1236 * not and full speed hubs after it.
1237 * @param hub_port Which port on the hub the device is
1238 * connected. Use zero for devices connected
1239 * directly to Octeon. Like hub_device_addr,
1240 * this is only used for full/low speed
1241 * devices behind a high speed hub.
1243 * @return A non negative value is a pipe handle. Negative
1244 * values are failure codes from cvmx_usb_status_t.
1246 int cvmx_usb_open_pipe(cvmx_usb_state_t *state, cvmx_usb_pipe_flags_t flags,
1247 int device_addr, int endpoint_num,
1248 cvmx_usb_speed_t device_speed, int max_packet,
1249 cvmx_usb_transfer_t transfer_type,
1250 cvmx_usb_direction_t transfer_dir, int interval,
1251 int multi_count, int hub_device_addr, int hub_port)
1253 cvmx_usb_pipe_t *pipe;
1254 cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
1256 CVMX_USB_LOG_CALLED();
1257 CVMX_USB_LOG_PARAM("%p", state);
1258 CVMX_USB_LOG_PARAM("0x%x", flags);
1259 CVMX_USB_LOG_PARAM("%d", device_addr);
1260 CVMX_USB_LOG_PARAM("%d", endpoint_num);
1261 CVMX_USB_LOG_PARAM("%d", device_speed);
1262 CVMX_USB_LOG_PARAM("%d", max_packet);
1263 CVMX_USB_LOG_PARAM("%d", transfer_type);
1264 CVMX_USB_LOG_PARAM("%d", transfer_dir);
1265 CVMX_USB_LOG_PARAM("%d", interval);
1266 CVMX_USB_LOG_PARAM("%d", multi_count);
1267 CVMX_USB_LOG_PARAM("%d", hub_device_addr);
1268 CVMX_USB_LOG_PARAM("%d", hub_port);
1270 if (cvmx_unlikely((device_addr < 0) || (device_addr > MAX_USB_ADDRESS)))
1271 CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
1272 if (cvmx_unlikely((endpoint_num < 0) || (endpoint_num > MAX_USB_ENDPOINT)))
1273 CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
1274 if (cvmx_unlikely(device_speed > CVMX_USB_SPEED_LOW))
1275 CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
1276 if (cvmx_unlikely((max_packet <= 0) || (max_packet > 1024)))
1277 CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
1278 if (cvmx_unlikely(transfer_type > CVMX_USB_TRANSFER_INTERRUPT))
1279 CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
1280 if (cvmx_unlikely((transfer_dir != CVMX_USB_DIRECTION_OUT) &&
1281 (transfer_dir != CVMX_USB_DIRECTION_IN)))
1282 CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
1283 if (cvmx_unlikely(interval < 0))
1284 CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
1285 if (cvmx_unlikely((transfer_type == CVMX_USB_TRANSFER_CONTROL) && interval))
1286 CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
1287 if (cvmx_unlikely(multi_count < 0))
1288 CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
1289 if (cvmx_unlikely((device_speed != CVMX_USB_SPEED_HIGH) &&
1290 (multi_count != 0)))
1291 CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
1292 if (cvmx_unlikely((hub_device_addr < 0) || (hub_device_addr > MAX_USB_ADDRESS)))
1293 CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
1294 if (cvmx_unlikely((hub_port < 0) || (hub_port > MAX_USB_HUB_PORT)))
1295 CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
1297 /* Find a free pipe */
1298 pipe = usb->free_pipes.head;
1300 CVMX_USB_RETURN(CVMX_USB_NO_MEMORY);
1301 __cvmx_usb_remove_pipe(&usb->free_pipes, pipe);
1302 pipe->flags = flags | __CVMX_USB_PIPE_FLAGS_OPEN;
1303 if ((device_speed == CVMX_USB_SPEED_HIGH) &&
1304 (transfer_dir == CVMX_USB_DIRECTION_OUT) &&
1305 (transfer_type == CVMX_USB_TRANSFER_BULK))
1306 pipe->flags |= __CVMX_USB_PIPE_FLAGS_NEED_PING;
1307 pipe->device_addr = device_addr;
1308 pipe->endpoint_num = endpoint_num;
1309 pipe->device_speed = device_speed;
1310 pipe->max_packet = max_packet;
1311 pipe->transfer_type = transfer_type;
1312 pipe->transfer_dir = transfer_dir;
1313 /* All pipes use interval to rate limit NAK processing. Force an interval
1314 if one wasn't supplied */
1317 if (__cvmx_usb_pipe_needs_split(usb, pipe))
1319 pipe->interval = interval*8;
1320 /* Force start splits to be schedule on uFrame 0 */
1321 pipe->next_tx_frame = ((usb->frame_number+7)&~7) + pipe->interval;
1325 pipe->interval = interval;
1326 pipe->next_tx_frame = usb->frame_number + pipe->interval;
1328 pipe->multi_count = multi_count;
1329 pipe->hub_device_addr = hub_device_addr;
1330 pipe->hub_port = hub_port;
1331 pipe->pid_toggle = 0;
1332 pipe->split_sc_frame = -1;
1333 __cvmx_usb_append_pipe(&usb->idle_pipes, pipe);
1335 /* We don't need to tell the hardware about this pipe yet since
1336 it doesn't have any submitted requests */
1338 CVMX_USB_RETURN(__cvmx_usb_get_pipe_handle(usb, pipe));
1340 #ifdef CVMX_BUILD_FOR_LINUX_KERNEL
1341 EXPORT_SYMBOL(cvmx_usb_open_pipe);
1347 * Poll the RX FIFOs and remove data as needed. This function is only used
1348 * in non DMA mode. It is very important that this function be called quickly
1349 * enough to prevent FIFO overflow.
1351 * @param usb USB device state populated by
1352 * cvmx_usb_initialize().
1354 static void __cvmx_usb_poll_rx_fifo(cvmx_usb_internal_state_t *usb)
1356 cvmx_usbcx_grxstsph_t rx_status;
1362 CVMX_USB_LOG_CALLED();
1363 CVMX_USB_LOG_PARAM("%p", usb);
1365 rx_status.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_GRXSTSPH(usb->index));
1366 /* Only read data if IN data is there */
1367 if (rx_status.s.pktsts != 2)
1368 CVMX_USB_RETURN_NOTHING();
1369 /* Check if no data is available */
1370 if (!rx_status.s.bcnt)
1371 CVMX_USB_RETURN_NOTHING();
1373 channel = rx_status.s.chnum;
1374 bytes = rx_status.s.bcnt;
1376 CVMX_USB_RETURN_NOTHING();
1378 /* Get where the DMA engine would have written this data */
1379 address = __cvmx_usb_read_csr64(usb, CVMX_USBNX_DMA0_INB_CHN0(usb->index) + channel*8);
1380 ptr = cvmx_phys_to_ptr(address);
1381 __cvmx_usb_write_csr64(usb, CVMX_USBNX_DMA0_INB_CHN0(usb->index) + channel*8, address + bytes);
1383 /* Loop writing the FIFO data for this packet into memory */
1386 *ptr++ = __cvmx_usb_read_csr32(usb, USB_FIFO_ADDRESS(channel, usb->index));
1391 CVMX_USB_RETURN_NOTHING();
1396 * Fill the TX hardware fifo with data out of the software
1399 * @param usb USB device state populated by
1400 * cvmx_usb_initialize().
1401 * @param fifo Software fifo to use
1402 * @param available Amount of space in the hardware fifo
1404 * @return Non zero if the hardware fifo was too small and needs
1405 * to be serviced again.
1407 static int __cvmx_usb_fill_tx_hw(cvmx_usb_internal_state_t *usb, cvmx_usb_tx_fifo_t *fifo, int available)
1409 CVMX_USB_LOG_CALLED();
1410 CVMX_USB_LOG_PARAM("%p", usb);
1411 CVMX_USB_LOG_PARAM("%p", fifo);
1412 CVMX_USB_LOG_PARAM("%d", available);
1414 /* We're done either when there isn't anymore space or the software FIFO
1416 while (available && (fifo->head != fifo->tail))
1419 const uint32_t *ptr = cvmx_phys_to_ptr(fifo->entry[i].address);
1420 uint64_t csr_address = USB_FIFO_ADDRESS(fifo->entry[i].channel, usb->index) ^ 4;
1421 int words = available;
1423 /* Limit the amount of data to waht the SW fifo has */
1424 if (fifo->entry[i].size <= available)
1426 words = fifo->entry[i].size;
1428 if (fifo->tail > MAX_CHANNELS)
1432 /* Update the next locations and counts */
1434 fifo->entry[i].address += words * 4;
1435 fifo->entry[i].size -= words;
1437 /* Write the HW fifo data. The read every three writes is due
1438 to an errata on CN3XXX chips */
1441 cvmx_write64_uint32(csr_address, *ptr++);
1442 cvmx_write64_uint32(csr_address, *ptr++);
1443 cvmx_write64_uint32(csr_address, *ptr++);
1444 cvmx_read64_uint64(CVMX_USBNX_DMA0_INB_CHN0(usb->index));
1447 cvmx_write64_uint32(csr_address, *ptr++);
1450 cvmx_write64_uint32(csr_address, *ptr++);
1452 cvmx_write64_uint32(csr_address, *ptr++);
1454 cvmx_read64_uint64(CVMX_USBNX_DMA0_INB_CHN0(usb->index));
1456 CVMX_USB_RETURN(fifo->head != fifo->tail);
1461 * Check the hardware FIFOs and fill them as needed
1463 * @param usb USB device state populated by
1464 * cvmx_usb_initialize().
1466 static void __cvmx_usb_poll_tx_fifo(cvmx_usb_internal_state_t *usb)
1468 CVMX_USB_LOG_CALLED();
1469 CVMX_USB_LOG_PARAM("%p", usb);
1471 if (usb->periodic.head != usb->periodic.tail)
1473 cvmx_usbcx_hptxsts_t tx_status;
1474 tx_status.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HPTXSTS(usb->index));
1475 if (__cvmx_usb_fill_tx_hw(usb, &usb->periodic, tx_status.s.ptxfspcavail))
1476 USB_SET_FIELD32(CVMX_USBCX_GINTMSK(usb->index), cvmx_usbcx_gintmsk_t, ptxfempmsk, 1);
1478 USB_SET_FIELD32(CVMX_USBCX_GINTMSK(usb->index), cvmx_usbcx_gintmsk_t, ptxfempmsk, 0);
1481 if (usb->nonperiodic.head != usb->nonperiodic.tail)
1483 cvmx_usbcx_gnptxsts_t tx_status;
1484 tx_status.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_GNPTXSTS(usb->index));
1485 if (__cvmx_usb_fill_tx_hw(usb, &usb->nonperiodic, tx_status.s.nptxfspcavail))
1486 USB_SET_FIELD32(CVMX_USBCX_GINTMSK(usb->index), cvmx_usbcx_gintmsk_t, nptxfempmsk, 1);
1488 USB_SET_FIELD32(CVMX_USBCX_GINTMSK(usb->index), cvmx_usbcx_gintmsk_t, nptxfempmsk, 0);
1491 CVMX_USB_RETURN_NOTHING();
1497 * Fill the TX FIFO with an outgoing packet
1499 * @param usb USB device state populated by
1500 * cvmx_usb_initialize().
1501 * @param channel Channel number to get packet from
1503 static void __cvmx_usb_fill_tx_fifo(cvmx_usb_internal_state_t *usb, int channel)
1505 cvmx_usbcx_hccharx_t hcchar;
1506 cvmx_usbcx_hcspltx_t usbc_hcsplt;
1507 cvmx_usbcx_hctsizx_t usbc_hctsiz;
1508 cvmx_usb_tx_fifo_t *fifo;
1510 CVMX_USB_LOG_CALLED();
1511 CVMX_USB_LOG_PARAM("%p", usb);
1512 CVMX_USB_LOG_PARAM("%d", channel);
1514 /* We only need to fill data on outbound channels */
1515 hcchar.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HCCHARX(channel, usb->index));
1516 if (hcchar.s.epdir != CVMX_USB_DIRECTION_OUT)
1517 CVMX_USB_RETURN_NOTHING();
1519 /* OUT Splits only have data on the start and not the complete */
1520 usbc_hcsplt.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HCSPLTX(channel, usb->index));
1521 if (usbc_hcsplt.s.spltena && usbc_hcsplt.s.compsplt)
1522 CVMX_USB_RETURN_NOTHING();
1524 /* Find out how many bytes we need to fill and convert it into 32bit words */
1525 usbc_hctsiz.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HCTSIZX(channel, usb->index));
1526 if (!usbc_hctsiz.s.xfersize)
1527 CVMX_USB_RETURN_NOTHING();
1529 if ((hcchar.s.eptype == CVMX_USB_TRANSFER_INTERRUPT) ||
1530 (hcchar.s.eptype == CVMX_USB_TRANSFER_ISOCHRONOUS))
1531 fifo = &usb->periodic;
1533 fifo = &usb->nonperiodic;
1535 fifo->entry[fifo->head].channel = channel;
1536 fifo->entry[fifo->head].address = __cvmx_usb_read_csr64(usb, CVMX_USBNX_DMA0_OUTB_CHN0(usb->index) + channel*8);
1537 fifo->entry[fifo->head].size = (usbc_hctsiz.s.xfersize+3)>>2;
1539 if (fifo->head > MAX_CHANNELS)
1542 __cvmx_usb_poll_tx_fifo(usb);
1544 CVMX_USB_RETURN_NOTHING();
1549 * Perform channel specific setup for Control transactions. All
1550 * the generic stuff will already have been done in
1551 * __cvmx_usb_start_channel()
1553 * @param usb USB device state populated by
1554 * cvmx_usb_initialize().
1555 * @param channel Channel to setup
1556 * @param pipe Pipe for control transaction
1558 static void __cvmx_usb_start_channel_control(cvmx_usb_internal_state_t *usb,
1560 cvmx_usb_pipe_t *pipe)
1562 cvmx_usb_transaction_t *transaction = pipe->head;
1563 cvmx_usb_control_header_t *header = cvmx_phys_to_ptr(transaction->control_header);
1564 int bytes_to_transfer = transaction->buffer_length - transaction->actual_bytes;
1565 int packets_to_transfer;
1566 cvmx_usbcx_hctsizx_t usbc_hctsiz;
1568 CVMX_USB_LOG_CALLED();
1569 CVMX_USB_LOG_PARAM("%p", usb);
1570 CVMX_USB_LOG_PARAM("%d", channel);
1571 CVMX_USB_LOG_PARAM("%p", pipe);
1573 usbc_hctsiz.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HCTSIZX(channel, usb->index));
1575 switch (transaction->stage)
1577 case CVMX_USB_STAGE_NON_CONTROL:
1578 case CVMX_USB_STAGE_NON_CONTROL_SPLIT_COMPLETE:
1579 cvmx_dprintf("%s: ERROR - Non control stage\n", __FUNCTION__);
1581 case CVMX_USB_STAGE_SETUP:
1582 usbc_hctsiz.s.pid = 3; /* Setup */
1583 bytes_to_transfer = sizeof(*header);
1584 /* All Control operations start with a setup going OUT */
1585 USB_SET_FIELD32(CVMX_USBCX_HCCHARX(channel, usb->index), cvmx_usbcx_hccharx_t, epdir, CVMX_USB_DIRECTION_OUT);
1586 /* Setup send the control header instead of the buffer data. The
1587 buffer data will be used in the next stage */
1588 __cvmx_usb_write_csr64(usb, CVMX_USBNX_DMA0_OUTB_CHN0(usb->index) + channel*8, transaction->control_header);
1590 case CVMX_USB_STAGE_SETUP_SPLIT_COMPLETE:
1591 usbc_hctsiz.s.pid = 3; /* Setup */
1592 bytes_to_transfer = 0;
1593 /* All Control operations start with a setup going OUT */
1594 USB_SET_FIELD32(CVMX_USBCX_HCCHARX(channel, usb->index), cvmx_usbcx_hccharx_t, epdir, CVMX_USB_DIRECTION_OUT);
1595 USB_SET_FIELD32(CVMX_USBCX_HCSPLTX(channel, usb->index), cvmx_usbcx_hcspltx_t, compsplt, 1);
1597 case CVMX_USB_STAGE_DATA:
1598 usbc_hctsiz.s.pid = __cvmx_usb_get_data_pid(pipe);
1599 if (__cvmx_usb_pipe_needs_split(usb, pipe))
1601 if (header->s.request_type & 0x80)
1602 bytes_to_transfer = 0;
1603 else if (bytes_to_transfer > pipe->max_packet)
1604 bytes_to_transfer = pipe->max_packet;
1606 USB_SET_FIELD32(CVMX_USBCX_HCCHARX(channel, usb->index),
1607 cvmx_usbcx_hccharx_t, epdir,
1608 ((header->s.request_type & 0x80) ?
1609 CVMX_USB_DIRECTION_IN :
1610 CVMX_USB_DIRECTION_OUT));
1612 case CVMX_USB_STAGE_DATA_SPLIT_COMPLETE:
1613 usbc_hctsiz.s.pid = __cvmx_usb_get_data_pid(pipe);
1614 if (!(header->s.request_type & 0x80))
1615 bytes_to_transfer = 0;
1616 USB_SET_FIELD32(CVMX_USBCX_HCCHARX(channel, usb->index),
1617 cvmx_usbcx_hccharx_t, epdir,
1618 ((header->s.request_type & 0x80) ?
1619 CVMX_USB_DIRECTION_IN :
1620 CVMX_USB_DIRECTION_OUT));
1621 USB_SET_FIELD32(CVMX_USBCX_HCSPLTX(channel, usb->index), cvmx_usbcx_hcspltx_t, compsplt, 1);
1623 case CVMX_USB_STAGE_STATUS:
1624 usbc_hctsiz.s.pid = __cvmx_usb_get_data_pid(pipe);
1625 bytes_to_transfer = 0;
1626 USB_SET_FIELD32(CVMX_USBCX_HCCHARX(channel, usb->index), cvmx_usbcx_hccharx_t, epdir,
1627 ((header->s.request_type & 0x80) ?
1628 CVMX_USB_DIRECTION_OUT :
1629 CVMX_USB_DIRECTION_IN));
1631 case CVMX_USB_STAGE_STATUS_SPLIT_COMPLETE:
1632 usbc_hctsiz.s.pid = __cvmx_usb_get_data_pid(pipe);
1633 bytes_to_transfer = 0;
1634 USB_SET_FIELD32(CVMX_USBCX_HCCHARX(channel, usb->index), cvmx_usbcx_hccharx_t, epdir,
1635 ((header->s.request_type & 0x80) ?
1636 CVMX_USB_DIRECTION_OUT :
1637 CVMX_USB_DIRECTION_IN));
1638 USB_SET_FIELD32(CVMX_USBCX_HCSPLTX(channel, usb->index), cvmx_usbcx_hcspltx_t, compsplt, 1);
1642 /* Make sure the transfer never exceeds the byte limit of the hardware.
1643 Further bytes will be sent as continued transactions */
1644 if (bytes_to_transfer > MAX_TRANSFER_BYTES)
1646 /* Round MAX_TRANSFER_BYTES to a multiple of out packet size */
1647 bytes_to_transfer = MAX_TRANSFER_BYTES / pipe->max_packet;
1648 bytes_to_transfer *= pipe->max_packet;
1651 /* Calculate the number of packets to transfer. If the length is zero
1652 we still need to transfer one packet */
1653 packets_to_transfer = (bytes_to_transfer + pipe->max_packet - 1) / pipe->max_packet;
1654 if (packets_to_transfer == 0)
1655 packets_to_transfer = 1;
1656 else if ((packets_to_transfer>1) && (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_NO_DMA))
1658 /* Limit to one packet when not using DMA. Channels must be restarted
1659 between every packet for IN transactions, so there is no reason to
1660 do multiple packets in a row */
1661 packets_to_transfer = 1;
1662 bytes_to_transfer = packets_to_transfer * pipe->max_packet;
1664 else if (packets_to_transfer > MAX_TRANSFER_PACKETS)
1666 /* Limit the number of packet and data transferred to what the
1667 hardware can handle */
1668 packets_to_transfer = MAX_TRANSFER_PACKETS;
1669 bytes_to_transfer = packets_to_transfer * pipe->max_packet;
1672 usbc_hctsiz.s.xfersize = bytes_to_transfer;
1673 usbc_hctsiz.s.pktcnt = packets_to_transfer;
1675 __cvmx_usb_write_csr32(usb, CVMX_USBCX_HCTSIZX(channel, usb->index), usbc_hctsiz.u32);
1676 CVMX_USB_RETURN_NOTHING();
1682 * Start a channel to perform the pipe's head transaction
1684 * @param usb USB device state populated by
1685 * cvmx_usb_initialize().
1686 * @param channel Channel to setup
1687 * @param pipe Pipe to start
1689 static void __cvmx_usb_start_channel(cvmx_usb_internal_state_t *usb,
1691 cvmx_usb_pipe_t *pipe)
1693 cvmx_usb_transaction_t *transaction = pipe->head;
1695 CVMX_USB_LOG_CALLED();
1696 CVMX_USB_LOG_PARAM("%p", usb);
1697 CVMX_USB_LOG_PARAM("%d", channel);
1698 CVMX_USB_LOG_PARAM("%p", pipe);
1700 if (cvmx_unlikely((usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_TRANSFERS) ||
1701 (pipe->flags & CVMX_USB_PIPE_FLAGS_DEBUG_TRANSFERS)))
1702 cvmx_dprintf("%s: Channel %d started. Pipe %d transaction %d stage %d\n",
1703 __FUNCTION__, channel, __cvmx_usb_get_pipe_handle(usb, pipe),
1704 __cvmx_usb_get_submit_handle(usb, transaction),
1705 transaction->stage);
1707 /* Make sure all writes to the DMA region get flushed */
1710 /* Attach the channel to the pipe */
1711 usb->pipe_for_channel[channel] = pipe;
1712 pipe->channel = channel;
1713 pipe->flags |= __CVMX_USB_PIPE_FLAGS_SCHEDULED;
1715 /* Mark this channel as in use */
1716 usb->idle_hardware_channels &= ~(1<<channel);
1718 /* Enable the channel interrupt bits */
1720 cvmx_usbcx_hcintx_t usbc_hcint;
1721 cvmx_usbcx_hcintmskx_t usbc_hcintmsk;
1722 cvmx_usbcx_haintmsk_t usbc_haintmsk;
1724 /* Clear all channel status bits */
1725 usbc_hcint.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HCINTX(channel, usb->index));
1726 __cvmx_usb_write_csr32(usb, CVMX_USBCX_HCINTX(channel, usb->index), usbc_hcint.u32);
1728 usbc_hcintmsk.u32 = 0;
1729 usbc_hcintmsk.s.chhltdmsk = 1;
1730 if (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_NO_DMA)
1732 /* Channels need these extra interrupts when we aren't in DMA mode */
1733 usbc_hcintmsk.s.datatglerrmsk = 1;
1734 usbc_hcintmsk.s.frmovrunmsk = 1;
1735 usbc_hcintmsk.s.bblerrmsk = 1;
1736 usbc_hcintmsk.s.xacterrmsk = 1;
1737 if (__cvmx_usb_pipe_needs_split(usb, pipe))
1739 /* Splits don't generate xfercompl, so we need ACK and NYET */
1740 usbc_hcintmsk.s.nyetmsk = 1;
1741 usbc_hcintmsk.s.ackmsk = 1;
1743 usbc_hcintmsk.s.nakmsk = 1;
1744 usbc_hcintmsk.s.stallmsk = 1;
1745 usbc_hcintmsk.s.xfercomplmsk = 1;
1747 __cvmx_usb_write_csr32(usb, CVMX_USBCX_HCINTMSKX(channel, usb->index), usbc_hcintmsk.u32);
1749 /* Enable the channel interrupt to propagate */
1750 usbc_haintmsk.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HAINTMSK(usb->index));
1751 usbc_haintmsk.s.haintmsk |= 1<<channel;
1752 __cvmx_usb_write_csr32(usb, CVMX_USBCX_HAINTMSK(usb->index), usbc_haintmsk.u32);
1755 /* Setup the locations the DMA engines use */
1757 uint64_t dma_address = transaction->buffer + transaction->actual_bytes;
1758 if (transaction->type == CVMX_USB_TRANSFER_ISOCHRONOUS)
1759 dma_address = transaction->buffer + transaction->iso_packets[0].offset + transaction->actual_bytes;
1760 __cvmx_usb_write_csr64(usb, CVMX_USBNX_DMA0_OUTB_CHN0(usb->index) + channel*8, dma_address);
1761 __cvmx_usb_write_csr64(usb, CVMX_USBNX_DMA0_INB_CHN0(usb->index) + channel*8, dma_address);
1764 /* Setup both the size of the transfer and the SPLIT characteristics */
1766 cvmx_usbcx_hcspltx_t usbc_hcsplt = {.u32 = 0};
1767 cvmx_usbcx_hctsizx_t usbc_hctsiz = {.u32 = 0};
1768 int packets_to_transfer;
1769 int bytes_to_transfer = transaction->buffer_length - transaction->actual_bytes;
1771 /* ISOCHRONOUS transactions store each individual transfer size in the
1772 packet structure, not the global buffer_length */
1773 if (transaction->type == CVMX_USB_TRANSFER_ISOCHRONOUS)
1774 bytes_to_transfer = transaction->iso_packets[0].length - transaction->actual_bytes;
1776 /* We need to do split transactions when we are talking to non high
1777 speed devices that are behind a high speed hub */
1778 if (__cvmx_usb_pipe_needs_split(usb, pipe))
1780 /* On the start split phase (stage is even) record the frame number we
1781 will need to send the split complete. We only store the lower two bits
1782 since the time ahead can only be two frames */
1783 if ((transaction->stage&1) == 0)
1785 if (transaction->type == CVMX_USB_TRANSFER_BULK)
1786 pipe->split_sc_frame = (usb->frame_number + 1) & 0x7f;
1788 pipe->split_sc_frame = (usb->frame_number + 2) & 0x7f;
1791 pipe->split_sc_frame = -1;
1793 usbc_hcsplt.s.spltena = 1;
1794 usbc_hcsplt.s.hubaddr = pipe->hub_device_addr;
1795 usbc_hcsplt.s.prtaddr = pipe->hub_port;
1796 usbc_hcsplt.s.compsplt = (transaction->stage == CVMX_USB_STAGE_NON_CONTROL_SPLIT_COMPLETE);
1798 /* SPLIT transactions can only ever transmit one data packet so
1799 limit the transfer size to the max packet size */
1800 if (bytes_to_transfer > pipe->max_packet)
1801 bytes_to_transfer = pipe->max_packet;
1803 /* ISOCHRONOUS OUT splits are unique in that they limit
1804 data transfers to 188 byte chunks representing the
1805 begin/middle/end of the data or all */
1806 if (!usbc_hcsplt.s.compsplt &&
1807 (pipe->transfer_dir == CVMX_USB_DIRECTION_OUT) &&
1808 (pipe->transfer_type == CVMX_USB_TRANSFER_ISOCHRONOUS))
1810 /* Clear the split complete frame number as there isn't going
1811 to be a split complete */
1812 pipe->split_sc_frame = -1;
1813 /* See if we've started this transfer and sent data */
1814 if (transaction->actual_bytes == 0)
1816 /* Nothing sent yet, this is either a begin or the
1818 if (bytes_to_transfer <= 188)
1819 usbc_hcsplt.s.xactpos = 3; /* Entire payload in one go */
1821 usbc_hcsplt.s.xactpos = 2; /* First part of payload */
1825 /* Continuing the previous data, we must either be
1826 in the middle or at the end */
1827 if (bytes_to_transfer <= 188)
1828 usbc_hcsplt.s.xactpos = 1; /* End of payload */
1830 usbc_hcsplt.s.xactpos = 0; /* Middle of payload */
1832 /* Again, the transfer size is limited to 188 bytes */
1833 if (bytes_to_transfer > 188)
1834 bytes_to_transfer = 188;
1838 /* Make sure the transfer never exceeds the byte limit of the hardware.
1839 Further bytes will be sent as continued transactions */
1840 if (bytes_to_transfer > MAX_TRANSFER_BYTES)
1842 /* Round MAX_TRANSFER_BYTES to a multiple of out packet size */
1843 bytes_to_transfer = MAX_TRANSFER_BYTES / pipe->max_packet;
1844 bytes_to_transfer *= pipe->max_packet;
1847 /* Calculate the number of packets to transfer. If the length is zero
1848 we still need to transfer one packet */
1849 packets_to_transfer = (bytes_to_transfer + pipe->max_packet - 1) / pipe->max_packet;
1850 if (packets_to_transfer == 0)
1851 packets_to_transfer = 1;
1852 else if ((packets_to_transfer>1) && (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_NO_DMA))
1854 /* Limit to one packet when not using DMA. Channels must be restarted
1855 between every packet for IN transactions, so there is no reason to
1856 do multiple packets in a row */
1857 packets_to_transfer = 1;
1858 bytes_to_transfer = packets_to_transfer * pipe->max_packet;
1860 else if (packets_to_transfer > MAX_TRANSFER_PACKETS)
1862 /* Limit the number of packet and data transferred to what the
1863 hardware can handle */
1864 packets_to_transfer = MAX_TRANSFER_PACKETS;
1865 bytes_to_transfer = packets_to_transfer * pipe->max_packet;
1868 usbc_hctsiz.s.xfersize = bytes_to_transfer;
1869 usbc_hctsiz.s.pktcnt = packets_to_transfer;
1871 /* Update the DATA0/DATA1 toggle */
1872 usbc_hctsiz.s.pid = __cvmx_usb_get_data_pid(pipe);
1873 /* High speed pipes may need a hardware ping before they start */
1874 if (pipe->flags & __CVMX_USB_PIPE_FLAGS_NEED_PING)
1875 usbc_hctsiz.s.dopng = 1;
1877 __cvmx_usb_write_csr32(usb, CVMX_USBCX_HCSPLTX(channel, usb->index), usbc_hcsplt.u32);
1878 __cvmx_usb_write_csr32(usb, CVMX_USBCX_HCTSIZX(channel, usb->index), usbc_hctsiz.u32);
1881 /* Setup the Host Channel Characteristics Register */
1883 cvmx_usbcx_hccharx_t usbc_hcchar = {.u32 = 0};
1885 /* Set the startframe odd/even properly. This is only used for periodic */
1886 usbc_hcchar.s.oddfrm = usb->frame_number&1;
1888 /* Set the number of back to back packets allowed by this endpoint.
1889 Split transactions interpret "ec" as the number of immediate
1890 retries of failure. These retries happen too quickly, so we
1891 disable these entirely for splits */
1892 if (__cvmx_usb_pipe_needs_split(usb, pipe))
1893 usbc_hcchar.s.ec = 1;
1894 else if (pipe->multi_count < 1)
1895 usbc_hcchar.s.ec = 1;
1896 else if (pipe->multi_count > 3)
1897 usbc_hcchar.s.ec = 3;
1899 usbc_hcchar.s.ec = pipe->multi_count;
1901 /* Set the rest of the endpoint specific settings */
1902 usbc_hcchar.s.devaddr = pipe->device_addr;
1903 usbc_hcchar.s.eptype = transaction->type;
1904 usbc_hcchar.s.lspddev = (pipe->device_speed == CVMX_USB_SPEED_LOW);
1905 usbc_hcchar.s.epdir = pipe->transfer_dir;
1906 usbc_hcchar.s.epnum = pipe->endpoint_num;
1907 usbc_hcchar.s.mps = pipe->max_packet;
1908 __cvmx_usb_write_csr32(usb, CVMX_USBCX_HCCHARX(channel, usb->index), usbc_hcchar.u32);
1911 /* Do transaction type specific fixups as needed */
1912 switch (transaction->type)
1914 case CVMX_USB_TRANSFER_CONTROL:
1915 __cvmx_usb_start_channel_control(usb, channel, pipe);
1917 case CVMX_USB_TRANSFER_BULK:
1918 case CVMX_USB_TRANSFER_INTERRUPT:
1920 case CVMX_USB_TRANSFER_ISOCHRONOUS:
1921 if (!__cvmx_usb_pipe_needs_split(usb, pipe))
1923 /* ISO transactions require different PIDs depending on direction
1924 and how many packets are needed */
1925 if (pipe->transfer_dir == CVMX_USB_DIRECTION_OUT)
1927 if (pipe->multi_count < 2) /* Need DATA0 */
1928 USB_SET_FIELD32(CVMX_USBCX_HCTSIZX(channel, usb->index), cvmx_usbcx_hctsizx_t, pid, 0);
1929 else /* Need MDATA */
1930 USB_SET_FIELD32(CVMX_USBCX_HCTSIZX(channel, usb->index), cvmx_usbcx_hctsizx_t, pid, 3);
1936 cvmx_usbcx_hctsizx_t usbc_hctsiz = {.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HCTSIZX(channel, usb->index))};
1937 transaction->xfersize = usbc_hctsiz.s.xfersize;
1938 transaction->pktcnt = usbc_hctsiz.s.pktcnt;
1940 /* Remeber when we start a split transaction */
1941 if (__cvmx_usb_pipe_needs_split(usb, pipe))
1942 usb->active_split = transaction;
1943 USB_SET_FIELD32(CVMX_USBCX_HCCHARX(channel, usb->index), cvmx_usbcx_hccharx_t, chena, 1);
1944 if (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_NO_DMA)
1945 __cvmx_usb_fill_tx_fifo(usb, channel);
1946 CVMX_USB_RETURN_NOTHING();
1952 * Find a pipe that is ready to be scheduled to hardware.
1953 * @param usb USB device state populated by
1954 * cvmx_usb_initialize().
1955 * @param list Pipe list to search
1956 * @param current_frame
1957 * Frame counter to use as a time reference.
1959 * @return Pipe or NULL if none are ready
1961 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)
1963 cvmx_usb_pipe_t *pipe = list->head;
1966 if (!(pipe->flags & __CVMX_USB_PIPE_FLAGS_SCHEDULED) && pipe->head &&
1967 (pipe->next_tx_frame <= current_frame) &&
1968 ((pipe->split_sc_frame == -1) || ((((int)current_frame - (int)pipe->split_sc_frame) & 0x7f) < 0x40)) &&
1969 (!usb->active_split || (usb->active_split == pipe->head)))
1971 CVMX_PREFETCH(pipe, 128);
1972 CVMX_PREFETCH(pipe->head, 0);
1983 * Called whenever a pipe might need to be scheduled to the
1986 * @param usb USB device state populated by
1987 * cvmx_usb_initialize().
1988 * @param is_sof True if this schedule was called on a SOF interrupt.
1990 static void __cvmx_usb_schedule(cvmx_usb_internal_state_t *usb, int is_sof)
1993 cvmx_usb_pipe_t *pipe;
1995 cvmx_usb_transfer_t ttype;
1997 CVMX_USB_LOG_CALLED();
1998 CVMX_USB_LOG_PARAM("%p", usb);
2000 if (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_NO_DMA)
2002 /* Without DMA we need to be careful to not schedule something at the end of a frame and cause an overrun */
2003 cvmx_usbcx_hfnum_t hfnum = {.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HFNUM(usb->index))};
2004 cvmx_usbcx_hfir_t hfir = {.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HFIR(usb->index))};
2005 if (hfnum.s.frrem < hfir.s.frint/4)
2009 while (usb->idle_hardware_channels)
2011 /* Find an idle channel */
2012 CVMX_CLZ(channel, usb->idle_hardware_channels);
2013 channel = 31 - channel;
2014 if (cvmx_unlikely(channel > 7))
2016 if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_INFO))
2017 cvmx_dprintf("%s: Idle hardware channels has a channel higher than 7. This is wrong\n", __FUNCTION__);
2021 /* Find a pipe needing service */
2025 /* Only process periodic pipes on SOF interrupts. This way we are
2026 sure that the periodic data is sent in the beginning of the
2028 pipe = __cvmx_usb_find_ready_pipe(usb, usb->active_pipes + CVMX_USB_TRANSFER_ISOCHRONOUS, usb->frame_number);
2029 if (cvmx_likely(!pipe))
2030 pipe = __cvmx_usb_find_ready_pipe(usb, usb->active_pipes + CVMX_USB_TRANSFER_INTERRUPT, usb->frame_number);
2032 if (cvmx_likely(!pipe))
2034 pipe = __cvmx_usb_find_ready_pipe(usb, usb->active_pipes + CVMX_USB_TRANSFER_CONTROL, usb->frame_number);
2035 if (cvmx_likely(!pipe))
2036 pipe = __cvmx_usb_find_ready_pipe(usb, usb->active_pipes + CVMX_USB_TRANSFER_BULK, usb->frame_number);
2041 CVMX_USB_LOG_PARAM("%d", channel);
2042 CVMX_USB_LOG_PARAM("%p", pipe);
2044 if (cvmx_unlikely((usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_TRANSFERS) ||
2045 (pipe->flags & CVMX_USB_PIPE_FLAGS_DEBUG_TRANSFERS)))
2047 cvmx_usb_transaction_t *transaction = pipe->head;
2048 const cvmx_usb_control_header_t *header = (transaction->control_header) ? cvmx_phys_to_ptr(transaction->control_header) : NULL;
2049 const char *dir = (pipe->transfer_dir == CVMX_USB_DIRECTION_IN) ? "IN" : "OUT";
2051 switch (pipe->transfer_type)
2053 case CVMX_USB_TRANSFER_CONTROL:
2055 dir = (header->s.request_type & 0x80) ? "IN" : "OUT";
2057 case CVMX_USB_TRANSFER_ISOCHRONOUS:
2058 type = "ISOCHRONOUS";
2060 case CVMX_USB_TRANSFER_BULK:
2063 default: /* CVMX_USB_TRANSFER_INTERRUPT */
2067 cvmx_dprintf("%s: Starting pipe %d, transaction %d on channel %d. %s %s len=%d header=0x%llx\n",
2068 __FUNCTION__, __cvmx_usb_get_pipe_handle(usb, pipe),
2069 __cvmx_usb_get_submit_handle(usb, transaction),
2071 transaction->buffer_length,
2072 (header) ? (unsigned long long)header->u64 : 0ull);
2074 __cvmx_usb_start_channel(usb, channel, pipe);
2078 /* Only enable SOF interrupts when we have transactions pending in the
2079 future that might need to be scheduled */
2081 for (ttype=CVMX_USB_TRANSFER_CONTROL; ttype<=CVMX_USB_TRANSFER_INTERRUPT; ttype++)
2083 pipe = usb->active_pipes[ttype].head;
2086 if (pipe->next_tx_frame > usb->frame_number)
2094 USB_SET_FIELD32(CVMX_USBCX_GINTMSK(usb->index), cvmx_usbcx_gintmsk_t, sofmsk, need_sof);
2095 CVMX_USB_RETURN_NOTHING();
2101 * Call a user's callback for a specific reason.
2103 * @param usb USB device state populated by
2104 * cvmx_usb_initialize().
2105 * @param pipe Pipe the callback is for or NULL
2106 * @param transaction
2107 * Transaction the callback is for or NULL
2108 * @param reason Reason this callback is being called
2109 * @param complete_code
2110 * Completion code for the transaction, if any
2112 static void __cvmx_usb_perform_callback(cvmx_usb_internal_state_t *usb,
2113 cvmx_usb_pipe_t *pipe,
2114 cvmx_usb_transaction_t *transaction,
2115 cvmx_usb_callback_t reason,
2116 cvmx_usb_complete_t complete_code)
2118 cvmx_usb_callback_func_t callback = usb->callback[reason];
2119 void *user_data = usb->callback_data[reason];
2120 int submit_handle = -1;
2121 int pipe_handle = -1;
2122 int bytes_transferred = 0;
2125 pipe_handle = __cvmx_usb_get_pipe_handle(usb, pipe);
2129 submit_handle = __cvmx_usb_get_submit_handle(usb, transaction);
2130 bytes_transferred = transaction->actual_bytes;
2131 /* Transactions are allowed to override the default callback */
2132 if ((reason == CVMX_USB_CALLBACK_TRANSFER_COMPLETE) && transaction->callback)
2134 callback = transaction->callback;
2135 user_data = transaction->callback_data;
2142 if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_CALLBACKS))
2143 cvmx_dprintf("%*s%s: calling callback %p(usb=%p, complete_code=%s, "
2144 "pipe_handle=%d, submit_handle=%d, bytes_transferred=%d, user_data=%p);\n",
2145 2*usb->indent, "", __FUNCTION__, callback, usb,
2146 __cvmx_usb_complete_to_string(complete_code),
2147 pipe_handle, submit_handle, bytes_transferred, user_data);
2149 callback((cvmx_usb_state_t *)usb, reason, complete_code, pipe_handle, submit_handle,
2150 bytes_transferred, user_data);
2152 if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_CALLBACKS))
2153 cvmx_dprintf("%*s%s: callback %p complete\n", 2*usb->indent, "",
2154 __FUNCTION__, callback);
2160 * Signal the completion of a transaction and free it. The
2161 * transaction will be removed from the pipe transaction list.
2163 * @param usb USB device state populated by
2164 * cvmx_usb_initialize().
2165 * @param pipe Pipe the transaction is on
2166 * @param transaction
2167 * Transaction that completed
2168 * @param complete_code
2171 static void __cvmx_usb_perform_complete(cvmx_usb_internal_state_t * usb,
2172 cvmx_usb_pipe_t *pipe,
2173 cvmx_usb_transaction_t *transaction,
2174 cvmx_usb_complete_t complete_code)
2176 CVMX_USB_LOG_CALLED();
2177 CVMX_USB_LOG_PARAM("%p", usb);
2178 CVMX_USB_LOG_PARAM("%p", pipe);
2179 CVMX_USB_LOG_PARAM("%p", transaction);
2180 CVMX_USB_LOG_PARAM("%d", complete_code);
2182 /* If this was a split then clear our split in progress marker */
2183 if (usb->active_split == transaction)
2184 usb->active_split = NULL;
2186 /* Isochronous transactions need extra processing as they might not be done
2187 after a single data transfer */
2188 if (cvmx_unlikely(transaction->type == CVMX_USB_TRANSFER_ISOCHRONOUS))
2190 /* Update the number of bytes transferred in this ISO packet */
2191 transaction->iso_packets[0].length = transaction->actual_bytes;
2192 transaction->iso_packets[0].status = complete_code;
2194 /* If there are more ISOs pending and we succeeded, schedule the next
2196 if ((transaction->iso_number_packets > 1) && (complete_code == CVMX_USB_COMPLETE_SUCCESS))
2198 transaction->actual_bytes = 0; /* No bytes transferred for this packet as of yet */
2199 transaction->iso_number_packets--; /* One less ISO waiting to transfer */
2200 transaction->iso_packets++; /* Increment to the next location in our packet array */
2201 transaction->stage = CVMX_USB_STAGE_NON_CONTROL;
2206 /* Remove the transaction from the pipe list */
2207 if (transaction->next)
2208 transaction->next->prev = transaction->prev;
2210 pipe->tail = transaction->prev;
2211 if (transaction->prev)
2212 transaction->prev->next = transaction->next;
2214 pipe->head = transaction->next;
2217 __cvmx_usb_remove_pipe(usb->active_pipes + pipe->transfer_type, pipe);
2218 __cvmx_usb_append_pipe(&usb->idle_pipes, pipe);
2221 __cvmx_usb_perform_callback(usb, pipe, transaction,
2222 CVMX_USB_CALLBACK_TRANSFER_COMPLETE,
2224 __cvmx_usb_free_transaction(usb, transaction);
2226 CVMX_USB_RETURN_NOTHING();
2232 * Submit a usb transaction to a pipe. Called for all types
2236 * @param pipe_handle
2237 * Which pipe to submit to. Will be validated in this function.
2238 * @param type Transaction type
2239 * @param flags Flags for the transaction
2240 * @param buffer User buffer for the transaction
2241 * @param buffer_length
2242 * User buffer's length in bytes
2243 * @param control_header
2244 * For control transactions, the 8 byte standard header
2245 * @param iso_start_frame
2246 * For ISO transactions, the start frame
2247 * @param iso_number_packets
2248 * For ISO, the number of packet in the transaction.
2249 * @param iso_packets
2250 * A description of each ISO packet
2251 * @param callback User callback to call when the transaction completes
2252 * @param user_data User's data for the callback
2254 * @return Submit handle or negative on failure. Matches the result
2255 * in the external API.
2257 static int __cvmx_usb_submit_transaction(cvmx_usb_internal_state_t *usb,
2259 cvmx_usb_transfer_t type,
2263 uint64_t control_header,
2264 int iso_start_frame,
2265 int iso_number_packets,
2266 cvmx_usb_iso_packet_t *iso_packets,
2267 cvmx_usb_callback_func_t callback,
2271 cvmx_usb_transaction_t *transaction;
2272 cvmx_usb_pipe_t *pipe = usb->pipe + pipe_handle;
2274 CVMX_USB_LOG_CALLED();
2275 if (cvmx_unlikely((pipe_handle < 0) || (pipe_handle >= MAX_PIPES)))
2276 CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2277 /* Fail if the pipe isn't open */
2278 if (cvmx_unlikely((pipe->flags & __CVMX_USB_PIPE_FLAGS_OPEN) == 0))
2279 CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2280 if (cvmx_unlikely(pipe->transfer_type != type))
2281 CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2283 transaction = __cvmx_usb_alloc_transaction(usb);
2284 if (cvmx_unlikely(!transaction))
2285 CVMX_USB_RETURN(CVMX_USB_NO_MEMORY);
2287 transaction->type = type;
2288 transaction->flags |= flags;
2289 transaction->buffer = buffer;
2290 transaction->buffer_length = buffer_length;
2291 transaction->control_header = control_header;
2292 transaction->iso_start_frame = iso_start_frame; // FIXME: This is not used, implement it
2293 transaction->iso_number_packets = iso_number_packets;
2294 transaction->iso_packets = iso_packets;
2295 transaction->callback = callback;
2296 transaction->callback_data = user_data;
2297 if (transaction->type == CVMX_USB_TRANSFER_CONTROL)
2298 transaction->stage = CVMX_USB_STAGE_SETUP;
2300 transaction->stage = CVMX_USB_STAGE_NON_CONTROL;
2302 transaction->next = NULL;
2305 transaction->prev = pipe->tail;
2306 transaction->prev->next = transaction;
2310 if (pipe->next_tx_frame < usb->frame_number)
2311 pipe->next_tx_frame = usb->frame_number + pipe->interval -
2312 (usb->frame_number - pipe->next_tx_frame) % pipe->interval;
2313 transaction->prev = NULL;
2314 pipe->head = transaction;
2315 __cvmx_usb_remove_pipe(&usb->idle_pipes, pipe);
2316 __cvmx_usb_append_pipe(usb->active_pipes + pipe->transfer_type, pipe);
2318 pipe->tail = transaction;
2320 submit_handle = __cvmx_usb_get_submit_handle(usb, transaction);
2322 /* We may need to schedule the pipe if this was the head of the pipe */
2323 if (!transaction->prev)
2324 __cvmx_usb_schedule(usb, 0);
2326 CVMX_USB_RETURN(submit_handle);
2331 * Call to submit a USB Bulk transfer to a pipe.
2333 * @param state USB device state populated by
2334 * cvmx_usb_initialize().
2335 * @param pipe_handle
2336 * Handle to the pipe for the transfer.
2337 * @param buffer Physical address of the data buffer in
2338 * memory. Note that this is NOT A POINTER, but
2339 * the full 64bit physical address of the
2340 * buffer. This may be zero if buffer_length is
2342 * @param buffer_length
2343 * Length of buffer in bytes.
2344 * @param callback Function to call when this transaction
2345 * completes. If the return value of this
2346 * function isn't an error, then this function
2347 * is guaranteed to be called when the
2348 * transaction completes. If this parameter is
2349 * NULL, then the generic callback registered
2350 * through cvmx_usb_register_callback is
2351 * called. If both are NULL, then there is no
2352 * way to know when a transaction completes.
2353 * @param user_data User supplied data returned when the
2354 * callback is called. This is only used if
2355 * callback in not NULL.
2357 * @return A submitted transaction handle or negative on
2358 * failure. Negative values are failure codes from
2359 * cvmx_usb_status_t.
2361 int cvmx_usb_submit_bulk(cvmx_usb_state_t *state, int pipe_handle,
2362 uint64_t buffer, int buffer_length,
2363 cvmx_usb_callback_func_t callback,
2367 cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
2369 CVMX_USB_LOG_CALLED();
2370 CVMX_USB_LOG_PARAM("%p", state);
2371 CVMX_USB_LOG_PARAM("%d", pipe_handle);
2372 CVMX_USB_LOG_PARAM("0x%llx", (unsigned long long)buffer);
2373 CVMX_USB_LOG_PARAM("%d", buffer_length);
2375 /* Pipe handle checking is done later in a common place */
2376 if (cvmx_unlikely(!buffer))
2377 CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2378 if (cvmx_unlikely(buffer_length < 0))
2379 CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2381 submit_handle = __cvmx_usb_submit_transaction(usb, pipe_handle,
2382 CVMX_USB_TRANSFER_BULK,
2386 0, /* control_header */
2387 0, /* iso_start_frame */
2388 0, /* iso_number_packets */
2389 NULL, /* iso_packets */
2392 CVMX_USB_RETURN(submit_handle);
2394 #ifdef CVMX_BUILD_FOR_LINUX_KERNEL
2395 EXPORT_SYMBOL(cvmx_usb_submit_bulk);
2400 * Call to submit a USB Interrupt transfer to a pipe.
2402 * @param state USB device state populated by
2403 * cvmx_usb_initialize().
2404 * @param pipe_handle
2405 * Handle to the pipe for the transfer.
2406 * @param buffer Physical address of the data buffer in
2407 * memory. Note that this is NOT A POINTER, but
2408 * the full 64bit physical address of the
2409 * buffer. This may be zero if buffer_length is
2411 * @param buffer_length
2412 * Length of buffer in bytes.
2413 * @param callback Function to call when this transaction
2414 * completes. If the return value of this
2415 * function isn't an error, then this function
2416 * is guaranteed to be called when the
2417 * transaction completes. If this parameter is
2418 * NULL, then the generic callback registered
2419 * through cvmx_usb_register_callback is
2420 * called. If both are NULL, then there is no
2421 * way to know when a transaction completes.
2422 * @param user_data User supplied data returned when the
2423 * callback is called. This is only used if
2424 * callback in not NULL.
2426 * @return A submitted transaction handle or negative on
2427 * failure. Negative values are failure codes from
2428 * cvmx_usb_status_t.
2430 int cvmx_usb_submit_interrupt(cvmx_usb_state_t *state, int pipe_handle,
2431 uint64_t buffer, int buffer_length,
2432 cvmx_usb_callback_func_t callback,
2436 cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
2438 CVMX_USB_LOG_CALLED();
2439 CVMX_USB_LOG_PARAM("%p", state);
2440 CVMX_USB_LOG_PARAM("%d", pipe_handle);
2441 CVMX_USB_LOG_PARAM("0x%llx", (unsigned long long)buffer);
2442 CVMX_USB_LOG_PARAM("%d", buffer_length);
2444 /* Pipe handle checking is done later in a common place */
2445 if (cvmx_unlikely(!buffer))
2446 CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2447 if (cvmx_unlikely(buffer_length < 0))
2448 CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2450 submit_handle = __cvmx_usb_submit_transaction(usb, pipe_handle,
2451 CVMX_USB_TRANSFER_INTERRUPT,
2455 0, /* control_header */
2456 0, /* iso_start_frame */
2457 0, /* iso_number_packets */
2458 NULL, /* iso_packets */
2461 CVMX_USB_RETURN(submit_handle);
2463 #ifdef CVMX_BUILD_FOR_LINUX_KERNEL
2464 EXPORT_SYMBOL(cvmx_usb_submit_interrupt);
2469 * Call to submit a USB Control transfer to a pipe.
2471 * @param state USB device state populated by
2472 * cvmx_usb_initialize().
2473 * @param pipe_handle
2474 * Handle to the pipe for the transfer.
2475 * @param control_header
2476 * USB 8 byte control header physical address.
2477 * Note that this is NOT A POINTER, but the
2478 * full 64bit physical address of the buffer.
2479 * @param buffer Physical address of the data buffer in
2480 * memory. Note that this is NOT A POINTER, but
2481 * the full 64bit physical address of the
2482 * buffer. This may be zero if buffer_length is
2484 * @param buffer_length
2485 * Length of buffer in bytes.
2486 * @param callback Function to call when this transaction
2487 * completes. If the return value of this
2488 * function isn't an error, then this function
2489 * is guaranteed to be called when the
2490 * transaction completes. If this parameter is
2491 * NULL, then the generic callback registered
2492 * through cvmx_usb_register_callback is
2493 * called. If both are NULL, then there is no
2494 * way to know when a transaction completes.
2495 * @param user_data User supplied data returned when the
2496 * callback is called. This is only used if
2497 * callback in not NULL.
2499 * @return A submitted transaction handle or negative on
2500 * failure. Negative values are failure codes from
2501 * cvmx_usb_status_t.
2503 int cvmx_usb_submit_control(cvmx_usb_state_t *state, int pipe_handle,
2504 uint64_t control_header,
2505 uint64_t buffer, int buffer_length,
2506 cvmx_usb_callback_func_t callback,
2510 cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
2511 cvmx_usb_control_header_t *header = cvmx_phys_to_ptr(control_header);
2513 CVMX_USB_LOG_CALLED();
2514 CVMX_USB_LOG_PARAM("%p", state);
2515 CVMX_USB_LOG_PARAM("%d", pipe_handle);
2516 CVMX_USB_LOG_PARAM("0x%llx", (unsigned long long)control_header);
2517 CVMX_USB_LOG_PARAM("0x%llx", (unsigned long long)buffer);
2518 CVMX_USB_LOG_PARAM("%d", buffer_length);
2520 /* Pipe handle checking is done later in a common place */
2521 if (cvmx_unlikely(!control_header))
2522 CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2523 /* Some drivers send a buffer with a zero length. God only knows why */
2524 if (cvmx_unlikely(buffer && (buffer_length < 0)))
2525 CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2526 if (cvmx_unlikely(!buffer && (buffer_length != 0)))
2527 CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2528 if ((header->s.request_type & 0x80) == 0)
2529 buffer_length = cvmx_le16_to_cpu(header->s.length);
2531 submit_handle = __cvmx_usb_submit_transaction(usb, pipe_handle,
2532 CVMX_USB_TRANSFER_CONTROL,
2537 0, /* iso_start_frame */
2538 0, /* iso_number_packets */
2539 NULL, /* iso_packets */
2542 CVMX_USB_RETURN(submit_handle);
2544 #ifdef CVMX_BUILD_FOR_LINUX_KERNEL
2545 EXPORT_SYMBOL(cvmx_usb_submit_control);
2550 * Call to submit a USB Isochronous transfer to a pipe.
2552 * @param state USB device state populated by
2553 * cvmx_usb_initialize().
2554 * @param pipe_handle
2555 * Handle to the pipe for the transfer.
2556 * @param start_frame
2557 * Number of frames into the future to schedule
2559 * @param flags Flags to control the transfer. See
2560 * cvmx_usb_isochronous_flags_t for the flag
2562 * @param number_packets
2563 * Number of sequential packets to transfer.
2564 * "packets" is a pointer to an array of this
2565 * many packet structures.
2566 * @param packets Description of each transfer packet as
2567 * defined by cvmx_usb_iso_packet_t. The array
2568 * pointed to here must stay valid until the
2569 * complete callback is called.
2570 * @param buffer Physical address of the data buffer in
2571 * memory. Note that this is NOT A POINTER, but
2572 * the full 64bit physical address of the
2573 * buffer. This may be zero if buffer_length is
2575 * @param buffer_length
2576 * Length of buffer in bytes.
2577 * @param callback Function to call when this transaction
2578 * completes. If the return value of this
2579 * function isn't an error, then this function
2580 * is guaranteed to be called when the
2581 * transaction completes. If this parameter is
2582 * NULL, then the generic callback registered
2583 * through cvmx_usb_register_callback is
2584 * called. If both are NULL, then there is no
2585 * way to know when a transaction completes.
2586 * @param user_data User supplied data returned when the
2587 * callback is called. This is only used if
2588 * callback in not NULL.
2590 * @return A submitted transaction handle or negative on
2591 * failure. Negative values are failure codes from
2592 * cvmx_usb_status_t.
2594 int cvmx_usb_submit_isochronous(cvmx_usb_state_t *state, int pipe_handle,
2595 int start_frame, int flags,
2597 cvmx_usb_iso_packet_t packets[],
2598 uint64_t buffer, int buffer_length,
2599 cvmx_usb_callback_func_t callback,
2603 cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
2605 CVMX_USB_LOG_CALLED();
2606 CVMX_USB_LOG_PARAM("%p", state);
2607 CVMX_USB_LOG_PARAM("%d", pipe_handle);
2608 CVMX_USB_LOG_PARAM("%d", start_frame);
2609 CVMX_USB_LOG_PARAM("0x%x", flags);
2610 CVMX_USB_LOG_PARAM("%d", number_packets);
2611 CVMX_USB_LOG_PARAM("%p", packets);
2612 CVMX_USB_LOG_PARAM("0x%llx", (unsigned long long)buffer);
2613 CVMX_USB_LOG_PARAM("%d", buffer_length);
2615 /* Pipe handle checking is done later in a common place */
2616 if (cvmx_unlikely(start_frame < 0))
2617 CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2618 if (cvmx_unlikely(flags & ~(CVMX_USB_ISOCHRONOUS_FLAGS_ALLOW_SHORT | CVMX_USB_ISOCHRONOUS_FLAGS_ASAP)))
2619 CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2620 if (cvmx_unlikely(number_packets < 1))
2621 CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2622 if (cvmx_unlikely(!packets))
2623 CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2624 if (cvmx_unlikely(!buffer))
2625 CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2626 if (cvmx_unlikely(buffer_length < 0))
2627 CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2629 submit_handle = __cvmx_usb_submit_transaction(usb, pipe_handle,
2630 CVMX_USB_TRANSFER_ISOCHRONOUS,
2634 0, /* control_header */
2640 CVMX_USB_RETURN(submit_handle);
2642 #ifdef CVMX_BUILD_FOR_LINUX_KERNEL
2643 EXPORT_SYMBOL(cvmx_usb_submit_isochronous);
2648 * Cancel one outstanding request in a pipe. Canceling a request
2649 * can fail if the transaction has already completed before cancel
2650 * is called. Even after a successful cancel call, it may take
2651 * a frame or two for the cvmx_usb_poll() function to call the
2652 * associated callback.
2654 * @param state USB device state populated by
2655 * cvmx_usb_initialize().
2656 * @param pipe_handle
2657 * Pipe handle to cancel requests in.
2658 * @param submit_handle
2659 * Handle to transaction to cancel, returned by the submit function.
2661 * @return CVMX_USB_SUCCESS or a negative error code defined in
2662 * cvmx_usb_status_t.
2664 cvmx_usb_status_t cvmx_usb_cancel(cvmx_usb_state_t *state, int pipe_handle,
2667 cvmx_usb_transaction_t *transaction;
2668 cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
2669 cvmx_usb_pipe_t *pipe = usb->pipe + pipe_handle;
2671 CVMX_USB_LOG_CALLED();
2672 CVMX_USB_LOG_PARAM("%p", state);
2673 CVMX_USB_LOG_PARAM("%d", pipe_handle);
2674 CVMX_USB_LOG_PARAM("%d", submit_handle);
2676 if (cvmx_unlikely((pipe_handle < 0) || (pipe_handle >= MAX_PIPES)))
2677 CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2678 if (cvmx_unlikely((submit_handle < 0) || (submit_handle >= MAX_TRANSACTIONS)))
2679 CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2681 /* Fail if the pipe isn't open */
2682 if (cvmx_unlikely((pipe->flags & __CVMX_USB_PIPE_FLAGS_OPEN) == 0))
2683 CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2685 transaction = usb->transaction + submit_handle;
2687 /* Fail if this transaction already completed */
2688 if (cvmx_unlikely((transaction->flags & __CVMX_USB_TRANSACTION_FLAGS_IN_USE) == 0))
2689 CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2691 /* If the transaction is the HEAD of the queue and scheduled. We need to
2693 if ((pipe->head == transaction) &&
2694 (pipe->flags & __CVMX_USB_PIPE_FLAGS_SCHEDULED))
2696 cvmx_usbcx_hccharx_t usbc_hcchar;
2698 usb->pipe_for_channel[pipe->channel] = NULL;
2699 pipe->flags &= ~__CVMX_USB_PIPE_FLAGS_SCHEDULED;
2703 usbc_hcchar.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HCCHARX(pipe->channel, usb->index));
2704 /* If the channel isn't enabled then the transaction already completed */
2705 if (usbc_hcchar.s.chena)
2707 usbc_hcchar.s.chdis = 1;
2708 __cvmx_usb_write_csr32(usb, CVMX_USBCX_HCCHARX(pipe->channel, usb->index), usbc_hcchar.u32);
2711 __cvmx_usb_perform_complete(usb, pipe, transaction, CVMX_USB_COMPLETE_CANCEL);
2712 CVMX_USB_RETURN(CVMX_USB_SUCCESS);
2714 #ifdef CVMX_BUILD_FOR_LINUX_KERNEL
2715 EXPORT_SYMBOL(cvmx_usb_cancel);
2720 * Cancel all outstanding requests in a pipe. Logically all this
2721 * does is call cvmx_usb_cancel() in a loop.
2723 * @param state USB device state populated by
2724 * cvmx_usb_initialize().
2725 * @param pipe_handle
2726 * Pipe handle to cancel requests in.
2728 * @return CVMX_USB_SUCCESS or a negative error code defined in
2729 * cvmx_usb_status_t.
2731 cvmx_usb_status_t cvmx_usb_cancel_all(cvmx_usb_state_t *state, int pipe_handle)
2733 cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
2734 cvmx_usb_pipe_t *pipe = usb->pipe + pipe_handle;
2736 CVMX_USB_LOG_CALLED();
2737 CVMX_USB_LOG_PARAM("%p", state);
2738 CVMX_USB_LOG_PARAM("%d", pipe_handle);
2739 if (cvmx_unlikely((pipe_handle < 0) || (pipe_handle >= MAX_PIPES)))
2740 CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2742 /* Fail if the pipe isn't open */
2743 if (cvmx_unlikely((pipe->flags & __CVMX_USB_PIPE_FLAGS_OPEN) == 0))
2744 CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2746 /* Simply loop through and attempt to cancel each transaction */
2749 cvmx_usb_status_t result = cvmx_usb_cancel(state, pipe_handle,
2750 __cvmx_usb_get_submit_handle(usb, pipe->head));
2751 if (cvmx_unlikely(result != CVMX_USB_SUCCESS))
2752 CVMX_USB_RETURN(result);
2754 CVMX_USB_RETURN(CVMX_USB_SUCCESS);
2756 #ifdef CVMX_BUILD_FOR_LINUX_KERNEL
2757 EXPORT_SYMBOL(cvmx_usb_cancel_all);
2762 * Close a pipe created with cvmx_usb_open_pipe().
2764 * @param state USB device state populated by
2765 * cvmx_usb_initialize().
2766 * @param pipe_handle
2767 * Pipe handle to close.
2769 * @return CVMX_USB_SUCCESS or a negative error code defined in
2770 * cvmx_usb_status_t. CVMX_USB_BUSY is returned if the
2771 * pipe has outstanding transfers.
2773 cvmx_usb_status_t cvmx_usb_close_pipe(cvmx_usb_state_t *state, int pipe_handle)
2775 cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
2776 cvmx_usb_pipe_t *pipe = usb->pipe + pipe_handle;
2778 CVMX_USB_LOG_CALLED();
2779 CVMX_USB_LOG_PARAM("%p", state);
2780 CVMX_USB_LOG_PARAM("%d", pipe_handle);
2781 if (cvmx_unlikely((pipe_handle < 0) || (pipe_handle >= MAX_PIPES)))
2782 CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2784 /* Fail if the pipe isn't open */
2785 if (cvmx_unlikely((pipe->flags & __CVMX_USB_PIPE_FLAGS_OPEN) == 0))
2786 CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2788 /* Fail if the pipe has pending transactions */
2789 if (cvmx_unlikely(pipe->head))
2790 CVMX_USB_RETURN(CVMX_USB_BUSY);
2793 __cvmx_usb_remove_pipe(&usb->idle_pipes, pipe);
2794 __cvmx_usb_append_pipe(&usb->free_pipes, pipe);
2796 CVMX_USB_RETURN(CVMX_USB_SUCCESS);
2798 #ifdef CVMX_BUILD_FOR_LINUX_KERNEL
2799 EXPORT_SYMBOL(cvmx_usb_close_pipe);
2804 * Register a function to be called when various USB events occur.
2806 * @param state USB device state populated by
2807 * cvmx_usb_initialize().
2808 * @param reason Which event to register for.
2809 * @param callback Function to call when the event occurs.
2810 * @param user_data User data parameter to the function.
2812 * @return CVMX_USB_SUCCESS or a negative error code defined in
2813 * cvmx_usb_status_t.
2815 cvmx_usb_status_t cvmx_usb_register_callback(cvmx_usb_state_t *state,
2816 cvmx_usb_callback_t reason,
2817 cvmx_usb_callback_func_t callback,
2820 cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
2822 CVMX_USB_LOG_CALLED();
2823 CVMX_USB_LOG_PARAM("%p", state);
2824 CVMX_USB_LOG_PARAM("%d", reason);
2825 CVMX_USB_LOG_PARAM("%p", callback);
2826 CVMX_USB_LOG_PARAM("%p", user_data);
2827 if (cvmx_unlikely(reason >= __CVMX_USB_CALLBACK_END))
2828 CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2829 if (cvmx_unlikely(!callback))
2830 CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2832 usb->callback[reason] = callback;
2833 usb->callback_data[reason] = user_data;
2835 CVMX_USB_RETURN(CVMX_USB_SUCCESS);
2837 #ifdef CVMX_BUILD_FOR_LINUX_KERNEL
2838 EXPORT_SYMBOL(cvmx_usb_register_callback);
2843 * Get the current USB protocol level frame number. The frame
2844 * number is always in the range of 0-0x7ff.
2846 * @param state USB device state populated by
2847 * cvmx_usb_initialize().
2849 * @return USB frame number
2851 int cvmx_usb_get_frame_number(cvmx_usb_state_t *state)
2854 cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
2855 cvmx_usbcx_hfnum_t usbc_hfnum;
2857 CVMX_USB_LOG_CALLED();
2858 CVMX_USB_LOG_PARAM("%p", state);
2860 usbc_hfnum.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HFNUM(usb->index));
2861 frame_number = usbc_hfnum.s.frnum;
2863 CVMX_USB_RETURN(frame_number);
2865 #ifdef CVMX_BUILD_FOR_LINUX_KERNEL
2866 EXPORT_SYMBOL(cvmx_usb_get_frame_number);
2872 * Poll a channel for status
2874 * @param usb USB device
2875 * @param channel Channel to poll
2877 * @return Zero on success
2879 static int __cvmx_usb_poll_channel(cvmx_usb_internal_state_t *usb, int channel)
2881 cvmx_usbcx_hcintx_t usbc_hcint;
2882 cvmx_usbcx_hctsizx_t usbc_hctsiz;
2883 cvmx_usbcx_hccharx_t usbc_hcchar;
2884 cvmx_usb_pipe_t *pipe;
2885 cvmx_usb_transaction_t *transaction;
2886 int bytes_this_transfer;
2887 int bytes_in_last_packet;
2888 int packets_processed;
2889 int buffer_space_left;
2890 CVMX_USB_LOG_CALLED();
2891 CVMX_USB_LOG_PARAM("%p", usb);
2892 CVMX_USB_LOG_PARAM("%d", channel);
2894 /* Read the interrupt status bits for the channel */
2895 usbc_hcint.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HCINTX(channel, usb->index));
2898 cvmx_dprintf("Channel %d%s%s%s%s%s%s%s%s%s%s%s\n", channel,
2899 (usbc_hcint.s.datatglerr) ? " DATATGLERR" : "",
2900 (usbc_hcint.s.frmovrun) ? " FRMOVRUN" : "",
2901 (usbc_hcint.s.bblerr) ? " BBLERR" : "",
2902 (usbc_hcint.s.xacterr) ? " XACTERR" : "",
2903 (usbc_hcint.s.nyet) ? " NYET" : "",
2904 (usbc_hcint.s.ack) ? " ACK" : "",
2905 (usbc_hcint.s.nak) ? " NAK" : "",
2906 (usbc_hcint.s.stall) ? " STALL" : "",
2907 (usbc_hcint.s.ahberr) ? " AHBERR" : "",
2908 (usbc_hcint.s.chhltd) ? " CHHLTD" : "",
2909 (usbc_hcint.s.xfercompl) ? " XFERCOMPL" : "");
2912 if (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_NO_DMA)
2914 usbc_hcchar.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HCCHARX(channel, usb->index));
2916 if (usbc_hcchar.s.chena && usbc_hcchar.s.chdis)
2918 /* There seems to be a bug in CN31XX which can cause interrupt
2919 IN transfers to get stuck until we do a write of HCCHARX
2920 without changing things */
2921 __cvmx_usb_write_csr32(usb, CVMX_USBCX_HCCHARX(channel, usb->index), usbc_hcchar.u32);
2925 /* In non DMA mode the channels don't halt themselves. We need to
2926 manually disable channels that are left running */
2927 if (!usbc_hcint.s.chhltd)
2929 if (usbc_hcchar.s.chena)
2931 cvmx_usbcx_hcintmskx_t hcintmsk;
2932 /* Disable all interrupts except CHHLTD */
2934 hcintmsk.s.chhltdmsk = 1;
2935 __cvmx_usb_write_csr32(usb, CVMX_USBCX_HCINTMSKX(channel, usb->index), hcintmsk.u32);
2936 usbc_hcchar.s.chdis = 1;
2937 __cvmx_usb_write_csr32(usb, CVMX_USBCX_HCCHARX(channel, usb->index), usbc_hcchar.u32);
2940 else if (usbc_hcint.s.xfercompl)
2942 /* Successful IN/OUT with transfer complete. Channel halt isn't needed */
2946 cvmx_dprintf("USB%d: Channel %d interrupt without halt\n", usb->index, channel);
2953 /* There is are no interrupts that we need to process when the channel is
2955 if (!usbc_hcint.s.chhltd)
2959 /* Disable the channel interrupts now that it is done */
2960 __cvmx_usb_write_csr32(usb, CVMX_USBCX_HCINTMSKX(channel, usb->index), 0);
2961 usb->idle_hardware_channels |= (1<<channel);
2963 /* Make sure this channel is tied to a valid pipe */
2964 pipe = usb->pipe_for_channel[channel];
2965 CVMX_PREFETCH(pipe, 0);
2966 CVMX_PREFETCH(pipe, 128);
2969 transaction = pipe->head;
2970 CVMX_PREFETCH0(transaction);
2972 /* Disconnect this pipe from the HW channel. Later the schedule function will
2973 figure out which pipe needs to go */
2974 usb->pipe_for_channel[channel] = NULL;
2975 pipe->flags &= ~__CVMX_USB_PIPE_FLAGS_SCHEDULED;
2977 /* Read the channel config info so we can figure out how much data
2979 usbc_hcchar.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HCCHARX(channel, usb->index));
2980 usbc_hctsiz.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HCTSIZX(channel, usb->index));
2982 /* Calculating the number of bytes successfully transferred is dependent on
2983 the transfer direction */
2984 packets_processed = transaction->pktcnt - usbc_hctsiz.s.pktcnt;
2985 if (usbc_hcchar.s.epdir)
2987 /* IN transactions are easy. For every byte received the hardware
2988 decrements xfersize. All we need to do is subtract the current
2989 value of xfersize from its starting value and we know how many
2990 bytes were written to the buffer */
2991 bytes_this_transfer = transaction->xfersize - usbc_hctsiz.s.xfersize;
2995 /* OUT transaction don't decrement xfersize. Instead pktcnt is
2996 decremented on every successful packet send. The hardware does
2997 this when it receives an ACK, or NYET. If it doesn't
2998 receive one of these responses pktcnt doesn't change */
2999 bytes_this_transfer = packets_processed * usbc_hcchar.s.mps;
3000 /* The last packet may not be a full transfer if we didn't have
3002 if (bytes_this_transfer > transaction->xfersize)
3003 bytes_this_transfer = transaction->xfersize;
3005 /* Figure out how many bytes were in the last packet of the transfer */
3006 if (packets_processed)
3007 bytes_in_last_packet = bytes_this_transfer - (packets_processed-1) * usbc_hcchar.s.mps;
3009 bytes_in_last_packet = bytes_this_transfer;
3011 /* As a special case, setup transactions output the setup header, not
3012 the user's data. For this reason we don't count setup data as bytes
3014 if ((transaction->stage == CVMX_USB_STAGE_SETUP) ||
3015 (transaction->stage == CVMX_USB_STAGE_SETUP_SPLIT_COMPLETE))
3016 bytes_this_transfer = 0;
3018 /* Optional debug output */
3019 if (cvmx_unlikely((usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_TRANSFERS) ||
3020 (pipe->flags & CVMX_USB_PIPE_FLAGS_DEBUG_TRANSFERS)))
3021 cvmx_dprintf("%s: Channel %d halted. Pipe %d transaction %d stage %d bytes=%d\n",
3022 __FUNCTION__, channel,
3023 __cvmx_usb_get_pipe_handle(usb, pipe),
3024 __cvmx_usb_get_submit_handle(usb, transaction),
3025 transaction->stage, bytes_this_transfer);
3027 /* Add the bytes transferred to the running total. It is important that
3028 bytes_this_transfer doesn't count any data that needs to be
3030 transaction->actual_bytes += bytes_this_transfer;
3031 if (transaction->type == CVMX_USB_TRANSFER_ISOCHRONOUS)
3032 buffer_space_left = transaction->iso_packets[0].length - transaction->actual_bytes;
3034 buffer_space_left = transaction->buffer_length - transaction->actual_bytes;
3036 /* We need to remember the PID toggle state for the next transaction. The
3037 hardware already updated it for the next transaction */
3038 pipe->pid_toggle = !(usbc_hctsiz.s.pid == 0);
3040 /* For high speed bulk out, assume the next transaction will need to do a
3041 ping before proceeding. If this isn't true the ACK processing below
3042 will clear this flag */
3043 if ((pipe->device_speed == CVMX_USB_SPEED_HIGH) &&
3044 (pipe->transfer_type == CVMX_USB_TRANSFER_BULK) &&
3045 (pipe->transfer_dir == CVMX_USB_DIRECTION_OUT))
3046 pipe->flags |= __CVMX_USB_PIPE_FLAGS_NEED_PING;
3048 if (usbc_hcint.s.stall)
3050 /* STALL as a response means this transaction cannot be completed
3051 because the device can't process transactions. Tell the user. Any
3052 data that was transferred will be counted on the actual bytes
3054 pipe->pid_toggle = 0;
3055 __cvmx_usb_perform_complete(usb, pipe, transaction, CVMX_USB_COMPLETE_STALL);
3057 else if (usbc_hcint.s.xacterr)
3059 /* We know at least one packet worked if we get a ACK or NAK. Reset the retry counter */
3060 if (usbc_hcint.s.nak || usbc_hcint.s.ack)
3061 transaction->retries = 0;
3062 transaction->retries++;
3063 if (transaction->retries > MAX_RETRIES)
3065 /* XactErr as a response means the device signaled something wrong with
3066 the transfer. For example, PID toggle errors cause these */
3067 __cvmx_usb_perform_complete(usb, pipe, transaction, CVMX_USB_COMPLETE_XACTERR);
3071 /* If this was a split then clear our split in progress marker */
3072 if (usb->active_split == transaction)
3073 usb->active_split = NULL;
3074 /* Rewind to the beginning of the transaction by anding off the
3075 split complete bit */
3076 transaction->stage &= ~1;
3077 pipe->split_sc_frame = -1;
3078 pipe->next_tx_frame += pipe->interval;
3079 if (pipe->next_tx_frame < usb->frame_number)
3080 pipe->next_tx_frame = usb->frame_number + pipe->interval -
3081 (usb->frame_number - pipe->next_tx_frame) % pipe->interval;
3084 else if (usbc_hcint.s.bblerr)
3086 /* Babble Error (BblErr) */
3087 __cvmx_usb_perform_complete(usb, pipe, transaction, CVMX_USB_COMPLETE_BABBLEERR);
3089 else if (usbc_hcint.s.datatglerr)
3091 /* We'll retry the exact same transaction again */
3092 transaction->retries++;
3094 else if (usbc_hcint.s.nyet)
3096 /* NYET as a response is only allowed in three cases: as a response to
3097 a ping, as a response to a split transaction, and as a response to
3098 a bulk out. The ping case is handled by hardware, so we only have
3099 splits and bulk out */
3100 if (!__cvmx_usb_pipe_needs_split(usb, pipe))
3102 transaction->retries = 0;
3103 /* If there is more data to go then we need to try again. Otherwise
3104 this transaction is complete */
3105 if ((buffer_space_left == 0) || (bytes_in_last_packet < pipe->max_packet))
3106 __cvmx_usb_perform_complete(usb, pipe, transaction, CVMX_USB_COMPLETE_SUCCESS);
3110 /* Split transactions retry the split complete 4 times then rewind
3111 to the start split and do the entire transactions again */
3112 transaction->retries++;
3113 if ((transaction->retries & 0x3) == 0)
3115 /* Rewind to the beginning of the transaction by anding off the
3116 split complete bit */
3117 transaction->stage &= ~1;
3118 pipe->split_sc_frame = -1;
3122 else if (usbc_hcint.s.ack)
3124 transaction->retries = 0;
3125 /* The ACK bit can only be checked after the other error bits. This is
3126 because a multi packet transfer may succeed in a number of packets
3127 and then get a different response on the last packet. In this case
3128 both ACK and the last response bit will be set. If none of the
3129 other response bits is set, then the last packet must have been an
3132 /* Since we got an ACK, we know we don't need to do a ping on this
3134 pipe->flags &= ~__CVMX_USB_PIPE_FLAGS_NEED_PING;
3136 switch (transaction->type)
3138 case CVMX_USB_TRANSFER_CONTROL:
3139 switch (transaction->stage)
3141 case CVMX_USB_STAGE_NON_CONTROL:
3142 case CVMX_USB_STAGE_NON_CONTROL_SPLIT_COMPLETE:
3143 /* This should be impossible */
3144 __cvmx_usb_perform_complete(usb, pipe, transaction, CVMX_USB_COMPLETE_ERROR);
3146 case CVMX_USB_STAGE_SETUP:
3147 pipe->pid_toggle = 1;
3148 if (__cvmx_usb_pipe_needs_split(usb, pipe))
3149 transaction->stage = CVMX_USB_STAGE_SETUP_SPLIT_COMPLETE;
3152 cvmx_usb_control_header_t *header = cvmx_phys_to_ptr(transaction->control_header);
3153 if (header->s.length)
3154 transaction->stage = CVMX_USB_STAGE_DATA;
3156 transaction->stage = CVMX_USB_STAGE_STATUS;
3159 case CVMX_USB_STAGE_SETUP_SPLIT_COMPLETE:
3161 cvmx_usb_control_header_t *header = cvmx_phys_to_ptr(transaction->control_header);
3162 if (header->s.length)
3163 transaction->stage = CVMX_USB_STAGE_DATA;
3165 transaction->stage = CVMX_USB_STAGE_STATUS;
3168 case CVMX_USB_STAGE_DATA:
3169 if (__cvmx_usb_pipe_needs_split(usb, pipe))
3171 transaction->stage = CVMX_USB_STAGE_DATA_SPLIT_COMPLETE;
3172 /* For setup OUT data that are splits, the hardware
3173 doesn't appear to count transferred data. Here
3174 we manually update the data transferred */
3175 if (!usbc_hcchar.s.epdir)
3177 if (buffer_space_left < pipe->max_packet)
3178 transaction->actual_bytes += buffer_space_left;
3180 transaction->actual_bytes += pipe->max_packet;
3183 else if ((buffer_space_left == 0) || (bytes_in_last_packet < pipe->max_packet))
3185 pipe->pid_toggle = 1;
3186 transaction->stage = CVMX_USB_STAGE_STATUS;
3189 case CVMX_USB_STAGE_DATA_SPLIT_COMPLETE:
3190 if ((buffer_space_left == 0) || (bytes_in_last_packet < pipe->max_packet))
3192 pipe->pid_toggle = 1;
3193 transaction->stage = CVMX_USB_STAGE_STATUS;
3197 transaction->stage = CVMX_USB_STAGE_DATA;
3200 case CVMX_USB_STAGE_STATUS:
3201 if (__cvmx_usb_pipe_needs_split(usb, pipe))
3202 transaction->stage = CVMX_USB_STAGE_STATUS_SPLIT_COMPLETE;
3204 __cvmx_usb_perform_complete(usb, pipe, transaction, CVMX_USB_COMPLETE_SUCCESS);
3206 case CVMX_USB_STAGE_STATUS_SPLIT_COMPLETE:
3207 __cvmx_usb_perform_complete(usb, pipe, transaction, CVMX_USB_COMPLETE_SUCCESS);
3211 case CVMX_USB_TRANSFER_BULK:
3212 case CVMX_USB_TRANSFER_INTERRUPT:
3213 /* The only time a bulk transfer isn't complete when
3214 it finishes with an ACK is during a split transaction. For
3215 splits we need to continue the transfer if more data is
3217 if (__cvmx_usb_pipe_needs_split(usb, pipe))
3219 if (transaction->stage == CVMX_USB_STAGE_NON_CONTROL)
3220 transaction->stage = CVMX_USB_STAGE_NON_CONTROL_SPLIT_COMPLETE;
3223 if (buffer_space_left && (bytes_in_last_packet == pipe->max_packet))
3224 transaction->stage = CVMX_USB_STAGE_NON_CONTROL;
3227 if (transaction->type == CVMX_USB_TRANSFER_INTERRUPT)
3228 pipe->next_tx_frame += pipe->interval;
3229 __cvmx_usb_perform_complete(usb, pipe, transaction, CVMX_USB_COMPLETE_SUCCESS);
3235 if ((pipe->device_speed == CVMX_USB_SPEED_HIGH) &&
3236 (pipe->transfer_type == CVMX_USB_TRANSFER_BULK) &&
3237 (pipe->transfer_dir == CVMX_USB_DIRECTION_OUT) &&
3239 pipe->flags |= __CVMX_USB_PIPE_FLAGS_NEED_PING;
3240 if (!buffer_space_left || (bytes_in_last_packet < pipe->max_packet))
3242 if (transaction->type == CVMX_USB_TRANSFER_INTERRUPT)
3243 pipe->next_tx_frame += pipe->interval;
3244 __cvmx_usb_perform_complete(usb, pipe, transaction, CVMX_USB_COMPLETE_SUCCESS);
3248 case CVMX_USB_TRANSFER_ISOCHRONOUS:
3249 if (__cvmx_usb_pipe_needs_split(usb, pipe))
3251 /* ISOCHRONOUS OUT splits don't require a complete split stage.
3252 Instead they use a sequence of begin OUT splits to transfer
3253 the data 188 bytes at a time. Once the transfer is complete,
3254 the pipe sleeps until the next schedule interval */
3255 if (pipe->transfer_dir == CVMX_USB_DIRECTION_OUT)
3257 /* If no space left or this wasn't a max size packet then
3258 this transfer is complete. Otherwise start it again
3259 to send the next 188 bytes */
3260 if (!buffer_space_left || (bytes_this_transfer < 188))
3262 pipe->next_tx_frame += pipe->interval;
3263 __cvmx_usb_perform_complete(usb, pipe, transaction, CVMX_USB_COMPLETE_SUCCESS);
3268 if (transaction->stage == CVMX_USB_STAGE_NON_CONTROL_SPLIT_COMPLETE)
3270 /* We are in the incoming data phase. Keep getting
3271 data until we run out of space or get a small
3273 if ((buffer_space_left == 0) || (bytes_in_last_packet < pipe->max_packet))
3275 pipe->next_tx_frame += pipe->interval;
3276 __cvmx_usb_perform_complete(usb, pipe, transaction, CVMX_USB_COMPLETE_SUCCESS);
3280 transaction->stage = CVMX_USB_STAGE_NON_CONTROL_SPLIT_COMPLETE;
3285 pipe->next_tx_frame += pipe->interval;
3286 __cvmx_usb_perform_complete(usb, pipe, transaction, CVMX_USB_COMPLETE_SUCCESS);
3291 else if (usbc_hcint.s.nak)
3293 /* If this was a split then clear our split in progress marker */
3294 if (usb->active_split == transaction)
3295 usb->active_split = NULL;
3296 /* NAK as a response means the device couldn't accept the transaction,
3297 but it should be retried in the future. Rewind to the beginning of
3298 the transaction by anding off the split complete bit. Retry in the
3300 transaction->retries = 0;
3301 transaction->stage &= ~1;
3302 pipe->next_tx_frame += pipe->interval;
3303 if (pipe->next_tx_frame < usb->frame_number)
3304 pipe->next_tx_frame = usb->frame_number + pipe->interval -
3305 (usb->frame_number - pipe->next_tx_frame) % pipe->interval;
3309 cvmx_usb_port_status_t port;
3310 port = cvmx_usb_get_status((cvmx_usb_state_t *)usb);
3311 if (port.port_enabled)
3313 /* We'll retry the exact same transaction again */
3314 transaction->retries++;
3318 /* We get channel halted interrupts with no result bits sets when the
3319 cable is unplugged */
3320 __cvmx_usb_perform_complete(usb, pipe, transaction, CVMX_USB_COMPLETE_ERROR);
3328 * Poll the USB block for status and call all needed callback
3329 * handlers. This function is meant to be called in the interrupt
3330 * handler for the USB controller. It can also be called
3331 * periodically in a loop for non-interrupt based operation.
3333 * @param state USB device state populated by
3334 * cvmx_usb_initialize().
3336 * @return CVMX_USB_SUCCESS or a negative error code defined in
3337 * cvmx_usb_status_t.
3339 cvmx_usb_status_t cvmx_usb_poll(cvmx_usb_state_t *state)
3341 cvmx_usbcx_hfnum_t usbc_hfnum;
3342 cvmx_usbcx_gintsts_t usbc_gintsts;
3343 cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
3345 CVMX_PREFETCH(usb, 0);
3346 CVMX_PREFETCH(usb, 1*128);
3347 CVMX_PREFETCH(usb, 2*128);
3348 CVMX_PREFETCH(usb, 3*128);
3349 CVMX_PREFETCH(usb, 4*128);
3351 CVMX_USB_LOG_CALLED();
3352 CVMX_USB_LOG_PARAM("%p", state);
3354 /* Update the frame counter */
3355 usbc_hfnum.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HFNUM(usb->index));
3356 if ((usb->frame_number&0x3fff) > usbc_hfnum.s.frnum)
3357 usb->frame_number += 0x4000;
3358 usb->frame_number &= ~0x3fffull;
3359 usb->frame_number |= usbc_hfnum.s.frnum;
3361 /* Read the pending interrupts */
3362 usbc_gintsts.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_GINTSTS(usb->index));
3364 /* Clear the interrupts now that we know about them */
3365 __cvmx_usb_write_csr32(usb, CVMX_USBCX_GINTSTS(usb->index), usbc_gintsts.u32);
3367 if (usbc_gintsts.s.rxflvl)
3369 /* RxFIFO Non-Empty (RxFLvl)
3370 Indicates that there is at least one packet pending to be read
3372 /* In DMA mode this is handled by hardware */
3373 if (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_NO_DMA)
3374 __cvmx_usb_poll_rx_fifo(usb);
3376 if (usbc_gintsts.s.ptxfemp || usbc_gintsts.s.nptxfemp)
3378 /* Fill the Tx FIFOs when not in DMA mode */
3379 if (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_NO_DMA)
3380 __cvmx_usb_poll_tx_fifo(usb);
3382 if (usbc_gintsts.s.disconnint || usbc_gintsts.s.prtint)
3384 cvmx_usbcx_hprt_t usbc_hprt;
3385 /* Disconnect Detected Interrupt (DisconnInt)
3386 Asserted when a device disconnect is detected. */
3388 /* Host Port Interrupt (PrtInt)
3389 The core sets this bit to indicate a change in port status of one
3390 of the O2P USB core ports in Host mode. The application must
3391 read the Host Port Control and Status (HPRT) register to
3392 determine the exact event that caused this interrupt. The
3393 application must clear the appropriate status bit in the Host Port
3394 Control and Status register to clear this bit. */
3396 /* Call the user's port callback */
3397 __cvmx_usb_perform_callback(usb, NULL, NULL,
3398 CVMX_USB_CALLBACK_PORT_CHANGED,
3399 CVMX_USB_COMPLETE_SUCCESS);
3400 /* Clear the port change bits */
3401 usbc_hprt.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HPRT(usb->index));
3402 usbc_hprt.s.prtena = 0;
3403 __cvmx_usb_write_csr32(usb, CVMX_USBCX_HPRT(usb->index), usbc_hprt.u32);
3405 if (usbc_gintsts.s.hchint)
3407 /* Host Channels Interrupt (HChInt)
3408 The core sets this bit to indicate that an interrupt is pending on
3409 one of the channels of the core (in Host mode). The application
3410 must read the Host All Channels Interrupt (HAINT) register to
3411 determine the exact number of the channel on which the
3412 interrupt occurred, and then read the corresponding Host
3413 Channel-n Interrupt (HCINTn) register to determine the exact
3414 cause of the interrupt. The application must clear the
3415 appropriate status bit in the HCINTn register to clear this bit. */
3416 cvmx_usbcx_haint_t usbc_haint;
3417 usbc_haint.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HAINT(usb->index));
3418 while (usbc_haint.u32)
3421 CVMX_CLZ(channel, usbc_haint.u32);
3422 channel = 31 - channel;
3423 __cvmx_usb_poll_channel(usb, channel);
3424 usbc_haint.u32 ^= 1<<channel;
3428 __cvmx_usb_schedule(usb, usbc_gintsts.s.sof);
3430 CVMX_USB_RETURN(CVMX_USB_SUCCESS);
3432 #ifdef CVMX_BUILD_FOR_LINUX_KERNEL
3433 EXPORT_SYMBOL(cvmx_usb_poll);
3436 extern void cvmx_usb_set_toggle(cvmx_usb_state_t *state, int endpoint_num, int toggle)
3438 cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
3439 cvmx_usb_pipe_t *pipe = usb->pipe + endpoint_num;
3441 pipe->pid_toggle = !!toggle;
3444 extern int cvmx_usb_get_toggle(cvmx_usb_state_t *state, int endpoint_num)
3446 cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
3447 cvmx_usb_pipe_t *pipe = usb->pipe + endpoint_num;
3449 if (pipe->pid_toggle)