sys/contrib/octeon-sdk/cvmx-usb.c

   1 /***********************license start***************
   2  * Copyright (c) 2003-2010  Cavium Inc. (support@cavium.com). All rights
   3  * reserved.
   4  *
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions are
   8  * met:
   9  *
  10  *   * Redistributions of source code must retain the above copyright
  11  *     notice, this list of conditions and the following disclaimer.
  12  *
  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.
  17
  18  *   * Neither the name of Cavium Inc. nor the names of
  19  *     its contributors may be used to endorse or promote products
  20  *     derived from this software without specific prior written
  21  *     permission.
  22
  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
  26  * countries.
  27
  28  * TO THE MAXIMUM EXTENT PERMITTED BY LAW, THE SOFTWARE IS PROVIDED "AS IS"
  29  * AND WITH ALL FAULTS AND CAVIUM INC. 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**************************************/
  39
  40
  41 /**
  42  * @file
  43  *
  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
  48  * operations.
  49  *
  50  * <hr>$Revision: 32636 $<hr>
  51  */
  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>
  62 #if 0
  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
  65     * this file */
  66    #include <asm/octeon/cvmx-error.h>
  67 #endif
  68 #else
  69 #include "cvmx.h"
  70 #include "cvmx-clock.h"
  71 #include "cvmx-sysinfo.h"
  72 #include "cvmx-usb.h"
  73 #include "cvmx-helper.h"
  74 #include "cvmx-helper-board.h"
  75 #if !defined(CVMX_BUILD_FOR_FREEBSD_KERNEL)
  76 #include "cvmx-csr-db.h"
  77 #endif
  78 #include "cvmx-swap.h"
  79 #if !defined(CVMX_BUILD_FOR_FREEBSD_KERNEL)
  80 #include "cvmx-error.h"
  81 #endif
  82 #endif
  83
  84 #define MAX_RETRIES         3   /* Maximum number of times to retry failed transactions */
  85 #define MAX_PIPES           32  /* Maximum number of pipes that can be open at once */
  86 #define MAX_TRANSACTIONS    256 /* Maximum number of outstanding transactions across all pipes */
  87 #define MAX_CHANNELS        8   /* Maximum number of hardware channels supported by the USB block */
  88 #define MAX_USB_ADDRESS     127 /* The highest valid USB device address */
  89 #define MAX_USB_ENDPOINT    15  /* The highest valid USB endpoint number */
  90 #define MAX_USB_HUB_PORT    15  /* The highest valid port number on a hub */
  91 #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 */
  92 #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 */
  93 #define ALLOW_CSR_DECODES   0   /* CSR decoding when CVMX_USB_INITIALIZE_FLAGS_DEBUG_CSRS is set
  94                                     enlarges the code a lot. This define overrides the ability to do CSR
  95                                     decoding since it isn't necessary 99% of the time. Change this to a
  96                                     one if you need CSR decoding */
  97
  98 /* These defines disable the normal read and write csr. This is so I can add
  99     extra debug stuff to the usb specific version and I won't use the normal
 100     version by mistake */
 101 #define cvmx_read_csr use_cvmx_usb_read_csr64_instead_of_cvmx_read_csr
 102 #define cvmx_write_csr use_cvmx_usb_write_csr64_instead_of_cvmx_write_csr
 103
 104 typedef enum
 105 {
 106     __CVMX_USB_TRANSACTION_FLAGS_IN_USE = 1<<16,
 107 } cvmx_usb_transaction_flags_t;
 108
 109 /**
 110  * Logical transactions may take numerous low level
 111  * transactions, especially when splits are concerned. This
 112  * enum represents all of the possible stages a transaction can
 113  * be in. Note that split completes are always even. This is so
 114  * the NAK handler can backup to the previous low level
 115  * transaction with a simple clearing of bit 0.
 116  */
 117 typedef enum
 118 {
 119     CVMX_USB_STAGE_NON_CONTROL,
 120     CVMX_USB_STAGE_NON_CONTROL_SPLIT_COMPLETE,
 121     CVMX_USB_STAGE_SETUP,
 122     CVMX_USB_STAGE_SETUP_SPLIT_COMPLETE,
 123     CVMX_USB_STAGE_DATA,
 124     CVMX_USB_STAGE_DATA_SPLIT_COMPLETE,
 125     CVMX_USB_STAGE_STATUS,
 126     CVMX_USB_STAGE_STATUS_SPLIT_COMPLETE,
 127 } cvmx_usb_stage_t;
 128
 129 /**
 130  * This structure describes each pending USB transaction
 131  * regardless of type. These are linked together to form a list
 132  * of pending requests for a pipe.
 133  */
 134 typedef struct cvmx_usb_transaction
 135 {
 136     struct cvmx_usb_transaction *prev;  /**< Transaction before this one in the pipe */
 137     struct cvmx_usb_transaction *next;  /**< Transaction after this one in the pipe */
 138     cvmx_usb_transfer_t type;           /**< Type of transaction, duplicated of the pipe */
 139     cvmx_usb_transaction_flags_t flags; /**< State flags for this transaction */
 140     uint64_t buffer;                    /**< User's physical buffer address to read/write */
 141     int buffer_length;                  /**< Size of the user's buffer in bytes */
 142     uint64_t control_header;            /**< For control transactions, physical address of the 8 byte standard header */
 143     int iso_start_frame;                /**< For ISO transactions, the starting frame number */
 144     int iso_number_packets;             /**< For ISO transactions, the number of packets in the request */
 145     cvmx_usb_iso_packet_t *iso_packets; /**< For ISO transactions, the sub packets in the request */
 146     int xfersize;
 147     int pktcnt;
 148     int retries;
 149     int actual_bytes;                   /**< Actual bytes transfer for this transaction */
 150     cvmx_usb_stage_t stage;             /**< For control transactions, the current stage */
 151     cvmx_usb_callback_func_t callback;  /**< User's callback function when complete */
 152     void *callback_data;                /**< User's data */
 153 } cvmx_usb_transaction_t;
 154
 155 /**
 156  * A pipe represents a virtual connection between Octeon and some
 157  * USB device. It contains a list of pending request to the device.
 158  */
 159 typedef struct cvmx_usb_pipe
 160 {
 161     struct cvmx_usb_pipe *prev;         /**< Pipe before this one in the list */
 162     struct cvmx_usb_pipe *next;         /**< Pipe after this one in the list */
 163     cvmx_usb_transaction_t *head;       /**< The first pending transaction */
 164     cvmx_usb_transaction_t *tail;       /**< The last pending transaction */
 165     uint64_t interval;                  /**< For periodic pipes, the interval between packets in frames */
 166     uint64_t next_tx_frame;             /**< The next frame this pipe is allowed to transmit on */
 167     cvmx_usb_pipe_flags_t flags;        /**< State flags for this pipe */
 168     cvmx_usb_speed_t device_speed;      /**< Speed of device connected to this pipe */
 169     cvmx_usb_transfer_t transfer_type;  /**< Type of transaction supported by this pipe */
 170     cvmx_usb_direction_t transfer_dir;  /**< IN or OUT. Ignored for Control */
 171     int multi_count;                    /**< Max packet in a row for the device */
 172     uint16_t max_packet;                /**< The device's maximum packet size in bytes */
 173     uint8_t device_addr;                /**< USB device address at other end of pipe */
 174     uint8_t endpoint_num;               /**< USB endpoint number at other end of pipe */
 175     uint8_t hub_device_addr;            /**< Hub address this device is connected to */
 176     uint8_t hub_port;                   /**< Hub port this device is connected to */
 177     uint8_t pid_toggle;                 /**< This toggles between 0/1 on every packet send to track the data pid needed */
 178     uint8_t channel;                    /**< Hardware DMA channel for this pipe */
 179     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;
 181
 182 typedef struct
 183 {
 184     cvmx_usb_pipe_t *head;              /**< Head of the list, or NULL if empty */
 185     cvmx_usb_pipe_t *tail;              /**< Tail if the list, or NULL if empty */
 186 } cvmx_usb_pipe_list_t;
 187
 188 typedef struct
 189 {
 190     struct
 191     {
 192         int channel;
 193         int size;
 194         uint64_t address;
 195     } entry[MAX_CHANNELS+1];
 196     int head;
 197     int tail;
 198 } cvmx_usb_tx_fifo_t;
 199
 200 /**
 201  * The state of the USB block is stored in this structure
 202  */
 203 typedef struct
 204 {
 205     int init_flags;                     /**< Flags passed to initialize */
 206     int index;                          /**< Which USB block this is for */
 207     int idle_hardware_channels;         /**< Bit set for every idle hardware channel */
 208     cvmx_usbcx_hprt_t usbcx_hprt;       /**< Stored port status so we don't need to read a CSR to determine splits */
 209     cvmx_usb_pipe_t *pipe_for_channel[MAX_CHANNELS];    /**< Map channels to pipes */
 210     cvmx_usb_transaction_t *free_transaction_head;      /**< List of free transactions head */
 211     cvmx_usb_transaction_t *free_transaction_tail;      /**< List of free transactions tail */
 212     cvmx_usb_pipe_t pipe[MAX_PIPES];                    /**< Storage for pipes */
 213     cvmx_usb_transaction_t transaction[MAX_TRANSACTIONS];       /**< Storage for transactions */
 214     cvmx_usb_callback_func_t callback[__CVMX_USB_CALLBACK_END]; /**< User global callbacks */
 215     void *callback_data[__CVMX_USB_CALLBACK_END];               /**< User data for each callback */
 216     int indent;                         /**< Used by debug output to indent functions */
 217     cvmx_usb_port_status_t port_status; /**< Last port status used for change notification */
 218     cvmx_usb_pipe_list_t free_pipes;    /**< List of all pipes that are currently closed */
 219     cvmx_usb_pipe_list_t idle_pipes;    /**< List of open pipes that have no transactions */
 220     cvmx_usb_pipe_list_t active_pipes[4]; /**< Active pipes indexed by transfer type */
 221     uint64_t frame_number;              /**< Increments every SOF interrupt for time keeping */
 222     cvmx_usb_transaction_t *active_split; /**< Points to the current active split, or NULL */
 223     cvmx_usb_tx_fifo_t periodic;
 224     cvmx_usb_tx_fifo_t nonperiodic;
 225 } cvmx_usb_internal_state_t;
 226
 227 /* This macro logs out whenever a function is called if debugging is on */
 228 #define CVMX_USB_LOG_CALLED() \
 229     if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_CALLS)) \
 230         cvmx_dprintf("%*s%s: called\n", 2*usb->indent++, "", __FUNCTION__);
 231
 232 /* This macro logs out each function parameter if debugging is on */
 233 #define CVMX_USB_LOG_PARAM(format, param) \
 234     if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_CALLS)) \
 235         cvmx_dprintf("%*s%s: param %s = " format "\n", 2*usb->indent, "", __FUNCTION__, #param, param);
 236
 237 /* This macro logs out when a function returns a value */
 238 #define CVMX_USB_RETURN(v)                                              \
 239     do {                                                                \
 240         __typeof(v) r = v;                                              \
 241         if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_CALLS))    \
 242             cvmx_dprintf("%*s%s: returned %s(%d)\n", 2*--usb->indent, "", __FUNCTION__, #v, r); \
 243         return r;                                                       \
 244     } while (0);
 245
 246 /* This macro logs out when a function doesn't return a value */
 247 #define CVMX_USB_RETURN_NOTHING()                                       \
 248     do {                                                                \
 249         if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_CALLS))    \
 250             cvmx_dprintf("%*s%s: returned\n", 2*--usb->indent, "", __FUNCTION__); \
 251         return;                                                         \
 252     } while (0);
 253
 254 /* This macro spins on a field waiting for it to reach a value */
 255 #define CVMX_WAIT_FOR_FIELD32(address, type, field, op, value, timeout_usec)\
 256     ({int result;                                                       \
 257     do {                                                                \
 258         uint64_t done = cvmx_get_cycle() + (uint64_t)timeout_usec *     \
 259                            cvmx_clock_get_rate(CVMX_CLOCK_CORE) / 1000000;  \
 260         type c;                                                         \
 261         while (1)                                                       \
 262         {                                                               \
 263             c.u32 = __cvmx_usb_read_csr32(usb, address);                \
 264             if (c.s.field op (value)) {                                 \
 265                 result = 0;                                             \
 266                 break;                                                  \
 267             } else if (cvmx_get_cycle() > done) {                       \
 268                 result = -1;                                            \
 269                 break;                                                  \
 270             } else                                                      \
 271                 cvmx_wait(100);                                         \
 272         }                                                               \
 273     } while (0);                                                        \
 274     result;})
 275
 276 /* This macro logically sets a single field in a CSR. It does the sequence
 277     read, modify, and write */
 278 #define USB_SET_FIELD32(address, type, field, value)\
 279     do {                                            \
 280         type c;                                     \
 281         c.u32 = __cvmx_usb_read_csr32(usb, address);\
 282         c.s.field = value;                          \
 283         __cvmx_usb_write_csr32(usb, address, c.u32);\
 284     } while (0)
 285
 286 /* Returns the IO address to push/pop stuff data from the FIFOs */
 287 #define USB_FIFO_ADDRESS(channel, usb_index) (CVMX_USBCX_GOTGCTL(usb_index) + ((channel)+1)*0x1000)
 288
 289 /**
 290  * @INTERNAL
 291  * Read a USB 32bit CSR. It performs the necessary address swizzle
 292  * for 32bit CSRs and logs the value in a readable format if
 293  * debugging is on.
 294  *
 295  * @param usb     USB block this access is for
 296  * @param address 64bit address to read
 297  *
 298  * @return Result of the read
 299  */
 300 static inline uint32_t __cvmx_usb_read_csr32(cvmx_usb_internal_state_t *usb,
 301                                              uint64_t address)
 302 {
 303     uint32_t result = cvmx_read64_uint32(address ^ 4);
 304 #if ALLOW_CSR_DECODES
 305     if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_CSRS))
 306     {
 307         cvmx_dprintf("Read: ");
 308         cvmx_csr_db_decode(cvmx_get_proc_id(), address, result);
 309     }
 310 #endif
 311     return result;
 312 }
 313
 314
 315 /**
 316  * @INTERNAL
 317  * Write a USB 32bit CSR. It performs the necessary address
 318  * swizzle for 32bit CSRs and logs the value in a readable format
 319  * if debugging is on.
 320  *
 321  * @param usb     USB block this access is for
 322  * @param address 64bit address to write
 323  * @param value   Value to write
 324  */
 325 static inline void __cvmx_usb_write_csr32(cvmx_usb_internal_state_t *usb,
 326                                           uint64_t address, uint32_t value)
 327 {
 328 #if ALLOW_CSR_DECODES
 329     if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_CSRS))
 330     {
 331         cvmx_dprintf("Write: ");
 332         cvmx_csr_db_decode(cvmx_get_proc_id(), address, value);
 333     }
 334 #endif
 335     cvmx_write64_uint32(address ^ 4, value);
 336     cvmx_read64_uint64(CVMX_USBNX_DMA0_INB_CHN0(usb->index));
 337 }
 338
 339
 340 /**
 341  * @INTERNAL
 342  * Read a USB 64bit CSR. It logs the value in a readable format if
 343  * debugging is on.
 344  *
 345  * @param usb     USB block this access is for
 346  * @param address 64bit address to read
 347  *
 348  * @return Result of the read
 349  */
 350 static inline uint64_t __cvmx_usb_read_csr64(cvmx_usb_internal_state_t *usb,
 351                                              uint64_t address)
 352 {
 353     uint64_t result = cvmx_read64_uint64(address);
 354 #if ALLOW_CSR_DECODES
 355     if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_CSRS))
 356     {
 357         cvmx_dprintf("Read: ");
 358         cvmx_csr_db_decode(cvmx_get_proc_id(), address, result);
 359     }
 360 #endif
 361     return result;
 362 }
 363
 364
 365 /**
 366  * @INTERNAL
 367  * Write a USB 64bit CSR. It logs the value in a readable format
 368  * if debugging is on.
 369  *
 370  * @param usb     USB block this access is for
 371  * @param address 64bit address to write
 372  * @param value   Value to write
 373  */
 374 static inline void __cvmx_usb_write_csr64(cvmx_usb_internal_state_t *usb,
 375                                           uint64_t address, uint64_t value)
 376 {
 377 #if ALLOW_CSR_DECODES
 378     if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_CSRS))
 379     {
 380         cvmx_dprintf("Write: ");
 381         cvmx_csr_db_decode(cvmx_get_proc_id(), address, value);
 382     }
 383 #endif
 384     cvmx_write64_uint64(address, value);
 385 }
 386
 387
 388 /**
 389  * @INTERNAL
 390  * Utility function to convert complete codes into strings
 391  *
 392  * @param complete_code
 393  *               Code to convert
 394  *
 395  * @return Human readable string
 396  */
 397 static const char *__cvmx_usb_complete_to_string(cvmx_usb_complete_t complete_code)
 398 {
 399     switch (complete_code)
 400     {
 401         case CVMX_USB_COMPLETE_SUCCESS: return "SUCCESS";
 402         case CVMX_USB_COMPLETE_SHORT:   return "SHORT";
 403         case CVMX_USB_COMPLETE_CANCEL:  return "CANCEL";
 404         case CVMX_USB_COMPLETE_ERROR:   return "ERROR";
 405         case CVMX_USB_COMPLETE_STALL:   return "STALL";
 406         case CVMX_USB_COMPLETE_XACTERR: return "XACTERR";
 407         case CVMX_USB_COMPLETE_DATATGLERR: return "DATATGLERR";
 408         case CVMX_USB_COMPLETE_BABBLEERR: return "BABBLEERR";
 409         case CVMX_USB_COMPLETE_FRAMEERR: return "FRAMEERR";
 410     }
 411     return "Update __cvmx_usb_complete_to_string";
 412 }
 413
 414
 415 /**
 416  * @INTERNAL
 417  * Return non zero if this pipe connects to a non HIGH speed
 418  * device through a high speed hub.
 419  *
 420  * @param usb    USB block this access is for
 421  * @param pipe   Pipe to check
 422  *
 423  * @return Non zero if we need to do split transactions
 424  */
 425 static inline int __cvmx_usb_pipe_needs_split(cvmx_usb_internal_state_t *usb, cvmx_usb_pipe_t *pipe)
 426 {
 427     return ((pipe->device_speed != CVMX_USB_SPEED_HIGH) && (usb->usbcx_hprt.s.prtspd == CVMX_USB_SPEED_HIGH));
 428 }
 429
 430
 431 /**
 432  * @INTERNAL
 433  * Trivial utility function to return the correct PID for a pipe
 434  *
 435  * @param pipe   pipe to check
 436  *
 437  * @return PID for pipe
 438  */
 439 static inline int __cvmx_usb_get_data_pid(cvmx_usb_pipe_t *pipe)
 440 {
 441     if (pipe->pid_toggle)
 442         return 2; /* Data1 */
 443     else
 444         return 0; /* Data0 */
 445 }
 446
 447
 448 /**
 449  * Return the number of USB ports supported by this Octeon
 450  * chip. If the chip doesn't support USB, or is not supported
 451  * by this API, a zero will be returned. Most Octeon chips
 452  * support one usb port, but some support two ports.
 453  * cvmx_usb_initialize() must be called on independent
 454  * cvmx_usb_state_t structures.
 455  *
 456  * This utilizes cvmx_helper_board_usb_get_num_ports()
 457  * to get any board specific variations.
 458  *
 459  * @return Number of port, zero if usb isn't supported
 460  */
 461 int cvmx_usb_get_num_ports(void)
 462 {
 463     int arch_ports = 0;
 464
 465     if (OCTEON_IS_MODEL(OCTEON_CN56XX))
 466         arch_ports = 1;
 467     else if (OCTEON_IS_MODEL(OCTEON_CN52XX))
 468         arch_ports = 2;
 469     else if (OCTEON_IS_MODEL(OCTEON_CN50XX))
 470         arch_ports = 1;
 471     else if (OCTEON_IS_MODEL(OCTEON_CN31XX))
 472         arch_ports = 1;
 473     else if (OCTEON_IS_MODEL(OCTEON_CN30XX))
 474         arch_ports = 1;
 475     else
 476         arch_ports = 0;
 477
 478     return __cvmx_helper_board_usb_get_num_ports(arch_ports);
 479 }
 480 #ifdef CVMX_BUILD_FOR_LINUX_KERNEL
 481 EXPORT_SYMBOL(cvmx_usb_get_num_ports);
 482 #endif
 483
 484
 485 /**
 486  * @INTERNAL
 487  * Allocate a usb transaction for use
 488  *
 489  * @param usb    USB device state populated by
 490  *               cvmx_usb_initialize().
 491  *
 492  * @return Transaction or NULL
 493  */
 494 static inline cvmx_usb_transaction_t *__cvmx_usb_alloc_transaction(cvmx_usb_internal_state_t *usb)
 495 {
 496     cvmx_usb_transaction_t *t;
 497     t = usb->free_transaction_head;
 498     if (t)
 499     {
 500         usb->free_transaction_head = t->next;
 501         if (!usb->free_transaction_head)
 502             usb->free_transaction_tail = NULL;
 503     }
 504     else if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_INFO))
 505         cvmx_dprintf("%s: Failed to allocate a transaction\n", __FUNCTION__);
 506     if (t)
 507     {
 508         memset(t, 0, sizeof(*t));
 509         t->flags = __CVMX_USB_TRANSACTION_FLAGS_IN_USE;
 510     }
 511     return t;
 512 }
 513
 514
 515 /**
 516  * @INTERNAL
 517  * Free a usb transaction
 518  *
 519  * @param usb    USB device state populated by
 520  *               cvmx_usb_initialize().
 521  * @param transaction
 522  *               Transaction to free
 523  */
 524 static inline void __cvmx_usb_free_transaction(cvmx_usb_internal_state_t *usb,
 525                                         cvmx_usb_transaction_t *transaction)
 526 {
 527     transaction->flags = 0;
 528     transaction->prev = NULL;
 529     transaction->next = NULL;
 530     if (usb->free_transaction_tail)
 531         usb->free_transaction_tail->next = transaction;
 532     else
 533         usb->free_transaction_head = transaction;
 534     usb->free_transaction_tail = transaction;
 535 }
 536
 537
 538 /**
 539  * @INTERNAL
 540  * Add a pipe to the tail of a list
 541  * @param list   List to add pipe to
 542  * @param pipe   Pipe to add
 543  */
 544 static inline void __cvmx_usb_append_pipe(cvmx_usb_pipe_list_t *list, cvmx_usb_pipe_t *pipe)
 545 {
 546     pipe->next = NULL;
 547     pipe->prev = list->tail;
 548     if (list->tail)
 549         list->tail->next = pipe;
 550     else
 551         list->head = pipe;
 552     list->tail = pipe;
 553 }
 554
 555
 556 /**
 557  * @INTERNAL
 558  * Remove a pipe from a list
 559  * @param list   List to remove pipe from
 560  * @param pipe   Pipe to remove
 561  */
 562 static inline void __cvmx_usb_remove_pipe(cvmx_usb_pipe_list_t *list, cvmx_usb_pipe_t *pipe)
 563 {
 564     if (list->head == pipe)
 565     {
 566         list->head = pipe->next;
 567         pipe->next = NULL;
 568         if (list->head)
 569             list->head->prev = NULL;
 570         else
 571             list->tail = NULL;
 572     }
 573     else if (list->tail == pipe)
 574     {
 575         list->tail = pipe->prev;
 576         list->tail->next = NULL;
 577         pipe->prev = NULL;
 578     }
 579     else
 580     {
 581         pipe->prev->next = pipe->next;
 582         pipe->next->prev = pipe->prev;
 583         pipe->prev = NULL;
 584         pipe->next = NULL;
 585     }
 586 }
 587
 588
 589 /**
 590  * Initialize a USB port for use. This must be called before any
 591  * other access to the Octeon USB port is made. The port starts
 592  * off in the disabled state.
 593  *
 594  * @param state  Pointer to an empty cvmx_usb_state_t structure
 595  *               that will be populated by the initialize call.
 596  *               This structure is then passed to all other USB
 597  *               functions.
 598  * @param usb_port_number
 599  *               Which Octeon USB port to initialize.
 600  * @param flags  Flags to control hardware initialization. See
 601  *               cvmx_usb_initialize_flags_t for the flag
 602  *               definitions. Some flags are mandatory.
 603  *
 604  * @return CVMX_USB_SUCCESS or a negative error code defined in
 605  *         cvmx_usb_status_t.
 606  */
 607 cvmx_usb_status_t cvmx_usb_initialize(cvmx_usb_state_t *state,
 608                                       int usb_port_number,
 609                                       cvmx_usb_initialize_flags_t flags)
 610 {
 611     cvmx_usbnx_clk_ctl_t usbn_clk_ctl;
 612     cvmx_usbnx_usbp_ctl_status_t usbn_usbp_ctl_status;
 613     cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
 614
 615     usb->init_flags = flags;
 616     CVMX_USB_LOG_CALLED();
 617     CVMX_USB_LOG_PARAM("%p", state);
 618     CVMX_USB_LOG_PARAM("%d", usb_port_number);
 619     CVMX_USB_LOG_PARAM("0x%x", flags);
 620
 621     /* Make sure that state is large enough to store the internal state */
 622     if (sizeof(*state) < sizeof(*usb))
 623         CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
 624     /* At first allow 0-1 for the usb port number */
 625     if ((usb_port_number < 0) || (usb_port_number > 1))
 626         CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
 627     /* For all chips except 52XX there is only one port */
 628     if (!OCTEON_IS_MODEL(OCTEON_CN52XX) && (usb_port_number > 0))
 629         CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
 630     /* Try to determine clock type automatically */
 631     if ((flags & (CVMX_USB_INITIALIZE_FLAGS_CLOCK_XO_XI |
 632                   CVMX_USB_INITIALIZE_FLAGS_CLOCK_XO_GND)) == 0)
 633     {
 634         if (__cvmx_helper_board_usb_get_clock_type() == USB_CLOCK_TYPE_CRYSTAL_12)
 635             flags |= CVMX_USB_INITIALIZE_FLAGS_CLOCK_XO_XI;  /* Only 12 MHZ crystals are supported */
 636         else
 637             flags |= CVMX_USB_INITIALIZE_FLAGS_CLOCK_XO_GND;
 638     }
 639
 640     if (flags & CVMX_USB_INITIALIZE_FLAGS_CLOCK_XO_GND)
 641     {
 642         /* Check for auto ref clock frequency */
 643         if (!(flags & CVMX_USB_INITIALIZE_FLAGS_CLOCK_MHZ_MASK))
 644             switch (__cvmx_helper_board_usb_get_clock_type())
 645             {
 646                 case USB_CLOCK_TYPE_REF_12:
 647                     flags |= CVMX_USB_INITIALIZE_FLAGS_CLOCK_12MHZ;
 648                     break;
 649                 case USB_CLOCK_TYPE_REF_24:
 650                     flags |= CVMX_USB_INITIALIZE_FLAGS_CLOCK_24MHZ;
 651                     break;
 652                 case USB_CLOCK_TYPE_REF_48:
 653                     flags |= CVMX_USB_INITIALIZE_FLAGS_CLOCK_48MHZ;
 654                     break;
 655                 default:
 656                     CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
 657                     break;
 658             }
 659     }
 660
 661     memset(usb, 0, sizeof(*usb));
 662     usb->init_flags = flags;
 663
 664     /* Initialize the USB state structure */
 665     {
 666         int i;
 667         usb->index = usb_port_number;
 668
 669         /* Initialize the transaction double linked list */
 670         usb->free_transaction_head = NULL;
 671         usb->free_transaction_tail = NULL;
 672         for (i=0; i<MAX_TRANSACTIONS; i++)
 673             __cvmx_usb_free_transaction(usb, usb->transaction + i);
 674         for (i=0; i<MAX_PIPES; i++)
 675             __cvmx_usb_append_pipe(&usb->free_pipes, usb->pipe + i);
 676     }
 677
 678     /* Power On Reset and PHY Initialization */
 679
 680     /* 1. Wait for DCOK to assert (nothing to do) */
 681     /* 2a. Write USBN0/1_CLK_CTL[POR] = 1 and
 682         USBN0/1_CLK_CTL[HRST,PRST,HCLK_RST] = 0 */
 683     usbn_clk_ctl.u64 = __cvmx_usb_read_csr64(usb, CVMX_USBNX_CLK_CTL(usb->index));
 684     usbn_clk_ctl.s.por = 1;
 685     usbn_clk_ctl.s.hrst = 0;
 686     usbn_clk_ctl.s.prst = 0;
 687     usbn_clk_ctl.s.hclk_rst = 0;
 688     usbn_clk_ctl.s.enable = 0;
 689     /* 2b. Select the USB reference clock/crystal parameters by writing
 690         appropriate values to USBN0/1_CLK_CTL[P_C_SEL, P_RTYPE, P_COM_ON] */
 691     if (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_CLOCK_XO_GND)
 692     {
 693         /* The USB port uses 12/24/48MHz 2.5V board clock
 694             source at USB_XO. USB_XI should be tied to GND.
 695             Most Octeon evaluation boards require this setting */
 696         if (OCTEON_IS_MODEL(OCTEON_CN3XXX))
 697         {
 698             usbn_clk_ctl.cn31xx.p_rclk  = 1; /* From CN31XX,CN30XX manual */
 699             usbn_clk_ctl.cn31xx.p_xenbn = 0;
 700         }
 701         else if (OCTEON_IS_MODEL(OCTEON_CN56XX) || OCTEON_IS_MODEL(OCTEON_CN50XX))
 702             usbn_clk_ctl.cn56xx.p_rtype = 2; /* From CN56XX,CN50XX manual */
 703         else
 704             usbn_clk_ctl.cn52xx.p_rtype = 1; /* From CN52XX manual */
 705
 706         switch (flags & CVMX_USB_INITIALIZE_FLAGS_CLOCK_MHZ_MASK)
 707         {
 708             case CVMX_USB_INITIALIZE_FLAGS_CLOCK_12MHZ:
 709                 usbn_clk_ctl.s.p_c_sel = 0;
 710                 break;
 711             case CVMX_USB_INITIALIZE_FLAGS_CLOCK_24MHZ:
 712                 usbn_clk_ctl.s.p_c_sel = 1;
 713                 break;
 714             case CVMX_USB_INITIALIZE_FLAGS_CLOCK_48MHZ:
 715                 usbn_clk_ctl.s.p_c_sel = 2;
 716                 break;
 717         }
 718     }
 719     else
 720     {
 721         /* The USB port uses a 12MHz crystal as clock source
 722             at USB_XO and USB_XI */
 723         if (OCTEON_IS_MODEL(OCTEON_CN3XXX))
 724         {
 725             usbn_clk_ctl.cn31xx.p_rclk  = 1; /* From CN31XX,CN30XX manual */
 726             usbn_clk_ctl.cn31xx.p_xenbn = 1;
 727         }
 728         else if (OCTEON_IS_MODEL(OCTEON_CN56XX) || OCTEON_IS_MODEL(OCTEON_CN50XX))
 729             usbn_clk_ctl.cn56xx.p_rtype = 0; /* From CN56XX,CN50XX manual */
 730         else
 731             usbn_clk_ctl.cn52xx.p_rtype = 0; /* From CN52XX manual */
 732
 733         usbn_clk_ctl.s.p_c_sel = 0;
 734     }
 735     /* 2c. Select the HCLK via writing USBN0/1_CLK_CTL[DIVIDE, DIVIDE2] and
 736         setting USBN0/1_CLK_CTL[ENABLE] = 1.  Divide the core clock down such
 737         that USB is as close as possible to 125Mhz */
 738     {
 739         int divisor = (cvmx_clock_get_rate(CVMX_CLOCK_CORE)+125000000-1)/125000000;
 740         if (divisor < 4)  /* Lower than 4 doesn't seem to work properly */
 741             divisor = 4;
 742         usbn_clk_ctl.s.divide = divisor;
 743         usbn_clk_ctl.s.divide2 = 0;
 744     }
 745     __cvmx_usb_write_csr64(usb, CVMX_USBNX_CLK_CTL(usb->index),
 746                            usbn_clk_ctl.u64);
 747     /* 2d. Write USBN0/1_CLK_CTL[HCLK_RST] = 1 */
 748     usbn_clk_ctl.s.hclk_rst = 1;
 749     __cvmx_usb_write_csr64(usb, CVMX_USBNX_CLK_CTL(usb->index),
 750                            usbn_clk_ctl.u64);
 751     /* 2e.  Wait 64 core-clock cycles for HCLK to stabilize */
 752     cvmx_wait(64);
 753     /* 3. Program the power-on reset field in the USBN clock-control register:
 754         USBN_CLK_CTL[POR] = 0 */
 755     usbn_clk_ctl.s.por = 0;
 756     __cvmx_usb_write_csr64(usb, CVMX_USBNX_CLK_CTL(usb->index),
 757                            usbn_clk_ctl.u64);
 758     /* 4. Wait 1 ms for PHY clock to start */
 759     cvmx_wait_usec(1000);
 760     /* 5. Program the Reset input from automatic test equipment field in the
 761         USBP control and status register: USBN_USBP_CTL_STATUS[ATE_RESET] = 1 */
 762     usbn_usbp_ctl_status.u64 = __cvmx_usb_read_csr64(usb, CVMX_USBNX_USBP_CTL_STATUS(usb->index));
 763     usbn_usbp_ctl_status.s.ate_reset = 1;
 764     __cvmx_usb_write_csr64(usb, CVMX_USBNX_USBP_CTL_STATUS(usb->index),
 765                            usbn_usbp_ctl_status.u64);
 766     /* 6. Wait 10 cycles */
 767     cvmx_wait(10);
 768     /* 7. Clear ATE_RESET field in the USBN clock-control register:
 769         USBN_USBP_CTL_STATUS[ATE_RESET] = 0 */
 770     usbn_usbp_ctl_status.s.ate_reset = 0;
 771     __cvmx_usb_write_csr64(usb, CVMX_USBNX_USBP_CTL_STATUS(usb->index),
 772                            usbn_usbp_ctl_status.u64);
 773     /* 8. Program the PHY reset field in the USBN clock-control register:
 774         USBN_CLK_CTL[PRST] = 1 */
 775     usbn_clk_ctl.s.prst = 1;
 776     __cvmx_usb_write_csr64(usb, CVMX_USBNX_CLK_CTL(usb->index),
 777                            usbn_clk_ctl.u64);
 778     /* 9. Program the USBP control and status register to select host or
 779         device mode. USBN_USBP_CTL_STATUS[HST_MODE] = 0 for host, = 1 for
 780         device */
 781     usbn_usbp_ctl_status.s.hst_mode = 0;
 782     __cvmx_usb_write_csr64(usb, CVMX_USBNX_USBP_CTL_STATUS(usb->index),
 783                            usbn_usbp_ctl_status.u64);
 784     /* 10. Wait 1 µs */
 785     cvmx_wait_usec(1);
 786     /* 11. Program the hreset_n field in the USBN clock-control register:
 787         USBN_CLK_CTL[HRST] = 1 */
 788     usbn_clk_ctl.s.hrst = 1;
 789     __cvmx_usb_write_csr64(usb, CVMX_USBNX_CLK_CTL(usb->index),
 790                            usbn_clk_ctl.u64);
 791     /* 12. Proceed to USB core initialization */
 792     usbn_clk_ctl.s.enable = 1;
 793     __cvmx_usb_write_csr64(usb, CVMX_USBNX_CLK_CTL(usb->index),
 794                            usbn_clk_ctl.u64);
 795     cvmx_wait_usec(1);
 796
 797     /* USB Core Initialization */
 798
 799     /* 1. Read USBC_GHWCFG1, USBC_GHWCFG2, USBC_GHWCFG3, USBC_GHWCFG4 to
 800         determine USB core configuration parameters. */
 801     /* Nothing needed */
 802     /* 2. Program the following fields in the global AHB configuration
 803         register (USBC_GAHBCFG)
 804         DMA mode, USBC_GAHBCFG[DMAEn]: 1 = DMA mode, 0 = slave mode
 805         Burst length, USBC_GAHBCFG[HBSTLEN] = 0
 806         Nonperiodic TxFIFO empty level (slave mode only),
 807         USBC_GAHBCFG[NPTXFEMPLVL]
 808         Periodic TxFIFO empty level (slave mode only),
 809         USBC_GAHBCFG[PTXFEMPLVL]
 810         Global interrupt mask, USBC_GAHBCFG[GLBLINTRMSK] = 1 */
 811     {
 812         cvmx_usbcx_gahbcfg_t usbcx_gahbcfg;
 813         /* Due to an errata, CN31XX doesn't support DMA */
 814         if (OCTEON_IS_MODEL(OCTEON_CN31XX))
 815             usb->init_flags |= CVMX_USB_INITIALIZE_FLAGS_NO_DMA;
 816         usbcx_gahbcfg.u32 = 0;
 817         usbcx_gahbcfg.s.dmaen = !(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_NO_DMA);
 818         if (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_NO_DMA)
 819             usb->idle_hardware_channels = 0x1;  /* Only use one channel with non DMA */
 820         else if (OCTEON_IS_MODEL(OCTEON_CN5XXX))
 821             usb->idle_hardware_channels = 0xf7; /* CN5XXX have an errata with channel 3 */
 822         else
 823             usb->idle_hardware_channels = 0xff;
 824         usbcx_gahbcfg.s.hbstlen = 0;
 825         usbcx_gahbcfg.s.nptxfemplvl = 1;
 826         usbcx_gahbcfg.s.ptxfemplvl = 1;
 827         usbcx_gahbcfg.s.glblintrmsk = 1;
 828         __cvmx_usb_write_csr32(usb, CVMX_USBCX_GAHBCFG(usb->index),
 829                                usbcx_gahbcfg.u32);
 830     }
 831     /* 3. Program the following fields in USBC_GUSBCFG register.
 832         HS/FS timeout calibration, USBC_GUSBCFG[TOUTCAL] = 0
 833         ULPI DDR select, USBC_GUSBCFG[DDRSEL] = 0
 834         USB turnaround time, USBC_GUSBCFG[USBTRDTIM] = 0x5
 835         PHY low-power clock select, USBC_GUSBCFG[PHYLPWRCLKSEL] = 0 */
 836     {
 837         cvmx_usbcx_gusbcfg_t usbcx_gusbcfg;
 838         usbcx_gusbcfg.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_GUSBCFG(usb->index));
 839         usbcx_gusbcfg.s.toutcal = 0;
 840         usbcx_gusbcfg.s.ddrsel = 0;
 841         usbcx_gusbcfg.s.usbtrdtim = 0x5;
 842         usbcx_gusbcfg.s.phylpwrclksel = 0;
 843         __cvmx_usb_write_csr32(usb, CVMX_USBCX_GUSBCFG(usb->index),
 844                                usbcx_gusbcfg.u32);
 845     }
 846     /* 4. The software must unmask the following bits in the USBC_GINTMSK
 847         register.
 848         OTG interrupt mask, USBC_GINTMSK[OTGINTMSK] = 1
 849         Mode mismatch interrupt mask, USBC_GINTMSK[MODEMISMSK] = 1 */
 850     {
 851         cvmx_usbcx_gintmsk_t usbcx_gintmsk;
 852         int channel;
 853
 854         usbcx_gintmsk.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_GINTMSK(usb->index));
 855         usbcx_gintmsk.s.otgintmsk = 1;
 856         usbcx_gintmsk.s.modemismsk = 1;
 857         usbcx_gintmsk.s.hchintmsk = 1;
 858         usbcx_gintmsk.s.sofmsk = 0;
 859         /* We need RX FIFO interrupts if we don't have DMA */
 860         if (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_NO_DMA)
 861             usbcx_gintmsk.s.rxflvlmsk = 1;
 862         __cvmx_usb_write_csr32(usb, CVMX_USBCX_GINTMSK(usb->index),
 863                                usbcx_gintmsk.u32);
 864
 865         /* Disable all channel interrupts. We'll enable them per channel later */
 866         for (channel=0; channel<8; channel++)
 867             __cvmx_usb_write_csr32(usb, CVMX_USBCX_HCINTMSKX(channel, usb->index), 0);
 868     }
 869
 870     {
 871         /* Host Port Initialization */
 872         if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_INFO))
 873             cvmx_dprintf("%s: USB%d is in host mode\n", __FUNCTION__, usb->index);
 874
 875         /* 1. Program the host-port interrupt-mask field to unmask,
 876             USBC_GINTMSK[PRTINT] = 1 */
 877         USB_SET_FIELD32(CVMX_USBCX_GINTMSK(usb->index), cvmx_usbcx_gintmsk_t,
 878                         prtintmsk, 1);
 879         USB_SET_FIELD32(CVMX_USBCX_GINTMSK(usb->index), cvmx_usbcx_gintmsk_t,
 880                         disconnintmsk, 1);
 881         /* 2. Program the USBC_HCFG register to select full-speed host or
 882             high-speed host. */
 883         {
 884             cvmx_usbcx_hcfg_t usbcx_hcfg;
 885             usbcx_hcfg.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HCFG(usb->index));
 886             usbcx_hcfg.s.fslssupp = 0;
 887             usbcx_hcfg.s.fslspclksel = 0;
 888             __cvmx_usb_write_csr32(usb, CVMX_USBCX_HCFG(usb->index), usbcx_hcfg.u32);
 889         }
 890         /* 3. Program the port power bit to drive VBUS on the USB,
 891             USBC_HPRT[PRTPWR] = 1 */
 892         USB_SET_FIELD32(CVMX_USBCX_HPRT(usb->index), cvmx_usbcx_hprt_t, prtpwr, 1);
 893
 894         /* Steps 4-15 from the manual are done later in the port enable */
 895     }
 896
 897 #ifdef __CVMX_ERROR_H__
 898     cvmx_error_enable_group(CVMX_ERROR_GROUP_USB, usb->index);
 899 #endif
 900     CVMX_USB_RETURN(CVMX_USB_SUCCESS);
 901 }
 902 #ifdef CVMX_BUILD_FOR_LINUX_KERNEL
 903 EXPORT_SYMBOL(cvmx_usb_initialize);
 904 #endif
 905
 906
 907 /**
 908  * Shutdown a USB port after a call to cvmx_usb_initialize().
 909  * The port should be disabled with all pipes closed when this
 910  * function is called.
 911  *
 912  * @param state  USB device state populated by
 913  *               cvmx_usb_initialize().
 914  *
 915  * @return CVMX_USB_SUCCESS or a negative error code defined in
 916  *         cvmx_usb_status_t.
 917  */
 918 cvmx_usb_status_t cvmx_usb_shutdown(cvmx_usb_state_t *state)
 919 {
 920     cvmx_usbnx_clk_ctl_t usbn_clk_ctl;
 921     cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
 922
 923     CVMX_USB_LOG_CALLED();
 924     CVMX_USB_LOG_PARAM("%p", state);
 925
 926     /* Make sure all pipes are closed */
 927     if (usb->idle_pipes.head ||
 928         usb->active_pipes[CVMX_USB_TRANSFER_ISOCHRONOUS].head ||
 929         usb->active_pipes[CVMX_USB_TRANSFER_INTERRUPT].head ||
 930         usb->active_pipes[CVMX_USB_TRANSFER_CONTROL].head ||
 931         usb->active_pipes[CVMX_USB_TRANSFER_BULK].head)
 932         CVMX_USB_RETURN(CVMX_USB_BUSY);
 933
 934 #ifdef __CVMX_ERROR_H__
 935     cvmx_error_disable_group(CVMX_ERROR_GROUP_USB, usb->index);
 936 #endif
 937
 938     /* Disable the clocks and put them in power on reset */
 939     usbn_clk_ctl.u64 = __cvmx_usb_read_csr64(usb, CVMX_USBNX_CLK_CTL(usb->index));
 940     usbn_clk_ctl.s.enable = 1;
 941     usbn_clk_ctl.s.por = 1;
 942     usbn_clk_ctl.s.hclk_rst = 1;
 943     usbn_clk_ctl.s.prst = 0;
 944     usbn_clk_ctl.s.hrst = 0;
 945     __cvmx_usb_write_csr64(usb, CVMX_USBNX_CLK_CTL(usb->index),
 946                            usbn_clk_ctl.u64);
 947     CVMX_USB_RETURN(CVMX_USB_SUCCESS);
 948 }
 949 #ifdef CVMX_BUILD_FOR_LINUX_KERNEL
 950 EXPORT_SYMBOL(cvmx_usb_shutdown);
 951 #endif
 952
 953
 954 /**
 955  * Enable a USB port. After this call succeeds, the USB port is
 956  * online and servicing requests.
 957  *
 958  * @param state  USB device state populated by
 959  *               cvmx_usb_initialize().
 960  *
 961  * @return CVMX_USB_SUCCESS or a negative error code defined in
 962  *         cvmx_usb_status_t.
 963  */
 964 cvmx_usb_status_t cvmx_usb_enable(cvmx_usb_state_t *state)
 965 {
 966     cvmx_usbcx_ghwcfg3_t usbcx_ghwcfg3;
 967     cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
 968
 969     CVMX_USB_LOG_CALLED();
 970     CVMX_USB_LOG_PARAM("%p", state);
 971
 972     usb->usbcx_hprt.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HPRT(usb->index));
 973
 974     /* If the port is already enabled the just return. We don't need to do
 975         anything */
 976     if (usb->usbcx_hprt.s.prtena)
 977         CVMX_USB_RETURN(CVMX_USB_SUCCESS);
 978
 979     /* If there is nothing plugged into the port then fail immediately */
 980     if (!usb->usbcx_hprt.s.prtconnsts)
 981     {
 982         if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_INFO))
 983             cvmx_dprintf("%s: USB%d Nothing plugged into the port\n", __FUNCTION__, usb->index);
 984         CVMX_USB_RETURN(CVMX_USB_TIMEOUT);
 985     }
 986
 987     /* Program the port reset bit to start the reset process */
 988     USB_SET_FIELD32(CVMX_USBCX_HPRT(usb->index), cvmx_usbcx_hprt_t, prtrst, 1);
 989
 990     /* Wait at least 50ms (high speed), or 10ms (full speed) for the reset
 991         process to complete. */
 992     cvmx_wait_usec(50000);
 993
 994     /* Program the port reset bit to 0, USBC_HPRT[PRTRST] = 0 */
 995     USB_SET_FIELD32(CVMX_USBCX_HPRT(usb->index), cvmx_usbcx_hprt_t, prtrst, 0);
 996
 997     /* Wait for the USBC_HPRT[PRTENA]. */
 998     if (CVMX_WAIT_FOR_FIELD32(CVMX_USBCX_HPRT(usb->index), cvmx_usbcx_hprt_t,
 999                               prtena, ==, 1, 100000))
1000     {
1001         if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_INFO))
1002             cvmx_dprintf("%s: Timeout waiting for the port to finish reset\n",
1003                          __FUNCTION__);
1004         CVMX_USB_RETURN(CVMX_USB_TIMEOUT);
1005     }
1006
1007     /* Read the port speed field to get the enumerated speed, USBC_HPRT[PRTSPD]. */
1008     usb->usbcx_hprt.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HPRT(usb->index));
1009     if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_INFO))
1010         cvmx_dprintf("%s: USB%d is in %s speed mode\n", __FUNCTION__, usb->index,
1011                      (usb->usbcx_hprt.s.prtspd == CVMX_USB_SPEED_HIGH) ? "high" :
1012                      (usb->usbcx_hprt.s.prtspd == CVMX_USB_SPEED_FULL) ? "full" :
1013                      "low");
1014
1015     usbcx_ghwcfg3.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_GHWCFG3(usb->index));
1016
1017     /* 13. Program the USBC_GRXFSIZ register to select the size of the receive
1018         FIFO (25%). */
1019     USB_SET_FIELD32(CVMX_USBCX_GRXFSIZ(usb->index), cvmx_usbcx_grxfsiz_t,
1020                     rxfdep, usbcx_ghwcfg3.s.dfifodepth / 4);
1021     /* 14. Program the USBC_GNPTXFSIZ register to select the size and the
1022         start address of the non- periodic transmit FIFO for nonperiodic
1023         transactions (50%). */
1024     {
1025         cvmx_usbcx_gnptxfsiz_t siz;
1026         siz.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_GNPTXFSIZ(usb->index));
1027         siz.s.nptxfdep = usbcx_ghwcfg3.s.dfifodepth / 2;
1028         siz.s.nptxfstaddr = usbcx_ghwcfg3.s.dfifodepth / 4;
1029         __cvmx_usb_write_csr32(usb, CVMX_USBCX_GNPTXFSIZ(usb->index), siz.u32);
1030     }
1031     /* 15. Program the USBC_HPTXFSIZ register to select the size and start
1032         address of the periodic transmit FIFO for periodic transactions (25%). */
1033     {
1034         cvmx_usbcx_hptxfsiz_t siz;
1035         siz.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HPTXFSIZ(usb->index));
1036         siz.s.ptxfsize = usbcx_ghwcfg3.s.dfifodepth / 4;
1037         siz.s.ptxfstaddr = 3 * usbcx_ghwcfg3.s.dfifodepth / 4;
1038         __cvmx_usb_write_csr32(usb, CVMX_USBCX_HPTXFSIZ(usb->index), siz.u32);
1039     }
1040     /* Flush all FIFOs */
1041     USB_SET_FIELD32(CVMX_USBCX_GRSTCTL(usb->index), cvmx_usbcx_grstctl_t, txfnum, 0x10);
1042     USB_SET_FIELD32(CVMX_USBCX_GRSTCTL(usb->index), cvmx_usbcx_grstctl_t, txfflsh, 1);
1043     CVMX_WAIT_FOR_FIELD32(CVMX_USBCX_GRSTCTL(usb->index), cvmx_usbcx_grstctl_t,
1044                           txfflsh, ==, 0, 100);
1045     USB_SET_FIELD32(CVMX_USBCX_GRSTCTL(usb->index), cvmx_usbcx_grstctl_t, rxfflsh, 1);
1046     CVMX_WAIT_FOR_FIELD32(CVMX_USBCX_GRSTCTL(usb->index), cvmx_usbcx_grstctl_t,
1047                           rxfflsh, ==, 0, 100);
1048
1049     CVMX_USB_RETURN(CVMX_USB_SUCCESS);
1050 }
1051 #ifdef CVMX_BUILD_FOR_LINUX_KERNEL
1052 EXPORT_SYMBOL(cvmx_usb_enable);
1053 #endif
1054
1055
1056 /**
1057  * Disable a USB port. After this call the USB port will not
1058  * generate data transfers and will not generate events.
1059  * Transactions in process will fail and call their
1060  * associated callbacks.
1061  *
1062  * @param state  USB device state populated by
1063  *               cvmx_usb_initialize().
1064  *
1065  * @return CVMX_USB_SUCCESS or a negative error code defined in
1066  *         cvmx_usb_status_t.
1067  */
1068 cvmx_usb_status_t cvmx_usb_disable(cvmx_usb_state_t *state)
1069 {
1070     cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
1071
1072     CVMX_USB_LOG_CALLED();
1073     CVMX_USB_LOG_PARAM("%p", state);
1074
1075     /* Disable the port */
1076     USB_SET_FIELD32(CVMX_USBCX_HPRT(usb->index), cvmx_usbcx_hprt_t, prtena, 1);
1077     CVMX_USB_RETURN(CVMX_USB_SUCCESS);
1078 }
1079 #ifdef CVMX_BUILD_FOR_LINUX_KERNEL
1080 EXPORT_SYMBOL(cvmx_usb_disable);
1081 #endif
1082
1083
1084 /**
1085  * Get the current state of the USB port. Use this call to
1086  * determine if the usb port has anything connected, is enabled,
1087  * or has some sort of error condition. The return value of this
1088  * call has "changed" bits to signal of the value of some fields
1089  * have changed between calls. These "changed" fields are based
1090  * on the last call to cvmx_usb_set_status(). In order to clear
1091  * them, you must update the status through cvmx_usb_set_status().
1092  *
1093  * @param state  USB device state populated by
1094  *               cvmx_usb_initialize().
1095  *
1096  * @return Port status information
1097  */
1098 cvmx_usb_port_status_t cvmx_usb_get_status(cvmx_usb_state_t *state)
1099 {
1100     cvmx_usbcx_hprt_t usbc_hprt;
1101     cvmx_usb_port_status_t result;
1102     cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
1103
1104     memset(&result, 0, sizeof(result));
1105
1106     CVMX_USB_LOG_CALLED();
1107     CVMX_USB_LOG_PARAM("%p", state);
1108
1109     usbc_hprt.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HPRT(usb->index));
1110     result.port_enabled = usbc_hprt.s.prtena;
1111     result.port_over_current = usbc_hprt.s.prtovrcurract;
1112     result.port_powered = usbc_hprt.s.prtpwr;
1113     result.port_speed = usbc_hprt.s.prtspd;
1114     result.connected = usbc_hprt.s.prtconnsts;
1115     result.connect_change = (result.connected != usb->port_status.connected);
1116
1117     if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_CALLS))
1118         cvmx_dprintf("%*s%s: returned port enabled=%d, over_current=%d, powered=%d, speed=%d, connected=%d, connect_change=%d\n",
1119                      2*(--usb->indent), "", __FUNCTION__,
1120                      result.port_enabled,
1121                      result.port_over_current,
1122                      result.port_powered,
1123                      result.port_speed,
1124                      result.connected,
1125                      result.connect_change);
1126     return result;
1127 }
1128 #ifdef CVMX_BUILD_FOR_LINUX_KERNEL
1129 EXPORT_SYMBOL(cvmx_usb_get_status);
1130 #endif
1131
1132
1133 /**
1134  * Set the current state of the USB port. The status is used as
1135  * a reference for the "changed" bits returned by
1136  * cvmx_usb_get_status(). Other than serving as a reference, the
1137  * status passed to this function is not used. No fields can be
1138  * changed through this call.
1139  *
1140  * @param state  USB device state populated by
1141  *               cvmx_usb_initialize().
1142  * @param port_status
1143  *               Port status to set, most like returned by cvmx_usb_get_status()
1144  */
1145 void cvmx_usb_set_status(cvmx_usb_state_t *state, cvmx_usb_port_status_t port_status)
1146 {
1147     cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
1148     CVMX_USB_LOG_CALLED();
1149     CVMX_USB_LOG_PARAM("%p", state);
1150     usb->port_status = port_status;
1151     CVMX_USB_RETURN_NOTHING();
1152 }
1153 #ifdef CVMX_BUILD_FOR_LINUX_KERNEL
1154 EXPORT_SYMBOL(cvmx_usb_set_status);
1155 #endif
1156
1157
1158 /**
1159  * @INTERNAL
1160  * Convert a USB transaction into a handle
1161  *
1162  * @param usb    USB device state populated by
1163  *               cvmx_usb_initialize().
1164  * @param transaction
1165  *               Transaction to get handle for
1166  *
1167  * @return Handle
1168  */
1169 static inline int __cvmx_usb_get_submit_handle(cvmx_usb_internal_state_t *usb,
1170                                         cvmx_usb_transaction_t *transaction)
1171 {
1172     return ((unsigned long)transaction - (unsigned long)usb->transaction) /
1173             sizeof(*transaction);
1174 }
1175
1176
1177 /**
1178  * @INTERNAL
1179  * Convert a USB pipe into a handle
1180  *
1181  * @param usb    USB device state populated by
1182  *               cvmx_usb_initialize().
1183  * @param pipe   Pipe to get handle for
1184  *
1185  * @return Handle
1186  */
1187 static inline int __cvmx_usb_get_pipe_handle(cvmx_usb_internal_state_t *usb,
1188                                         cvmx_usb_pipe_t *pipe)
1189 {
1190     return ((unsigned long)pipe - (unsigned long)usb->pipe) / sizeof(*pipe);
1191 }
1192
1193
1194 /**
1195  * Open a virtual pipe between the host and a USB device. A pipe
1196  * must be opened before data can be transferred between a device
1197  * and Octeon.
1198  *
1199  * @param state      USB device state populated by
1200  *                   cvmx_usb_initialize().
1201  * @param flags      Optional pipe flags defined in
1202  *                   cvmx_usb_pipe_flags_t.
1203  * @param device_addr
1204  *                   USB device address to open the pipe to
1205  *                   (0-127).
1206  * @param endpoint_num
1207  *                   USB endpoint number to open the pipe to
1208  *                   (0-15).
1209  * @param device_speed
1210  *                   The speed of the device the pipe is going
1211  *                   to. This must match the device's speed,
1212  *                   which may be different than the port speed.
1213  * @param max_packet The maximum packet length the device can
1214  *                   transmit/receive (low speed=0-8, full
1215  *                   speed=0-1023, high speed=0-1024). This value
1216  *                   comes from the standard endpoint descriptor
1217  *                   field wMaxPacketSize bits <10:0>.
1218  * @param transfer_type
1219  *                   The type of transfer this pipe is for.
1220  * @param transfer_dir
1221  *                   The direction the pipe is in. This is not
1222  *                   used for control pipes.
1223  * @param interval   For ISOCHRONOUS and INTERRUPT transfers,
1224  *                   this is how often the transfer is scheduled
1225  *                   for. All other transfers should specify
1226  *                   zero. The units are in frames (8000/sec at
1227  *                   high speed, 1000/sec for full speed).
1228  * @param multi_count
1229  *                   For high speed devices, this is the maximum
1230  *                   allowed number of packet per microframe.
1231  *                   Specify zero for non high speed devices. This
1232  *                   value comes from the standard endpoint descriptor
1233  *                   field wMaxPacketSize bits <12:11>.
1234  * @param hub_device_addr
1235  *                   Hub device address this device is connected
1236  *                   to. Devices connected directly to Octeon
1237  *                   use zero. This is only used when the device
1238  *                   is full/low speed behind a high speed hub.
1239  *                   The address will be of the high speed hub,
1240  *                   not and full speed hubs after it.
1241  * @param hub_port   Which port on the hub the device is
1242  *                   connected. Use zero for devices connected
1243  *                   directly to Octeon. Like hub_device_addr,
1244  *                   this is only used for full/low speed
1245  *                   devices behind a high speed hub.
1246  *
1247  * @return A non negative value is a pipe handle. Negative
1248  *         values are failure codes from cvmx_usb_status_t.
1249  */
1250 int cvmx_usb_open_pipe(cvmx_usb_state_t *state, cvmx_usb_pipe_flags_t flags,
1251                        int device_addr, int endpoint_num,
1252                        cvmx_usb_speed_t device_speed, int max_packet,
1253                        cvmx_usb_transfer_t transfer_type,
1254                        cvmx_usb_direction_t transfer_dir, int interval,
1255                        int multi_count, int hub_device_addr, int hub_port)
1256 {
1257     cvmx_usb_pipe_t *pipe;
1258     cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
1259
1260     CVMX_USB_LOG_CALLED();
1261     CVMX_USB_LOG_PARAM("%p", state);
1262     CVMX_USB_LOG_PARAM("0x%x", flags);
1263     CVMX_USB_LOG_PARAM("%d", device_addr);
1264     CVMX_USB_LOG_PARAM("%d", endpoint_num);
1265     CVMX_USB_LOG_PARAM("%d", device_speed);
1266     CVMX_USB_LOG_PARAM("%d", max_packet);
1267     CVMX_USB_LOG_PARAM("%d", transfer_type);
1268     CVMX_USB_LOG_PARAM("%d", transfer_dir);
1269     CVMX_USB_LOG_PARAM("%d", interval);
1270     CVMX_USB_LOG_PARAM("%d", multi_count);
1271     CVMX_USB_LOG_PARAM("%d", hub_device_addr);
1272     CVMX_USB_LOG_PARAM("%d", hub_port);
1273
1274     if (cvmx_unlikely((device_addr < 0) || (device_addr > MAX_USB_ADDRESS)))
1275         CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
1276     if (cvmx_unlikely((endpoint_num < 0) || (endpoint_num > MAX_USB_ENDPOINT)))
1277         CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
1278     if (cvmx_unlikely(device_speed > CVMX_USB_SPEED_LOW))
1279         CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
1280     if (cvmx_unlikely((max_packet <= 0) || (max_packet > 1024)))
1281         CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
1282     if (cvmx_unlikely(transfer_type > CVMX_USB_TRANSFER_INTERRUPT))
1283         CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
1284     if (cvmx_unlikely((transfer_dir != CVMX_USB_DIRECTION_OUT) &&
1285         (transfer_dir != CVMX_USB_DIRECTION_IN)))
1286         CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
1287     if (cvmx_unlikely(interval < 0))
1288         CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
1289     if (cvmx_unlikely((transfer_type == CVMX_USB_TRANSFER_CONTROL) && interval))
1290         CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
1291     if (cvmx_unlikely(multi_count < 0))
1292         CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
1293     if (cvmx_unlikely((device_speed != CVMX_USB_SPEED_HIGH) &&
1294         (multi_count != 0)))
1295         CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
1296     if (cvmx_unlikely((hub_device_addr < 0) || (hub_device_addr > MAX_USB_ADDRESS)))
1297         CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
1298     if (cvmx_unlikely((hub_port < 0) || (hub_port > MAX_USB_HUB_PORT)))
1299         CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
1300
1301     /* Find a free pipe */
1302     pipe = usb->free_pipes.head;
1303     if (!pipe)
1304         CVMX_USB_RETURN(CVMX_USB_NO_MEMORY);
1305     __cvmx_usb_remove_pipe(&usb->free_pipes, pipe);
1306     pipe->flags = flags | __CVMX_USB_PIPE_FLAGS_OPEN;
1307     if ((device_speed == CVMX_USB_SPEED_HIGH) &&
1308         (transfer_dir == CVMX_USB_DIRECTION_OUT) &&
1309         (transfer_type == CVMX_USB_TRANSFER_BULK))
1310         pipe->flags |= __CVMX_USB_PIPE_FLAGS_NEED_PING;
1311     pipe->device_addr = device_addr;
1312     pipe->endpoint_num = endpoint_num;
1313     pipe->device_speed = device_speed;
1314     pipe->max_packet = max_packet;
1315     pipe->transfer_type = transfer_type;
1316     pipe->transfer_dir = transfer_dir;
1317     /* All pipes use interval to rate limit NAK processing. Force an interval
1318         if one wasn't supplied */
1319     if (!interval)
1320         interval = 1;
1321     if (__cvmx_usb_pipe_needs_split(usb, pipe))
1322     {
1323         pipe->interval = interval*8;
1324         /* Force start splits to be schedule on uFrame 0 */
1325         pipe->next_tx_frame = ((usb->frame_number+7)&~7) + pipe->interval;
1326     }
1327     else
1328     {
1329         pipe->interval = interval;
1330         pipe->next_tx_frame = usb->frame_number + pipe->interval;
1331     }
1332     pipe->multi_count = multi_count;
1333     pipe->hub_device_addr = hub_device_addr;
1334     pipe->hub_port = hub_port;
1335     pipe->pid_toggle = 0;
1336     pipe->split_sc_frame = -1;
1337     __cvmx_usb_append_pipe(&usb->idle_pipes, pipe);
1338
1339     /* We don't need to tell the hardware about this pipe yet since
1340         it doesn't have any submitted requests */
1341
1342     CVMX_USB_RETURN(__cvmx_usb_get_pipe_handle(usb, pipe));
1343 }
1344 #ifdef CVMX_BUILD_FOR_LINUX_KERNEL
1345 EXPORT_SYMBOL(cvmx_usb_open_pipe);
1346 #endif
1347
1348
1349 /**
1350  * @INTERNAL
1351  * Poll the RX FIFOs and remove data as needed. This function is only used
1352  * in non DMA mode. It is very important that this function be called quickly
1353  * enough to prevent FIFO overflow.
1354  *
1355  * @param usb     USB device state populated by
1356  *                cvmx_usb_initialize().
1357  */
1358 static void __cvmx_usb_poll_rx_fifo(cvmx_usb_internal_state_t *usb)
1359 {
1360     cvmx_usbcx_grxstsph_t rx_status;
1361     int channel;
1362     int bytes;
1363     uint64_t address;
1364     uint32_t *ptr;
1365
1366     CVMX_USB_LOG_CALLED();
1367     CVMX_USB_LOG_PARAM("%p", usb);
1368
1369     rx_status.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_GRXSTSPH(usb->index));
1370     /* Only read data if IN data is there */
1371     if (rx_status.s.pktsts != 2)
1372         CVMX_USB_RETURN_NOTHING();
1373     /* Check if no data is available */
1374     if (!rx_status.s.bcnt)
1375         CVMX_USB_RETURN_NOTHING();
1376
1377     channel = rx_status.s.chnum;
1378     bytes = rx_status.s.bcnt;
1379     if (!bytes)
1380         CVMX_USB_RETURN_NOTHING();
1381
1382     /* Get where the DMA engine would have written this data */
1383     address = __cvmx_usb_read_csr64(usb, CVMX_USBNX_DMA0_INB_CHN0(usb->index) + channel*8);
1384     ptr = cvmx_phys_to_ptr(address);
1385     __cvmx_usb_write_csr64(usb, CVMX_USBNX_DMA0_INB_CHN0(usb->index) + channel*8, address + bytes);
1386
1387     /* Loop writing the FIFO data for this packet into memory */
1388     while (bytes > 0)
1389     {
1390         *ptr++ = __cvmx_usb_read_csr32(usb, USB_FIFO_ADDRESS(channel, usb->index));
1391         bytes -= 4;
1392     }
1393     CVMX_SYNCW;
1394
1395     CVMX_USB_RETURN_NOTHING();
1396 }
1397
1398
1399 /**
1400  * Fill the TX hardware fifo with data out of the software
1401  * fifos
1402  *
1403  * @param usb       USB device state populated by
1404  *                  cvmx_usb_initialize().
1405  * @param fifo      Software fifo to use
1406  * @param available Amount of space in the hardware fifo
1407  *
1408  * @return Non zero if the hardware fifo was too small and needs
1409  *         to be serviced again.
1410  */
1411 static int __cvmx_usb_fill_tx_hw(cvmx_usb_internal_state_t *usb, cvmx_usb_tx_fifo_t *fifo, int available)
1412 {
1413     CVMX_USB_LOG_CALLED();
1414     CVMX_USB_LOG_PARAM("%p", usb);
1415     CVMX_USB_LOG_PARAM("%p", fifo);
1416     CVMX_USB_LOG_PARAM("%d", available);
1417
1418     /* We're done either when there isn't anymore space or the software FIFO
1419         is empty */
1420     while (available && (fifo->head != fifo->tail))
1421     {
1422         int i = fifo->tail;
1423         const uint32_t *ptr = cvmx_phys_to_ptr(fifo->entry[i].address);
1424         uint64_t csr_address = USB_FIFO_ADDRESS(fifo->entry[i].channel, usb->index) ^ 4;
1425         int words = available;
1426
1427         /* Limit the amount of data to waht the SW fifo has */
1428         if (fifo->entry[i].size <= available)
1429         {
1430             words = fifo->entry[i].size;
1431             fifo->tail++;
1432             if (fifo->tail > MAX_CHANNELS)
1433                 fifo->tail = 0;
1434         }
1435
1436         /* Update the next locations and counts */
1437         available -= words;
1438         fifo->entry[i].address += words * 4;
1439         fifo->entry[i].size -= words;
1440
1441         /* Write the HW fifo data. The read every three writes is due
1442             to an errata on CN3XXX chips */
1443         while (words > 3)
1444         {
1445             cvmx_write64_uint32(csr_address, *ptr++);
1446             cvmx_write64_uint32(csr_address, *ptr++);
1447             cvmx_write64_uint32(csr_address, *ptr++);
1448             cvmx_read64_uint64(CVMX_USBNX_DMA0_INB_CHN0(usb->index));
1449             words -= 3;
1450         }
1451         cvmx_write64_uint32(csr_address, *ptr++);
1452         if (--words)
1453         {
1454             cvmx_write64_uint32(csr_address, *ptr++);
1455             if (--words)
1456                 cvmx_write64_uint32(csr_address, *ptr++);
1457         }
1458         cvmx_read64_uint64(CVMX_USBNX_DMA0_INB_CHN0(usb->index));
1459     }
1460     CVMX_USB_RETURN(fifo->head != fifo->tail);
1461 }
1462
1463
1464 /**
1465  * Check the hardware FIFOs and fill them as needed
1466  *
1467  * @param usb    USB device state populated by
1468  *               cvmx_usb_initialize().
1469  */
1470 static void __cvmx_usb_poll_tx_fifo(cvmx_usb_internal_state_t *usb)
1471 {
1472     CVMX_USB_LOG_CALLED();
1473     CVMX_USB_LOG_PARAM("%p", usb);
1474
1475     if (usb->periodic.head != usb->periodic.tail)
1476     {
1477         cvmx_usbcx_hptxsts_t tx_status;
1478         tx_status.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HPTXSTS(usb->index));
1479         if (__cvmx_usb_fill_tx_hw(usb, &usb->periodic, tx_status.s.ptxfspcavail))
1480             USB_SET_FIELD32(CVMX_USBCX_GINTMSK(usb->index), cvmx_usbcx_gintmsk_t, ptxfempmsk, 1);
1481         else
1482             USB_SET_FIELD32(CVMX_USBCX_GINTMSK(usb->index), cvmx_usbcx_gintmsk_t, ptxfempmsk, 0);
1483     }
1484
1485     if (usb->nonperiodic.head != usb->nonperiodic.tail)
1486     {
1487         cvmx_usbcx_gnptxsts_t tx_status;
1488         tx_status.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_GNPTXSTS(usb->index));
1489         if (__cvmx_usb_fill_tx_hw(usb, &usb->nonperiodic, tx_status.s.nptxfspcavail))
1490             USB_SET_FIELD32(CVMX_USBCX_GINTMSK(usb->index), cvmx_usbcx_gintmsk_t, nptxfempmsk, 1);
1491         else
1492             USB_SET_FIELD32(CVMX_USBCX_GINTMSK(usb->index), cvmx_usbcx_gintmsk_t, nptxfempmsk, 0);
1493     }
1494
1495     CVMX_USB_RETURN_NOTHING();
1496 }
1497
1498
1499 /**
1500  * @INTERNAL
1501  * Fill the TX FIFO with an outgoing packet
1502  *
1503  * @param usb     USB device state populated by
1504  *                cvmx_usb_initialize().
1505  * @param channel Channel number to get packet from
1506  */
1507 static void __cvmx_usb_fill_tx_fifo(cvmx_usb_internal_state_t *usb, int channel)
1508 {
1509     cvmx_usbcx_hccharx_t hcchar;
1510     cvmx_usbcx_hcspltx_t usbc_hcsplt;
1511     cvmx_usbcx_hctsizx_t usbc_hctsiz;
1512     cvmx_usb_tx_fifo_t *fifo;
1513
1514     CVMX_USB_LOG_CALLED();
1515     CVMX_USB_LOG_PARAM("%p", usb);
1516     CVMX_USB_LOG_PARAM("%d", channel);
1517
1518     /* We only need to fill data on outbound channels */
1519     hcchar.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HCCHARX(channel, usb->index));
1520     if (hcchar.s.epdir != CVMX_USB_DIRECTION_OUT)
1521         CVMX_USB_RETURN_NOTHING();
1522
1523     /* OUT Splits only have data on the start and not the complete */
1524     usbc_hcsplt.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HCSPLTX(channel, usb->index));
1525     if (usbc_hcsplt.s.spltena && usbc_hcsplt.s.compsplt)
1526         CVMX_USB_RETURN_NOTHING();
1527
1528     /* Find out how many bytes we need to fill and convert it into 32bit words */
1529     usbc_hctsiz.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HCTSIZX(channel, usb->index));
1530     if (!usbc_hctsiz.s.xfersize)
1531         CVMX_USB_RETURN_NOTHING();
1532
1533     if ((hcchar.s.eptype == CVMX_USB_TRANSFER_INTERRUPT) ||
1534         (hcchar.s.eptype == CVMX_USB_TRANSFER_ISOCHRONOUS))
1535         fifo = &usb->periodic;
1536     else
1537         fifo = &usb->nonperiodic;
1538
1539     fifo->entry[fifo->head].channel = channel;
1540     fifo->entry[fifo->head].address = __cvmx_usb_read_csr64(usb, CVMX_USBNX_DMA0_OUTB_CHN0(usb->index) + channel*8);
1541     fifo->entry[fifo->head].size = (usbc_hctsiz.s.xfersize+3)>>2;
1542     fifo->head++;
1543     if (fifo->head > MAX_CHANNELS)
1544         fifo->head = 0;
1545
1546     __cvmx_usb_poll_tx_fifo(usb);
1547
1548     CVMX_USB_RETURN_NOTHING();
1549 }
1550
1551 /**
1552  * @INTERNAL
1553  * Perform channel specific setup for Control transactions. All
1554  * the generic stuff will already have been done in
1555  * __cvmx_usb_start_channel()
1556  *
1557  * @param usb     USB device state populated by
1558  *                cvmx_usb_initialize().
1559  * @param channel Channel to setup
1560  * @param pipe    Pipe for control transaction
1561  */
1562 static void __cvmx_usb_start_channel_control(cvmx_usb_internal_state_t *usb,
1563                                              int channel,
1564                                              cvmx_usb_pipe_t *pipe)
1565 {
1566     cvmx_usb_transaction_t *transaction = pipe->head;
1567     cvmx_usb_control_header_t *header = cvmx_phys_to_ptr(transaction->control_header);
1568     int bytes_to_transfer = transaction->buffer_length - transaction->actual_bytes;
1569     int packets_to_transfer;
1570     cvmx_usbcx_hctsizx_t usbc_hctsiz;
1571
1572     CVMX_USB_LOG_CALLED();
1573     CVMX_USB_LOG_PARAM("%p", usb);
1574     CVMX_USB_LOG_PARAM("%d", channel);
1575     CVMX_USB_LOG_PARAM("%p", pipe);
1576
1577     usbc_hctsiz.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HCTSIZX(channel, usb->index));
1578
1579     switch (transaction->stage)
1580     {
1581         case CVMX_USB_STAGE_NON_CONTROL:
1582         case CVMX_USB_STAGE_NON_CONTROL_SPLIT_COMPLETE:
1583             cvmx_dprintf("%s: ERROR - Non control stage\n", __FUNCTION__);
1584             break;
1585         case CVMX_USB_STAGE_SETUP:
1586             usbc_hctsiz.s.pid = 3; /* Setup */
1587             bytes_to_transfer = sizeof(*header);
1588             /* All Control operations start with a setup going OUT */
1589             USB_SET_FIELD32(CVMX_USBCX_HCCHARX(channel, usb->index), cvmx_usbcx_hccharx_t, epdir, CVMX_USB_DIRECTION_OUT);
1590             /* Setup send the control header instead of the buffer data. The
1591                 buffer data will be used in the next stage */
1592             __cvmx_usb_write_csr64(usb, CVMX_USBNX_DMA0_OUTB_CHN0(usb->index) + channel*8, transaction->control_header);
1593             break;
1594         case CVMX_USB_STAGE_SETUP_SPLIT_COMPLETE:
1595             usbc_hctsiz.s.pid = 3; /* Setup */
1596             bytes_to_transfer = 0;
1597             /* All Control operations start with a setup going OUT */
1598             USB_SET_FIELD32(CVMX_USBCX_HCCHARX(channel, usb->index), cvmx_usbcx_hccharx_t, epdir, CVMX_USB_DIRECTION_OUT);
1599             USB_SET_FIELD32(CVMX_USBCX_HCSPLTX(channel, usb->index), cvmx_usbcx_hcspltx_t, compsplt, 1);
1600             break;
1601         case CVMX_USB_STAGE_DATA:
1602             usbc_hctsiz.s.pid = __cvmx_usb_get_data_pid(pipe);
1603             if (__cvmx_usb_pipe_needs_split(usb, pipe))
1604             {
1605                 if (header->s.request_type & 0x80)
1606                     bytes_to_transfer = 0;
1607                 else if (bytes_to_transfer > pipe->max_packet)
1608                     bytes_to_transfer = pipe->max_packet;
1609             }
1610             USB_SET_FIELD32(CVMX_USBCX_HCCHARX(channel, usb->index),
1611                             cvmx_usbcx_hccharx_t, epdir,
1612                             ((header->s.request_type & 0x80) ?
1613                              CVMX_USB_DIRECTION_IN :
1614                              CVMX_USB_DIRECTION_OUT));
1615             break;
1616         case CVMX_USB_STAGE_DATA_SPLIT_COMPLETE:
1617             usbc_hctsiz.s.pid = __cvmx_usb_get_data_pid(pipe);
1618             if (!(header->s.request_type & 0x80))
1619                 bytes_to_transfer = 0;
1620             USB_SET_FIELD32(CVMX_USBCX_HCCHARX(channel, usb->index),
1621                             cvmx_usbcx_hccharx_t, epdir,
1622                             ((header->s.request_type & 0x80) ?
1623                              CVMX_USB_DIRECTION_IN :
1624                              CVMX_USB_DIRECTION_OUT));
1625             USB_SET_FIELD32(CVMX_USBCX_HCSPLTX(channel, usb->index), cvmx_usbcx_hcspltx_t, compsplt, 1);
1626             break;
1627         case CVMX_USB_STAGE_STATUS:
1628             usbc_hctsiz.s.pid = __cvmx_usb_get_data_pid(pipe);
1629             bytes_to_transfer = 0;
1630             USB_SET_FIELD32(CVMX_USBCX_HCCHARX(channel, usb->index), cvmx_usbcx_hccharx_t, epdir,
1631                             ((header->s.request_type & 0x80) ?
1632                              CVMX_USB_DIRECTION_OUT :
1633                              CVMX_USB_DIRECTION_IN));
1634             break;
1635         case CVMX_USB_STAGE_STATUS_SPLIT_COMPLETE:
1636             usbc_hctsiz.s.pid = __cvmx_usb_get_data_pid(pipe);
1637             bytes_to_transfer = 0;
1638             USB_SET_FIELD32(CVMX_USBCX_HCCHARX(channel, usb->index), cvmx_usbcx_hccharx_t, epdir,
1639                             ((header->s.request_type & 0x80) ?
1640                              CVMX_USB_DIRECTION_OUT :
1641                              CVMX_USB_DIRECTION_IN));
1642             USB_SET_FIELD32(CVMX_USBCX_HCSPLTX(channel, usb->index), cvmx_usbcx_hcspltx_t, compsplt, 1);
1643             break;
1644     }
1645
1646     /* Make sure the transfer never exceeds the byte limit of the hardware.
1647         Further bytes will be sent as continued transactions */
1648     if (bytes_to_transfer > MAX_TRANSFER_BYTES)
1649     {
1650         /* Round MAX_TRANSFER_BYTES to a multiple of out packet size */
1651         bytes_to_transfer = MAX_TRANSFER_BYTES / pipe->max_packet;
1652         bytes_to_transfer *= pipe->max_packet;
1653     }
1654
1655     /* Calculate the number of packets to transfer. If the length is zero
1656         we still need to transfer one packet */
1657     packets_to_transfer = (bytes_to_transfer + pipe->max_packet - 1) / pipe->max_packet;
1658     if (packets_to_transfer == 0)
1659         packets_to_transfer = 1;
1660     else if ((packets_to_transfer>1) && (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_NO_DMA))
1661     {
1662         /* Limit to one packet when not using DMA. Channels must be restarted
1663             between every packet for IN transactions, so there is no reason to
1664             do multiple packets in a row */
1665         packets_to_transfer = 1;
1666         bytes_to_transfer = packets_to_transfer * pipe->max_packet;
1667     }
1668     else if (packets_to_transfer > MAX_TRANSFER_PACKETS)
1669     {
1670         /* Limit the number of packet and data transferred to what the
1671             hardware can handle */
1672         packets_to_transfer = MAX_TRANSFER_PACKETS;
1673         bytes_to_transfer = packets_to_transfer * pipe->max_packet;
1674     }
1675
1676     usbc_hctsiz.s.xfersize = bytes_to_transfer;
1677     usbc_hctsiz.s.pktcnt = packets_to_transfer;
1678
1679     __cvmx_usb_write_csr32(usb, CVMX_USBCX_HCTSIZX(channel, usb->index), usbc_hctsiz.u32);
1680     CVMX_USB_RETURN_NOTHING();
1681 }
1682
1683
1684 /**
1685  * @INTERNAL
1686  * Start a channel to perform the pipe's head transaction
1687  *
1688  * @param usb     USB device state populated by
1689  *                cvmx_usb_initialize().
1690  * @param channel Channel to setup
1691  * @param pipe    Pipe to start
1692  */
1693 static void __cvmx_usb_start_channel(cvmx_usb_internal_state_t *usb,
1694                                      int channel,
1695                                      cvmx_usb_pipe_t *pipe)
1696 {
1697     cvmx_usb_transaction_t *transaction = pipe->head;
1698
1699     CVMX_USB_LOG_CALLED();
1700     CVMX_USB_LOG_PARAM("%p", usb);
1701     CVMX_USB_LOG_PARAM("%d", channel);
1702     CVMX_USB_LOG_PARAM("%p", pipe);
1703
1704     if (cvmx_unlikely((usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_TRANSFERS) ||
1705         (pipe->flags & CVMX_USB_PIPE_FLAGS_DEBUG_TRANSFERS)))
1706         cvmx_dprintf("%s: Channel %d started. Pipe %d transaction %d stage %d\n",
1707                      __FUNCTION__, channel, __cvmx_usb_get_pipe_handle(usb, pipe),
1708                      __cvmx_usb_get_submit_handle(usb, transaction),
1709                      transaction->stage);
1710
1711     /* Make sure all writes to the DMA region get flushed */
1712     CVMX_SYNCW;
1713
1714     /* Attach the channel to the pipe */
1715     usb->pipe_for_channel[channel] = pipe;
1716     pipe->channel = channel;
1717     pipe->flags |= __CVMX_USB_PIPE_FLAGS_SCHEDULED;
1718
1719     /* Mark this channel as in use */
1720     usb->idle_hardware_channels &= ~(1<<channel);
1721
1722     /* Enable the channel interrupt bits */
1723     {
1724         cvmx_usbcx_hcintx_t usbc_hcint;
1725         cvmx_usbcx_hcintmskx_t usbc_hcintmsk;
1726         cvmx_usbcx_haintmsk_t usbc_haintmsk;
1727
1728         /* Clear all channel status bits */
1729         usbc_hcint.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HCINTX(channel, usb->index));
1730         __cvmx_usb_write_csr32(usb, CVMX_USBCX_HCINTX(channel, usb->index), usbc_hcint.u32);
1731
1732         usbc_hcintmsk.u32 = 0;
1733         usbc_hcintmsk.s.chhltdmsk = 1;
1734         if (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_NO_DMA)
1735         {
1736             /* Channels need these extra interrupts when we aren't in DMA mode */
1737             usbc_hcintmsk.s.datatglerrmsk = 1;
1738             usbc_hcintmsk.s.frmovrunmsk = 1;
1739             usbc_hcintmsk.s.bblerrmsk = 1;
1740             usbc_hcintmsk.s.xacterrmsk = 1;
1741             if (__cvmx_usb_pipe_needs_split(usb, pipe))
1742             {
1743                 /* Splits don't generate xfercompl, so we need ACK and NYET */
1744                 usbc_hcintmsk.s.nyetmsk = 1;
1745                 usbc_hcintmsk.s.ackmsk = 1;
1746             }
1747             usbc_hcintmsk.s.nakmsk = 1;
1748             usbc_hcintmsk.s.stallmsk = 1;
1749             usbc_hcintmsk.s.xfercomplmsk = 1;
1750         }
1751         __cvmx_usb_write_csr32(usb, CVMX_USBCX_HCINTMSKX(channel, usb->index), usbc_hcintmsk.u32);
1752
1753         /* Enable the channel interrupt to propagate */
1754         usbc_haintmsk.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HAINTMSK(usb->index));
1755         usbc_haintmsk.s.haintmsk |= 1<<channel;
1756         __cvmx_usb_write_csr32(usb, CVMX_USBCX_HAINTMSK(usb->index), usbc_haintmsk.u32);
1757     }
1758
1759     /* Setup the locations the DMA engines use  */
1760     {
1761         uint64_t dma_address = transaction->buffer + transaction->actual_bytes;
1762         if (transaction->type == CVMX_USB_TRANSFER_ISOCHRONOUS)
1763             dma_address = transaction->buffer + transaction->iso_packets[0].offset + transaction->actual_bytes;
1764         __cvmx_usb_write_csr64(usb, CVMX_USBNX_DMA0_OUTB_CHN0(usb->index) + channel*8, dma_address);
1765         __cvmx_usb_write_csr64(usb, CVMX_USBNX_DMA0_INB_CHN0(usb->index) + channel*8, dma_address);
1766     }
1767
1768     /* Setup both the size of the transfer and the SPLIT characteristics */
1769     {
1770         cvmx_usbcx_hcspltx_t usbc_hcsplt = {.u32 = 0};
1771         cvmx_usbcx_hctsizx_t usbc_hctsiz = {.u32 = 0};
1772         int packets_to_transfer;
1773         int bytes_to_transfer = transaction->buffer_length - transaction->actual_bytes;
1774
1775         /* ISOCHRONOUS transactions store each individual transfer size in the
1776             packet structure, not the global buffer_length */
1777         if (transaction->type == CVMX_USB_TRANSFER_ISOCHRONOUS)
1778             bytes_to_transfer = transaction->iso_packets[0].length - transaction->actual_bytes;
1779
1780         /* We need to do split transactions when we are talking to non high
1781             speed devices that are behind a high speed hub */
1782         if (__cvmx_usb_pipe_needs_split(usb, pipe))
1783         {
1784             /* On the start split phase (stage is even) record the frame number we
1785                 will need to send the split complete. We only store the lower two bits
1786                 since the time ahead can only be two frames */
1787             if ((transaction->stage&1) == 0)
1788             {
1789                 if (transaction->type == CVMX_USB_TRANSFER_BULK)
1790                     pipe->split_sc_frame = (usb->frame_number + 1) & 0x7f;
1791                 else
1792                     pipe->split_sc_frame = (usb->frame_number + 2) & 0x7f;
1793             }
1794             else
1795                 pipe->split_sc_frame = -1;
1796
1797             usbc_hcsplt.s.spltena = 1;
1798             usbc_hcsplt.s.hubaddr = pipe->hub_device_addr;
1799             usbc_hcsplt.s.prtaddr = pipe->hub_port;
1800             usbc_hcsplt.s.compsplt = (transaction->stage == CVMX_USB_STAGE_NON_CONTROL_SPLIT_COMPLETE);
1801
1802             /* SPLIT transactions can only ever transmit one data packet so
1803                 limit the transfer size to the max packet size */
1804             if (bytes_to_transfer > pipe->max_packet)
1805                 bytes_to_transfer = pipe->max_packet;
1806
1807             /* ISOCHRONOUS OUT splits are unique in that they limit
1808                 data transfers to 188 byte chunks representing the
1809                 begin/middle/end of the data or all */
1810             if (!usbc_hcsplt.s.compsplt &&
1811                 (pipe->transfer_dir == CVMX_USB_DIRECTION_OUT) &&
1812                 (pipe->transfer_type == CVMX_USB_TRANSFER_ISOCHRONOUS))
1813             {
1814                 /* Clear the split complete frame number as there isn't going
1815                     to be a split complete */
1816                 pipe->split_sc_frame = -1;
1817                 /* See if we've started this transfer and sent data */
1818                 if (transaction->actual_bytes == 0)
1819                 {
1820                     /* Nothing sent yet, this is either a begin or the
1821                         entire payload */
1822                     if (bytes_to_transfer <= 188)
1823                         usbc_hcsplt.s.xactpos = 3; /* Entire payload in one go */
1824                     else
1825                         usbc_hcsplt.s.xactpos = 2; /* First part of payload */
1826                 }
1827                 else
1828                 {
1829                     /* Continuing the previous data, we must either be
1830                         in the middle or at the end */
1831                     if (bytes_to_transfer <= 188)
1832                         usbc_hcsplt.s.xactpos = 1; /* End of payload */
1833                     else
1834                         usbc_hcsplt.s.xactpos = 0; /* Middle of payload */
1835                 }
1836                 /* Again, the transfer size is limited to 188 bytes */
1837                 if (bytes_to_transfer > 188)
1838                     bytes_to_transfer = 188;
1839             }
1840         }
1841
1842         /* Make sure the transfer never exceeds the byte limit of the hardware.
1843             Further bytes will be sent as continued transactions */
1844         if (bytes_to_transfer > MAX_TRANSFER_BYTES)
1845         {
1846             /* Round MAX_TRANSFER_BYTES to a multiple of out packet size */
1847             bytes_to_transfer = MAX_TRANSFER_BYTES / pipe->max_packet;
1848             bytes_to_transfer *= pipe->max_packet;
1849         }
1850
1851         /* Calculate the number of packets to transfer. If the length is zero
1852             we still need to transfer one packet */
1853         packets_to_transfer = (bytes_to_transfer + pipe->max_packet - 1) / pipe->max_packet;
1854         if (packets_to_transfer == 0)
1855             packets_to_transfer = 1;
1856         else if ((packets_to_transfer>1) && (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_NO_DMA))
1857         {
1858             /* Limit to one packet when not using DMA. Channels must be restarted
1859                 between every packet for IN transactions, so there is no reason to
1860                 do multiple packets in a row */
1861             packets_to_transfer = 1;
1862             bytes_to_transfer = packets_to_transfer * pipe->max_packet;
1863         }
1864         else if (packets_to_transfer > MAX_TRANSFER_PACKETS)
1865         {
1866             /* Limit the number of packet and data transferred to what the
1867                 hardware can handle */
1868             packets_to_transfer = MAX_TRANSFER_PACKETS;
1869             bytes_to_transfer = packets_to_transfer * pipe->max_packet;
1870         }
1871
1872         usbc_hctsiz.s.xfersize = bytes_to_transfer;
1873         usbc_hctsiz.s.pktcnt = packets_to_transfer;
1874
1875         /* Update the DATA0/DATA1 toggle */
1876         usbc_hctsiz.s.pid = __cvmx_usb_get_data_pid(pipe);
1877         /* High speed pipes may need a hardware ping before they start */
1878         if (pipe->flags & __CVMX_USB_PIPE_FLAGS_NEED_PING)
1879             usbc_hctsiz.s.dopng = 1;
1880
1881         __cvmx_usb_write_csr32(usb, CVMX_USBCX_HCSPLTX(channel, usb->index), usbc_hcsplt.u32);
1882         __cvmx_usb_write_csr32(usb, CVMX_USBCX_HCTSIZX(channel, usb->index), usbc_hctsiz.u32);
1883     }
1884
1885     /* Setup the Host Channel Characteristics Register */
1886     {
1887         cvmx_usbcx_hccharx_t usbc_hcchar = {.u32 = 0};
1888
1889         /* Set the startframe odd/even properly. This is only used for periodic */
1890         usbc_hcchar.s.oddfrm = usb->frame_number&1;
1891
1892         /* Set the number of back to back packets allowed by this endpoint.
1893             Split transactions interpret "ec" as the number of immediate
1894             retries of failure. These retries happen too quickly, so we
1895             disable these entirely for splits */
1896         if (__cvmx_usb_pipe_needs_split(usb, pipe))
1897             usbc_hcchar.s.ec = 1;
1898         else if (pipe->multi_count < 1)
1899             usbc_hcchar.s.ec = 1;
1900         else if (pipe->multi_count > 3)
1901             usbc_hcchar.s.ec = 3;
1902         else
1903             usbc_hcchar.s.ec = pipe->multi_count;
1904
1905         /* Set the rest of the endpoint specific settings */
1906         usbc_hcchar.s.devaddr = pipe->device_addr;
1907         usbc_hcchar.s.eptype = transaction->type;
1908         usbc_hcchar.s.lspddev = (pipe->device_speed == CVMX_USB_SPEED_LOW);
1909         usbc_hcchar.s.epdir = pipe->transfer_dir;
1910         usbc_hcchar.s.epnum = pipe->endpoint_num;
1911         usbc_hcchar.s.mps = pipe->max_packet;
1912         __cvmx_usb_write_csr32(usb, CVMX_USBCX_HCCHARX(channel, usb->index), usbc_hcchar.u32);
1913     }
1914
1915     /* Do transaction type specific fixups as needed */
1916     switch (transaction->type)
1917     {
1918         case CVMX_USB_TRANSFER_CONTROL:
1919             __cvmx_usb_start_channel_control(usb, channel, pipe);
1920             break;
1921         case CVMX_USB_TRANSFER_BULK:
1922         case CVMX_USB_TRANSFER_INTERRUPT:
1923             break;
1924         case CVMX_USB_TRANSFER_ISOCHRONOUS:
1925             if (!__cvmx_usb_pipe_needs_split(usb, pipe))
1926             {
1927                 /* ISO transactions require different PIDs depending on direction
1928                     and how many packets are needed */
1929                 if (pipe->transfer_dir == CVMX_USB_DIRECTION_OUT)
1930                 {
1931                     if (pipe->multi_count < 2) /* Need DATA0 */
1932                         USB_SET_FIELD32(CVMX_USBCX_HCTSIZX(channel, usb->index), cvmx_usbcx_hctsizx_t, pid, 0);
1933                     else /* Need MDATA */
1934                         USB_SET_FIELD32(CVMX_USBCX_HCTSIZX(channel, usb->index), cvmx_usbcx_hctsizx_t, pid, 3);
1935                 }
1936             }
1937             break;
1938     }
1939     {
1940         cvmx_usbcx_hctsizx_t usbc_hctsiz = {.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HCTSIZX(channel, usb->index))};
1941         transaction->xfersize = usbc_hctsiz.s.xfersize;
1942         transaction->pktcnt = usbc_hctsiz.s.pktcnt;
1943     }
1944     /* Remeber when we start a split transaction */
1945     if (__cvmx_usb_pipe_needs_split(usb, pipe))
1946         usb->active_split = transaction;
1947     USB_SET_FIELD32(CVMX_USBCX_HCCHARX(channel, usb->index), cvmx_usbcx_hccharx_t, chena, 1);
1948     if (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_NO_DMA)
1949         __cvmx_usb_fill_tx_fifo(usb, channel);
1950     CVMX_USB_RETURN_NOTHING();
1951 }
1952
1953
1954 /**
1955  * @INTERNAL
1956  * Find a pipe that is ready to be scheduled to hardware.
1957  * @param usb    USB device state populated by
1958  *               cvmx_usb_initialize().
1959  * @param list   Pipe list to search
1960  * @param current_frame
1961  *               Frame counter to use as a time reference.
1962  *
1963  * @return Pipe or NULL if none are ready
1964  */
1965 static cvmx_usb_pipe_t *__cvmx_usb_find_ready_pipe(cvmx_usb_internal_state_t *usb, cvmx_usb_pipe_list_t *list, uint64_t current_frame)
1966 {
1967     cvmx_usb_pipe_t *pipe = list->head;
1968     while (pipe)
1969     {
1970         if (!(pipe->flags & __CVMX_USB_PIPE_FLAGS_SCHEDULED) && pipe->head &&
1971             (pipe->next_tx_frame <= current_frame) &&
1972             ((pipe->split_sc_frame == -1) || ((((int)current_frame - (int)pipe->split_sc_frame) & 0x7f) < 0x40)) &&
1973             (!usb->active_split || (usb->active_split == pipe->head)))
1974         {
1975             CVMX_PREFETCH(pipe, 128);
1976             CVMX_PREFETCH(pipe->head, 0);
1977             return pipe;
1978         }
1979         pipe = pipe->next;
1980     }
1981     return NULL;
1982 }
1983
1984
1985 /**
1986  * @INTERNAL
1987  * Called whenever a pipe might need to be scheduled to the
1988  * hardware.
1989  *
1990  * @param usb    USB device state populated by
1991  *               cvmx_usb_initialize().
1992  * @param is_sof True if this schedule was called on a SOF interrupt.
1993  */
1994 static void __cvmx_usb_schedule(cvmx_usb_internal_state_t *usb, int is_sof)
1995 {
1996     int channel;
1997     cvmx_usb_pipe_t *pipe;
1998     int need_sof;
1999     cvmx_usb_transfer_t ttype;
2000
2001     CVMX_USB_LOG_CALLED();
2002     CVMX_USB_LOG_PARAM("%p", usb);
2003
2004     if (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_NO_DMA)
2005     {
2006         /* Without DMA we need to be careful to not schedule something at the end of a frame and cause an overrun */
2007         cvmx_usbcx_hfnum_t hfnum = {.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HFNUM(usb->index))};
2008         cvmx_usbcx_hfir_t hfir = {.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HFIR(usb->index))};
2009         if (hfnum.s.frrem < hfir.s.frint/4)
2010             goto done;
2011     }
2012
2013     while (usb->idle_hardware_channels)
2014     {
2015         /* Find an idle channel */
2016         CVMX_CLZ(channel, usb->idle_hardware_channels);
2017         channel = 31 - channel;
2018         if (cvmx_unlikely(channel > 7))
2019         {
2020             if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_INFO))
2021                 cvmx_dprintf("%s: Idle hardware channels has a channel higher than 7. This is wrong\n", __FUNCTION__);
2022             break;
2023         }
2024
2025         /* Find a pipe needing service */
2026         pipe = NULL;
2027         if (is_sof)
2028         {
2029             /* Only process periodic pipes on SOF interrupts. This way we are
2030                 sure that the periodic data is sent in the beginning of the
2031                 frame */
2032             pipe = __cvmx_usb_find_ready_pipe(usb, usb->active_pipes + CVMX_USB_TRANSFER_ISOCHRONOUS, usb->frame_number);
2033             if (cvmx_likely(!pipe))
2034                 pipe = __cvmx_usb_find_ready_pipe(usb, usb->active_pipes + CVMX_USB_TRANSFER_INTERRUPT, usb->frame_number);
2035         }
2036         if (cvmx_likely(!pipe))
2037         {
2038             pipe = __cvmx_usb_find_ready_pipe(usb, usb->active_pipes + CVMX_USB_TRANSFER_CONTROL, usb->frame_number);
2039             if (cvmx_likely(!pipe))
2040                 pipe = __cvmx_usb_find_ready_pipe(usb, usb->active_pipes + CVMX_USB_TRANSFER_BULK, usb->frame_number);
2041         }
2042         if (!pipe)
2043             break;
2044
2045         CVMX_USB_LOG_PARAM("%d", channel);
2046         CVMX_USB_LOG_PARAM("%p", pipe);
2047
2048         if (cvmx_unlikely((usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_TRANSFERS) ||
2049             (pipe->flags & CVMX_USB_PIPE_FLAGS_DEBUG_TRANSFERS)))
2050         {
2051             cvmx_usb_transaction_t *transaction = pipe->head;
2052             const cvmx_usb_control_header_t *header = (transaction->control_header) ? cvmx_phys_to_ptr(transaction->control_header) : NULL;
2053             const char *dir = (pipe->transfer_dir == CVMX_USB_DIRECTION_IN) ? "IN" : "OUT";
2054             const char *type;
2055             switch (pipe->transfer_type)
2056             {
2057                 case CVMX_USB_TRANSFER_CONTROL:
2058                     type = "SETUP";
2059                     dir = (header->s.request_type & 0x80) ? "IN" : "OUT";
2060                     break;
2061                 case CVMX_USB_TRANSFER_ISOCHRONOUS:
2062                     type = "ISOCHRONOUS";
2063                     break;
2064                 case CVMX_USB_TRANSFER_BULK:
2065                     type = "BULK";
2066                     break;
2067                 default: /* CVMX_USB_TRANSFER_INTERRUPT */
2068                     type = "INTERRUPT";
2069                     break;
2070             }
2071             cvmx_dprintf("%s: Starting pipe %d, transaction %d on channel %d. %s %s len=%d header=0x%llx\n",
2072                          __FUNCTION__, __cvmx_usb_get_pipe_handle(usb, pipe),
2073                          __cvmx_usb_get_submit_handle(usb, transaction),
2074                          channel, type, dir,
2075                          transaction->buffer_length,
2076                          (header) ? (unsigned long long)header->u64 : 0ull);
2077         }
2078         __cvmx_usb_start_channel(usb, channel, pipe);
2079     }
2080
2081 done:
2082     /* Only enable SOF interrupts when we have transactions pending in the
2083         future that might need to be scheduled */
2084     need_sof = 0;
2085     for (ttype=CVMX_USB_TRANSFER_CONTROL; ttype<=CVMX_USB_TRANSFER_INTERRUPT; ttype++)
2086     {
2087         pipe = usb->active_pipes[ttype].head;
2088         while (pipe)
2089         {
2090             if (pipe->next_tx_frame > usb->frame_number)
2091             {
2092                 need_sof = 1;
2093                 break;
2094             }
2095             pipe=pipe->next;
2096         }
2097     }
2098     USB_SET_FIELD32(CVMX_USBCX_GINTMSK(usb->index), cvmx_usbcx_gintmsk_t, sofmsk, need_sof);
2099     CVMX_USB_RETURN_NOTHING();
2100 }
2101
2102
2103 /**
2104  * @INTERNAL
2105  * Call a user's callback for a specific reason.
2106  *
2107  * @param usb    USB device state populated by
2108  *               cvmx_usb_initialize().
2109  * @param pipe   Pipe the callback is for or NULL
2110  * @param transaction
2111  *               Transaction the callback is for or NULL
2112  * @param reason Reason this callback is being called
2113  * @param complete_code
2114  *               Completion code for the transaction, if any
2115  */
2116 static void __cvmx_usb_perform_callback(cvmx_usb_internal_state_t *usb,
2117                                         cvmx_usb_pipe_t *pipe,
2118                                         cvmx_usb_transaction_t *transaction,
2119                                         cvmx_usb_callback_t reason,
2120                                         cvmx_usb_complete_t complete_code)
2121 {
2122     cvmx_usb_callback_func_t callback = usb->callback[reason];
2123     void *user_data = usb->callback_data[reason];
2124     int submit_handle = -1;
2125     int pipe_handle = -1;
2126     int bytes_transferred = 0;
2127
2128     if (pipe)
2129         pipe_handle = __cvmx_usb_get_pipe_handle(usb, pipe);
2130
2131     if (transaction)
2132     {
2133         submit_handle = __cvmx_usb_get_submit_handle(usb, transaction);
2134         bytes_transferred = transaction->actual_bytes;
2135         /* Transactions are allowed to override the default callback */
2136         if ((reason == CVMX_USB_CALLBACK_TRANSFER_COMPLETE) && transaction->callback)
2137         {
2138             callback = transaction->callback;
2139             user_data = transaction->callback_data;
2140         }
2141     }
2142
2143     if (!callback)
2144         return;
2145
2146     if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_CALLBACKS))
2147         cvmx_dprintf("%*s%s: calling callback %p(usb=%p, complete_code=%s, "
2148                      "pipe_handle=%d, submit_handle=%d, bytes_transferred=%d, user_data=%p);\n",
2149                      2*usb->indent, "", __FUNCTION__, callback, usb,
2150                      __cvmx_usb_complete_to_string(complete_code),
2151                      pipe_handle, submit_handle, bytes_transferred, user_data);
2152
2153     callback((cvmx_usb_state_t *)usb, reason, complete_code, pipe_handle, submit_handle,
2154              bytes_transferred, user_data);
2155
2156     if (cvmx_unlikely(usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_CALLBACKS))
2157         cvmx_dprintf("%*s%s: callback %p complete\n", 2*usb->indent, "",
2158                       __FUNCTION__, callback);
2159 }
2160
2161
2162 /**
2163  * @INTERNAL
2164  * Signal the completion of a transaction and free it. The
2165  * transaction will be removed from the pipe transaction list.
2166  *
2167  * @param usb    USB device state populated by
2168  *               cvmx_usb_initialize().
2169  * @param pipe   Pipe the transaction is on
2170  * @param transaction
2171  *               Transaction that completed
2172  * @param complete_code
2173  *               Completion code
2174  */
2175 static void __cvmx_usb_perform_complete(cvmx_usb_internal_state_t * usb,
2176                                         cvmx_usb_pipe_t *pipe,
2177                                         cvmx_usb_transaction_t *transaction,
2178                                         cvmx_usb_complete_t complete_code)
2179 {
2180     CVMX_USB_LOG_CALLED();
2181     CVMX_USB_LOG_PARAM("%p", usb);
2182     CVMX_USB_LOG_PARAM("%p", pipe);
2183     CVMX_USB_LOG_PARAM("%p", transaction);
2184     CVMX_USB_LOG_PARAM("%d", complete_code);
2185
2186     /* If this was a split then clear our split in progress marker */
2187     if (usb->active_split == transaction)
2188         usb->active_split = NULL;
2189
2190     /* Isochronous transactions need extra processing as they might not be done
2191         after a single data transfer */
2192     if (cvmx_unlikely(transaction->type == CVMX_USB_TRANSFER_ISOCHRONOUS))
2193     {
2194         /* Update the number of bytes transferred in this ISO packet */
2195         transaction->iso_packets[0].length = transaction->actual_bytes;
2196         transaction->iso_packets[0].status = complete_code;
2197
2198         /* If there are more ISOs pending and we succeeded, schedule the next
2199             one */
2200         if ((transaction->iso_number_packets > 1) && (complete_code == CVMX_USB_COMPLETE_SUCCESS))
2201         {
2202             transaction->actual_bytes = 0;      /* No bytes transferred for this packet as of yet */
2203             transaction->iso_number_packets--;  /* One less ISO waiting to transfer */
2204             transaction->iso_packets++;         /* Increment to the next location in our packet array */
2205             transaction->stage = CVMX_USB_STAGE_NON_CONTROL;
2206             goto done;
2207         }
2208     }
2209
2210     /* Remove the transaction from the pipe list */
2211     if (transaction->next)
2212         transaction->next->prev = transaction->prev;
2213     else
2214         pipe->tail = transaction->prev;
2215     if (transaction->prev)
2216         transaction->prev->next = transaction->next;
2217     else
2218         pipe->head = transaction->next;
2219     if (!pipe->head)
2220     {
2221         __cvmx_usb_remove_pipe(usb->active_pipes + pipe->transfer_type, pipe);
2222         __cvmx_usb_append_pipe(&usb->idle_pipes, pipe);
2223
2224     }
2225     __cvmx_usb_perform_callback(usb, pipe, transaction,
2226                                 CVMX_USB_CALLBACK_TRANSFER_COMPLETE,
2227                                 complete_code);
2228     __cvmx_usb_free_transaction(usb, transaction);
2229 done:
2230     CVMX_USB_RETURN_NOTHING();
2231 }
2232
2233
2234 /**
2235  * @INTERNAL
2236  * Submit a usb transaction to a pipe. Called for all types
2237  * of transactions.
2238  *
2239  * @param usb
2240  * @param pipe_handle
2241  *                  Which pipe to submit to. Will be validated in this function.
2242  * @param type      Transaction type
2243  * @param flags     Flags for the transaction
2244  * @param buffer    User buffer for the transaction
2245  * @param buffer_length
2246  *                  User buffer's length in bytes
2247  * @param control_header
2248  *                  For control transactions, the 8 byte standard header
2249  * @param iso_start_frame
2250  *                  For ISO transactions, the start frame
2251  * @param iso_number_packets
2252  *                  For ISO, the number of packet in the transaction.
2253  * @param iso_packets
2254  *                  A description of each ISO packet
2255  * @param callback  User callback to call when the transaction completes
2256  * @param user_data User's data for the callback
2257  *
2258  * @return Submit handle or negative on failure. Matches the result
2259  *         in the external API.
2260  */
2261 static int __cvmx_usb_submit_transaction(cvmx_usb_internal_state_t *usb,
2262                                          int pipe_handle,
2263                                          cvmx_usb_transfer_t type,
2264                                          int flags,
2265                                          uint64_t buffer,
2266                                          int buffer_length,
2267                                          uint64_t control_header,
2268                                          int iso_start_frame,
2269                                          int iso_number_packets,
2270                                          cvmx_usb_iso_packet_t *iso_packets,
2271                                          cvmx_usb_callback_func_t callback,
2272                                          void *user_data)
2273 {
2274     int submit_handle;
2275     cvmx_usb_transaction_t *transaction;
2276     cvmx_usb_pipe_t *pipe = usb->pipe + pipe_handle;
2277
2278     CVMX_USB_LOG_CALLED();
2279     if (cvmx_unlikely((pipe_handle < 0) || (pipe_handle >= MAX_PIPES)))
2280         CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2281     /* Fail if the pipe isn't open */
2282     if (cvmx_unlikely((pipe->flags & __CVMX_USB_PIPE_FLAGS_OPEN) == 0))
2283         CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2284     if (cvmx_unlikely(pipe->transfer_type != type))
2285         CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2286
2287     transaction = __cvmx_usb_alloc_transaction(usb);
2288     if (cvmx_unlikely(!transaction))
2289         CVMX_USB_RETURN(CVMX_USB_NO_MEMORY);
2290
2291     transaction->type = type;
2292     transaction->flags |= flags;
2293     transaction->buffer = buffer;
2294     transaction->buffer_length = buffer_length;
2295     transaction->control_header = control_header;
2296     transaction->iso_start_frame = iso_start_frame; // FIXME: This is not used, implement it
2297     transaction->iso_number_packets = iso_number_packets;
2298     transaction->iso_packets = iso_packets;
2299     transaction->callback = callback;
2300     transaction->callback_data = user_data;
2301     if (transaction->type == CVMX_USB_TRANSFER_CONTROL)
2302         transaction->stage = CVMX_USB_STAGE_SETUP;
2303     else
2304         transaction->stage = CVMX_USB_STAGE_NON_CONTROL;
2305
2306     transaction->next = NULL;
2307     if (pipe->tail)
2308     {
2309         transaction->prev = pipe->tail;
2310         transaction->prev->next = transaction;
2311     }
2312     else
2313     {
2314         if (pipe->next_tx_frame < usb->frame_number)
2315             pipe->next_tx_frame = usb->frame_number + pipe->interval -
2316                 (usb->frame_number - pipe->next_tx_frame) % pipe->interval;
2317         transaction->prev = NULL;
2318         pipe->head = transaction;
2319         __cvmx_usb_remove_pipe(&usb->idle_pipes, pipe);
2320         __cvmx_usb_append_pipe(usb->active_pipes + pipe->transfer_type, pipe);
2321     }
2322     pipe->tail = transaction;
2323
2324     submit_handle = __cvmx_usb_get_submit_handle(usb, transaction);
2325
2326     /* We may need to schedule the pipe if this was the head of the pipe */
2327     if (!transaction->prev)
2328         __cvmx_usb_schedule(usb, 0);
2329
2330     CVMX_USB_RETURN(submit_handle);
2331 }
2332
2333
2334 /**
2335  * Call to submit a USB Bulk transfer to a pipe.
2336  *
2337  * @param state     USB device state populated by
2338  *                  cvmx_usb_initialize().
2339  * @param pipe_handle
2340  *                  Handle to the pipe for the transfer.
2341  * @param buffer    Physical address of the data buffer in
2342  *                  memory. Note that this is NOT A POINTER, but
2343  *                  the full 64bit physical address of the
2344  *                  buffer. This may be zero if buffer_length is
2345  *                  zero.
2346  * @param buffer_length
2347  *                  Length of buffer in bytes.
2348  * @param callback  Function to call when this transaction
2349  *                  completes. If the return value of this
2350  *                  function isn't an error, then this function
2351  *                  is guaranteed to be called when the
2352  *                  transaction completes. If this parameter is
2353  *                  NULL, then the generic callback registered
2354  *                  through cvmx_usb_register_callback is
2355  *                  called. If both are NULL, then there is no
2356  *                  way to know when a transaction completes.
2357  * @param user_data User supplied data returned when the
2358  *                  callback is called. This is only used if
2359  *                  callback in not NULL.
2360  *
2361  * @return A submitted transaction handle or negative on
2362  *         failure. Negative values are failure codes from
2363  *         cvmx_usb_status_t.
2364  */
2365 int cvmx_usb_submit_bulk(cvmx_usb_state_t *state, int pipe_handle,
2366                                 uint64_t buffer, int buffer_length,
2367                                 cvmx_usb_callback_func_t callback,
2368                                 void *user_data)
2369 {
2370     int submit_handle;
2371     cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
2372
2373     CVMX_USB_LOG_CALLED();
2374     CVMX_USB_LOG_PARAM("%p", state);
2375     CVMX_USB_LOG_PARAM("%d", pipe_handle);
2376     CVMX_USB_LOG_PARAM("0x%llx", (unsigned long long)buffer);
2377     CVMX_USB_LOG_PARAM("%d", buffer_length);
2378
2379     /* Pipe handle checking is done later in a common place */
2380     if (cvmx_unlikely(!buffer))
2381         CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2382     if (cvmx_unlikely(buffer_length < 0))
2383         CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2384
2385     submit_handle = __cvmx_usb_submit_transaction(usb, pipe_handle,
2386                                          CVMX_USB_TRANSFER_BULK,
2387                                          0, /* flags */
2388                                          buffer,
2389                                          buffer_length,
2390                                          0, /* control_header */
2391                                          0, /* iso_start_frame */
2392                                          0, /* iso_number_packets */
2393                                          NULL, /* iso_packets */
2394                                          callback,
2395                                          user_data);
2396     CVMX_USB_RETURN(submit_handle);
2397 }
2398 #ifdef CVMX_BUILD_FOR_LINUX_KERNEL
2399 EXPORT_SYMBOL(cvmx_usb_submit_bulk);
2400 #endif
2401
2402
2403 /**
2404  * Call to submit a USB Interrupt transfer to a pipe.
2405  *
2406  * @param state     USB device state populated by
2407  *                  cvmx_usb_initialize().
2408  * @param pipe_handle
2409  *                  Handle to the pipe for the transfer.
2410  * @param buffer    Physical address of the data buffer in
2411  *                  memory. Note that this is NOT A POINTER, but
2412  *                  the full 64bit physical address of the
2413  *                  buffer. This may be zero if buffer_length is
2414  *                  zero.
2415  * @param buffer_length
2416  *                  Length of buffer in bytes.
2417  * @param callback  Function to call when this transaction
2418  *                  completes. If the return value of this
2419  *                  function isn't an error, then this function
2420  *                  is guaranteed to be called when the
2421  *                  transaction completes. If this parameter is
2422  *                  NULL, then the generic callback registered
2423  *                  through cvmx_usb_register_callback is
2424  *                  called. If both are NULL, then there is no
2425  *                  way to know when a transaction completes.
2426  * @param user_data User supplied data returned when the
2427  *                  callback is called. This is only used if
2428  *                  callback in not NULL.
2429  *
2430  * @return A submitted transaction handle or negative on
2431  *         failure. Negative values are failure codes from
2432  *         cvmx_usb_status_t.
2433  */
2434 int cvmx_usb_submit_interrupt(cvmx_usb_state_t *state, int pipe_handle,
2435                               uint64_t buffer, int buffer_length,
2436                               cvmx_usb_callback_func_t callback,
2437                               void *user_data)
2438 {
2439     int submit_handle;
2440     cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
2441
2442     CVMX_USB_LOG_CALLED();
2443     CVMX_USB_LOG_PARAM("%p", state);
2444     CVMX_USB_LOG_PARAM("%d", pipe_handle);
2445     CVMX_USB_LOG_PARAM("0x%llx", (unsigned long long)buffer);
2446     CVMX_USB_LOG_PARAM("%d", buffer_length);
2447
2448     /* Pipe handle checking is done later in a common place */
2449     if (cvmx_unlikely(!buffer))
2450         CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2451     if (cvmx_unlikely(buffer_length < 0))
2452         CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2453
2454     submit_handle = __cvmx_usb_submit_transaction(usb, pipe_handle,
2455                                          CVMX_USB_TRANSFER_INTERRUPT,
2456                                          0, /* flags */
2457                                          buffer,
2458                                          buffer_length,
2459                                          0, /* control_header */
2460                                          0, /* iso_start_frame */
2461                                          0, /* iso_number_packets */
2462                                          NULL, /* iso_packets */
2463                                          callback,
2464                                          user_data);
2465     CVMX_USB_RETURN(submit_handle);
2466 }
2467 #ifdef CVMX_BUILD_FOR_LINUX_KERNEL
2468 EXPORT_SYMBOL(cvmx_usb_submit_interrupt);
2469 #endif
2470
2471
2472 /**
2473  * Call to submit a USB Control transfer to a pipe.
2474  *
2475  * @param state     USB device state populated by
2476  *                  cvmx_usb_initialize().
2477  * @param pipe_handle
2478  *                  Handle to the pipe for the transfer.
2479  * @param control_header
2480  *                  USB 8 byte control header physical address.
2481  *                  Note that this is NOT A POINTER, but the
2482  *                  full 64bit physical address of the buffer.
2483  * @param buffer    Physical address of the data buffer in
2484  *                  memory. Note that this is NOT A POINTER, but
2485  *                  the full 64bit physical address of the
2486  *                  buffer. This may be zero if buffer_length is
2487  *                  zero.
2488  * @param buffer_length
2489  *                  Length of buffer in bytes.
2490  * @param callback  Function to call when this transaction
2491  *                  completes. If the return value of this
2492  *                  function isn't an error, then this function
2493  *                  is guaranteed to be called when the
2494  *                  transaction completes. If this parameter is
2495  *                  NULL, then the generic callback registered
2496  *                  through cvmx_usb_register_callback is
2497  *                  called. If both are NULL, then there is no
2498  *                  way to know when a transaction completes.
2499  * @param user_data User supplied data returned when the
2500  *                  callback is called. This is only used if
2501  *                  callback in not NULL.
2502  *
2503  * @return A submitted transaction handle or negative on
2504  *         failure. Negative values are failure codes from
2505  *         cvmx_usb_status_t.
2506  */
2507 int cvmx_usb_submit_control(cvmx_usb_state_t *state, int pipe_handle,
2508                             uint64_t control_header,
2509                             uint64_t buffer, int buffer_length,
2510                             cvmx_usb_callback_func_t callback,
2511                             void *user_data)
2512 {
2513     int submit_handle;
2514     cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
2515     cvmx_usb_control_header_t *header = cvmx_phys_to_ptr(control_header);
2516
2517     CVMX_USB_LOG_CALLED();
2518     CVMX_USB_LOG_PARAM("%p", state);
2519     CVMX_USB_LOG_PARAM("%d", pipe_handle);
2520     CVMX_USB_LOG_PARAM("0x%llx", (unsigned long long)control_header);
2521     CVMX_USB_LOG_PARAM("0x%llx", (unsigned long long)buffer);
2522     CVMX_USB_LOG_PARAM("%d", buffer_length);
2523
2524     /* Pipe handle checking is done later in a common place */
2525     if (cvmx_unlikely(!control_header))
2526         CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2527     /* Some drivers send a buffer with a zero length. God only knows why */
2528     if (cvmx_unlikely(buffer && (buffer_length < 0)))
2529         CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2530     if (cvmx_unlikely(!buffer && (buffer_length != 0)))
2531         CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2532     if ((header->s.request_type & 0x80) == 0)
2533         buffer_length = cvmx_le16_to_cpu(header->s.length);
2534
2535     submit_handle = __cvmx_usb_submit_transaction(usb, pipe_handle,
2536                                          CVMX_USB_TRANSFER_CONTROL,
2537                                          0, /* flags */
2538                                          buffer,
2539                                          buffer_length,
2540                                          control_header,
2541                                          0, /* iso_start_frame */
2542                                          0, /* iso_number_packets */
2543                                          NULL, /* iso_packets */
2544                                          callback,
2545                                          user_data);
2546     CVMX_USB_RETURN(submit_handle);
2547 }
2548 #ifdef CVMX_BUILD_FOR_LINUX_KERNEL
2549 EXPORT_SYMBOL(cvmx_usb_submit_control);
2550 #endif
2551
2552
2553 /**
2554  * Call to submit a USB Isochronous transfer to a pipe.
2555  *
2556  * @param state     USB device state populated by
2557  *                  cvmx_usb_initialize().
2558  * @param pipe_handle
2559  *                  Handle to the pipe for the transfer.
2560  * @param start_frame
2561  *                  Number of frames into the future to schedule
2562  *                  this transaction.
2563  * @param flags     Flags to control the transfer. See
2564  *                  cvmx_usb_isochronous_flags_t for the flag
2565  *                  definitions.
2566  * @param number_packets
2567  *                  Number of sequential packets to transfer.
2568  *                  "packets" is a pointer to an array of this
2569  *                  many packet structures.
2570  * @param packets   Description of each transfer packet as
2571  *                  defined by cvmx_usb_iso_packet_t. The array
2572  *                  pointed to here must stay valid until the
2573  *                  complete callback is called.
2574  * @param buffer    Physical address of the data buffer in
2575  *                  memory. Note that this is NOT A POINTER, but
2576  *                  the full 64bit physical address of the
2577  *                  buffer. This may be zero if buffer_length is
2578  *                  zero.
2579  * @param buffer_length
2580  *                  Length of buffer in bytes.
2581  * @param callback  Function to call when this transaction
2582  *                  completes. If the return value of this
2583  *                  function isn't an error, then this function
2584  *                  is guaranteed to be called when the
2585  *                  transaction completes. If this parameter is
2586  *                  NULL, then the generic callback registered
2587  *                  through cvmx_usb_register_callback is
2588  *                  called. If both are NULL, then there is no
2589  *                  way to know when a transaction completes.
2590  * @param user_data User supplied data returned when the
2591  *                  callback is called. This is only used if
2592  *                  callback in not NULL.
2593  *
2594  * @return A submitted transaction handle or negative on
2595  *         failure. Negative values are failure codes from
2596  *         cvmx_usb_status_t.
2597  */
2598 int cvmx_usb_submit_isochronous(cvmx_usb_state_t *state, int pipe_handle,
2599                                 int start_frame, int flags,
2600                                 int number_packets,
2601                                 cvmx_usb_iso_packet_t packets[],
2602                                 uint64_t buffer, int buffer_length,
2603                                 cvmx_usb_callback_func_t callback,
2604                                 void *user_data)
2605 {
2606     int submit_handle;
2607     cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
2608
2609     CVMX_USB_LOG_CALLED();
2610     CVMX_USB_LOG_PARAM("%p", state);
2611     CVMX_USB_LOG_PARAM("%d", pipe_handle);
2612     CVMX_USB_LOG_PARAM("%d", start_frame);
2613     CVMX_USB_LOG_PARAM("0x%x", flags);
2614     CVMX_USB_LOG_PARAM("%d", number_packets);
2615     CVMX_USB_LOG_PARAM("%p", packets);
2616     CVMX_USB_LOG_PARAM("0x%llx", (unsigned long long)buffer);
2617     CVMX_USB_LOG_PARAM("%d", buffer_length);
2618
2619     /* Pipe handle checking is done later in a common place */
2620     if (cvmx_unlikely(start_frame < 0))
2621         CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2622     if (cvmx_unlikely(flags & ~(CVMX_USB_ISOCHRONOUS_FLAGS_ALLOW_SHORT | CVMX_USB_ISOCHRONOUS_FLAGS_ASAP)))
2623         CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2624     if (cvmx_unlikely(number_packets < 1))
2625         CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2626     if (cvmx_unlikely(!packets))
2627         CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2628     if (cvmx_unlikely(!buffer))
2629         CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2630     if (cvmx_unlikely(buffer_length < 0))
2631         CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2632
2633     submit_handle = __cvmx_usb_submit_transaction(usb, pipe_handle,
2634                                          CVMX_USB_TRANSFER_ISOCHRONOUS,
2635                                          flags,
2636                                          buffer,
2637                                          buffer_length,
2638                                          0, /* control_header */
2639                                          start_frame,
2640                                          number_packets,
2641                                          packets,
2642                                          callback,
2643                                          user_data);
2644     CVMX_USB_RETURN(submit_handle);
2645 }
2646 #ifdef CVMX_BUILD_FOR_LINUX_KERNEL
2647 EXPORT_SYMBOL(cvmx_usb_submit_isochronous);
2648 #endif
2649
2650
2651 /**
2652  * Cancel one outstanding request in a pipe. Canceling a request
2653  * can fail if the transaction has already completed before cancel
2654  * is called. Even after a successful cancel call, it may take
2655  * a frame or two for the cvmx_usb_poll() function to call the
2656  * associated callback.
2657  *
2658  * @param state  USB device state populated by
2659  *               cvmx_usb_initialize().
2660  * @param pipe_handle
2661  *               Pipe handle to cancel requests in.
2662  * @param submit_handle
2663  *               Handle to transaction to cancel, returned by the submit function.
2664  *
2665  * @return CVMX_USB_SUCCESS or a negative error code defined in
2666  *         cvmx_usb_status_t.
2667  */
2668 cvmx_usb_status_t cvmx_usb_cancel(cvmx_usb_state_t *state, int pipe_handle,
2669                                   int submit_handle)
2670 {
2671     cvmx_usb_transaction_t *transaction;
2672     cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
2673     cvmx_usb_pipe_t *pipe = usb->pipe + pipe_handle;
2674
2675     CVMX_USB_LOG_CALLED();
2676     CVMX_USB_LOG_PARAM("%p", state);
2677     CVMX_USB_LOG_PARAM("%d", pipe_handle);
2678     CVMX_USB_LOG_PARAM("%d", submit_handle);
2679
2680     if (cvmx_unlikely((pipe_handle < 0) || (pipe_handle >= MAX_PIPES)))
2681         CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2682     if (cvmx_unlikely((submit_handle < 0) || (submit_handle >= MAX_TRANSACTIONS)))
2683         CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2684
2685     /* Fail if the pipe isn't open */
2686     if (cvmx_unlikely((pipe->flags & __CVMX_USB_PIPE_FLAGS_OPEN) == 0))
2687         CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2688
2689     transaction = usb->transaction + submit_handle;
2690
2691     /* Fail if this transaction already completed */
2692     if (cvmx_unlikely((transaction->flags & __CVMX_USB_TRANSACTION_FLAGS_IN_USE) == 0))
2693         CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2694
2695     /* If the transaction is the HEAD of the queue and scheduled. We need to
2696         treat it special */
2697     if ((pipe->head == transaction) &&
2698         (pipe->flags & __CVMX_USB_PIPE_FLAGS_SCHEDULED))
2699     {
2700         cvmx_usbcx_hccharx_t usbc_hcchar;
2701
2702         usb->pipe_for_channel[pipe->channel] = NULL;
2703         pipe->flags &= ~__CVMX_USB_PIPE_FLAGS_SCHEDULED;
2704
2705         CVMX_SYNCW;
2706
2707         usbc_hcchar.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HCCHARX(pipe->channel, usb->index));
2708         /* If the channel isn't enabled then the transaction already completed */
2709         if (usbc_hcchar.s.chena)
2710         {
2711             usbc_hcchar.s.chdis = 1;
2712             __cvmx_usb_write_csr32(usb, CVMX_USBCX_HCCHARX(pipe->channel, usb->index), usbc_hcchar.u32);
2713         }
2714     }
2715     __cvmx_usb_perform_complete(usb, pipe, transaction, CVMX_USB_COMPLETE_CANCEL);
2716     CVMX_USB_RETURN(CVMX_USB_SUCCESS);
2717 }
2718 #ifdef CVMX_BUILD_FOR_LINUX_KERNEL
2719 EXPORT_SYMBOL(cvmx_usb_cancel);
2720 #endif
2721
2722
2723 /**
2724  * Cancel all outstanding requests in a pipe. Logically all this
2725  * does is call cvmx_usb_cancel() in a loop.
2726  *
2727  * @param state  USB device state populated by
2728  *               cvmx_usb_initialize().
2729  * @param pipe_handle
2730  *               Pipe handle to cancel requests in.
2731  *
2732  * @return CVMX_USB_SUCCESS or a negative error code defined in
2733  *         cvmx_usb_status_t.
2734  */
2735 cvmx_usb_status_t cvmx_usb_cancel_all(cvmx_usb_state_t *state, int pipe_handle)
2736 {
2737     cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
2738     cvmx_usb_pipe_t *pipe = usb->pipe + pipe_handle;
2739
2740     CVMX_USB_LOG_CALLED();
2741     CVMX_USB_LOG_PARAM("%p", state);
2742     CVMX_USB_LOG_PARAM("%d", pipe_handle);
2743     if (cvmx_unlikely((pipe_handle < 0) || (pipe_handle >= MAX_PIPES)))
2744         CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2745
2746     /* Fail if the pipe isn't open */
2747     if (cvmx_unlikely((pipe->flags & __CVMX_USB_PIPE_FLAGS_OPEN) == 0))
2748         CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2749
2750     /* Simply loop through and attempt to cancel each transaction */
2751     while (pipe->head)
2752     {
2753         cvmx_usb_status_t result = cvmx_usb_cancel(state, pipe_handle,
2754             __cvmx_usb_get_submit_handle(usb, pipe->head));
2755         if (cvmx_unlikely(result != CVMX_USB_SUCCESS))
2756             CVMX_USB_RETURN(result);
2757     }
2758     CVMX_USB_RETURN(CVMX_USB_SUCCESS);
2759 }
2760 #ifdef CVMX_BUILD_FOR_LINUX_KERNEL
2761 EXPORT_SYMBOL(cvmx_usb_cancel_all);
2762 #endif
2763
2764
2765 /**
2766  * Close a pipe created with cvmx_usb_open_pipe().
2767  *
2768  * @param state  USB device state populated by
2769  *               cvmx_usb_initialize().
2770  * @param pipe_handle
2771  *               Pipe handle to close.
2772  *
2773  * @return CVMX_USB_SUCCESS or a negative error code defined in
2774  *         cvmx_usb_status_t. CVMX_USB_BUSY is returned if the
2775  *         pipe has outstanding transfers.
2776  */
2777 cvmx_usb_status_t cvmx_usb_close_pipe(cvmx_usb_state_t *state, int pipe_handle)
2778 {
2779     cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
2780     cvmx_usb_pipe_t *pipe = usb->pipe + pipe_handle;
2781
2782     CVMX_USB_LOG_CALLED();
2783     CVMX_USB_LOG_PARAM("%p", state);
2784     CVMX_USB_LOG_PARAM("%d", pipe_handle);
2785     if (cvmx_unlikely((pipe_handle < 0) || (pipe_handle >= MAX_PIPES)))
2786         CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2787
2788     /* Fail if the pipe isn't open */
2789     if (cvmx_unlikely((pipe->flags & __CVMX_USB_PIPE_FLAGS_OPEN) == 0))
2790         CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2791
2792     /* Fail if the pipe has pending transactions */
2793     if (cvmx_unlikely(pipe->head))
2794         CVMX_USB_RETURN(CVMX_USB_BUSY);
2795
2796     pipe->flags = 0;
2797     __cvmx_usb_remove_pipe(&usb->idle_pipes, pipe);
2798     __cvmx_usb_append_pipe(&usb->free_pipes, pipe);
2799
2800     CVMX_USB_RETURN(CVMX_USB_SUCCESS);
2801 }
2802 #ifdef CVMX_BUILD_FOR_LINUX_KERNEL
2803 EXPORT_SYMBOL(cvmx_usb_close_pipe);
2804 #endif
2805
2806
2807 /**
2808  * Register a function to be called when various USB events occur.
2809  *
2810  * @param state     USB device state populated by
2811  *                  cvmx_usb_initialize().
2812  * @param reason    Which event to register for.
2813  * @param callback  Function to call when the event occurs.
2814  * @param user_data User data parameter to the function.
2815  *
2816  * @return CVMX_USB_SUCCESS or a negative error code defined in
2817  *         cvmx_usb_status_t.
2818  */
2819 cvmx_usb_status_t cvmx_usb_register_callback(cvmx_usb_state_t *state,
2820                                              cvmx_usb_callback_t reason,
2821                                              cvmx_usb_callback_func_t callback,
2822                                              void *user_data)
2823 {
2824     cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
2825
2826     CVMX_USB_LOG_CALLED();
2827     CVMX_USB_LOG_PARAM("%p", state);
2828     CVMX_USB_LOG_PARAM("%d", reason);
2829     CVMX_USB_LOG_PARAM("%p", callback);
2830     CVMX_USB_LOG_PARAM("%p", user_data);
2831     if (cvmx_unlikely(reason >= __CVMX_USB_CALLBACK_END))
2832         CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2833     if (cvmx_unlikely(!callback))
2834         CVMX_USB_RETURN(CVMX_USB_INVALID_PARAM);
2835
2836     usb->callback[reason] = callback;
2837     usb->callback_data[reason] = user_data;
2838
2839     CVMX_USB_RETURN(CVMX_USB_SUCCESS);
2840 }
2841 #ifdef CVMX_BUILD_FOR_LINUX_KERNEL
2842 EXPORT_SYMBOL(cvmx_usb_register_callback);
2843 #endif
2844
2845
2846 /**
2847  * Get the current USB protocol level frame number. The frame
2848  * number is always in the range of 0-0x7ff.
2849  *
2850  * @param state  USB device state populated by
2851  *               cvmx_usb_initialize().
2852  *
2853  * @return USB frame number
2854  */
2855 int cvmx_usb_get_frame_number(cvmx_usb_state_t *state)
2856 {
2857     int frame_number;
2858     cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
2859     cvmx_usbcx_hfnum_t usbc_hfnum;
2860
2861     CVMX_USB_LOG_CALLED();
2862     CVMX_USB_LOG_PARAM("%p", state);
2863
2864     usbc_hfnum.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HFNUM(usb->index));
2865     frame_number = usbc_hfnum.s.frnum;
2866
2867     CVMX_USB_RETURN(frame_number);
2868 }
2869 #ifdef CVMX_BUILD_FOR_LINUX_KERNEL
2870 EXPORT_SYMBOL(cvmx_usb_get_frame_number);
2871 #endif
2872
2873
2874 /**
2875  * @INTERNAL
2876  * Poll a channel for status
2877  *
2878  * @param usb     USB device
2879  * @param channel Channel to poll
2880  *
2881  * @return Zero on success
2882  */
2883 static int __cvmx_usb_poll_channel(cvmx_usb_internal_state_t *usb, int channel)
2884 {
2885     cvmx_usbcx_hcintx_t usbc_hcint;
2886     cvmx_usbcx_hctsizx_t usbc_hctsiz;
2887     cvmx_usbcx_hccharx_t usbc_hcchar;
2888     cvmx_usb_pipe_t *pipe;
2889     cvmx_usb_transaction_t *transaction;
2890     int bytes_this_transfer;
2891     int bytes_in_last_packet;
2892     int packets_processed;
2893     int buffer_space_left;
2894     CVMX_USB_LOG_CALLED();
2895     CVMX_USB_LOG_PARAM("%p", usb);
2896     CVMX_USB_LOG_PARAM("%d", channel);
2897
2898     /* Read the interrupt status bits for the channel */
2899     usbc_hcint.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HCINTX(channel, usb->index));
2900
2901 #if 0
2902     cvmx_dprintf("Channel %d%s%s%s%s%s%s%s%s%s%s%s\n", channel,
2903         (usbc_hcint.s.datatglerr) ? " DATATGLERR" : "",
2904         (usbc_hcint.s.frmovrun) ? " FRMOVRUN" : "",
2905         (usbc_hcint.s.bblerr) ? " BBLERR" : "",
2906         (usbc_hcint.s.xacterr) ? " XACTERR" : "",
2907         (usbc_hcint.s.nyet) ? " NYET" : "",
2908         (usbc_hcint.s.ack) ? " ACK" : "",
2909         (usbc_hcint.s.nak) ? " NAK" : "",
2910         (usbc_hcint.s.stall) ? " STALL" : "",
2911         (usbc_hcint.s.ahberr) ? " AHBERR" : "",
2912         (usbc_hcint.s.chhltd) ? " CHHLTD" : "",
2913         (usbc_hcint.s.xfercompl) ? " XFERCOMPL" : "");
2914 #endif
2915
2916     if (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_NO_DMA)
2917     {
2918         usbc_hcchar.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HCCHARX(channel, usb->index));
2919
2920         if (usbc_hcchar.s.chena && usbc_hcchar.s.chdis)
2921         {
2922             /* There seems to be a bug in CN31XX which can cause interrupt
2923                 IN transfers to get stuck until we do a write of HCCHARX
2924                 without changing things */
2925             __cvmx_usb_write_csr32(usb, CVMX_USBCX_HCCHARX(channel, usb->index), usbc_hcchar.u32);
2926             CVMX_USB_RETURN(0);
2927         }
2928
2929         /* In non DMA mode the channels don't halt themselves. We need to
2930             manually disable channels that are left running */
2931         if (!usbc_hcint.s.chhltd)
2932         {
2933             if (usbc_hcchar.s.chena)
2934             {
2935                 cvmx_usbcx_hcintmskx_t hcintmsk;
2936                 /* Disable all interrupts except CHHLTD */
2937                 hcintmsk.u32 = 0;
2938                 hcintmsk.s.chhltdmsk = 1;
2939                 __cvmx_usb_write_csr32(usb, CVMX_USBCX_HCINTMSKX(channel, usb->index), hcintmsk.u32);
2940                 usbc_hcchar.s.chdis = 1;
2941                 __cvmx_usb_write_csr32(usb, CVMX_USBCX_HCCHARX(channel, usb->index), usbc_hcchar.u32);
2942                 CVMX_USB_RETURN(0);
2943             }
2944             else if (usbc_hcint.s.xfercompl)
2945             {
2946                 /* Successful IN/OUT with transfer complete. Channel halt isn't needed */
2947             }
2948             else
2949             {
2950                 cvmx_dprintf("USB%d: Channel %d interrupt without halt\n", usb->index, channel);
2951                 CVMX_USB_RETURN(0);
2952             }
2953         }
2954     }
2955     else
2956     {
2957         /* There is are no interrupts that we need to process when the channel is
2958             still running */
2959         if (!usbc_hcint.s.chhltd)
2960             CVMX_USB_RETURN(0);
2961     }
2962
2963     /* Disable the channel interrupts now that it is done */
2964     __cvmx_usb_write_csr32(usb, CVMX_USBCX_HCINTMSKX(channel, usb->index), 0);
2965     usb->idle_hardware_channels |= (1<<channel);
2966
2967     /* Make sure this channel is tied to a valid pipe */
2968     pipe = usb->pipe_for_channel[channel];
2969     CVMX_PREFETCH(pipe, 0);
2970     CVMX_PREFETCH(pipe, 128);
2971     if (!pipe)
2972         CVMX_USB_RETURN(0);
2973     transaction = pipe->head;
2974     CVMX_PREFETCH0(transaction);
2975
2976     /* Disconnect this pipe from the HW channel. Later the schedule function will
2977         figure out which pipe needs to go */
2978     usb->pipe_for_channel[channel] = NULL;
2979     pipe->flags &= ~__CVMX_USB_PIPE_FLAGS_SCHEDULED;
2980
2981     /* Read the channel config info so we can figure out how much data
2982         transfered */
2983     usbc_hcchar.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HCCHARX(channel, usb->index));
2984     usbc_hctsiz.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HCTSIZX(channel, usb->index));
2985
2986     /* Calculating the number of bytes successfully transferred is dependent on
2987         the transfer direction */
2988     packets_processed = transaction->pktcnt - usbc_hctsiz.s.pktcnt;
2989     if (usbc_hcchar.s.epdir)
2990     {
2991         /* IN transactions are easy. For every byte received the hardware
2992             decrements xfersize. All we need to do is subtract the current
2993             value of xfersize from its starting value and we know how many
2994             bytes were written to the buffer */
2995         bytes_this_transfer = transaction->xfersize - usbc_hctsiz.s.xfersize;
2996     }
2997     else
2998     {
2999         /* OUT transaction don't decrement xfersize. Instead pktcnt is
3000             decremented on every successful packet send. The hardware does
3001             this when it receives an ACK, or NYET. If it doesn't
3002             receive one of these responses pktcnt doesn't change */
3003         bytes_this_transfer = packets_processed * usbc_hcchar.s.mps;
3004         /* The last packet may not be a full transfer if we didn't have
3005             enough data */
3006         if (bytes_this_transfer > transaction->xfersize)
3007             bytes_this_transfer = transaction->xfersize;
3008     }
3009     /* Figure out how many bytes were in the last packet of the transfer */
3010     if (packets_processed)
3011         bytes_in_last_packet = bytes_this_transfer - (packets_processed-1) * usbc_hcchar.s.mps;
3012     else
3013         bytes_in_last_packet = bytes_this_transfer;
3014
3015     /* As a special case, setup transactions output the setup header, not
3016         the user's data. For this reason we don't count setup data as bytes
3017         transferred */
3018     if ((transaction->stage == CVMX_USB_STAGE_SETUP) ||
3019         (transaction->stage == CVMX_USB_STAGE_SETUP_SPLIT_COMPLETE))
3020         bytes_this_transfer = 0;
3021
3022     /* Optional debug output */
3023     if (cvmx_unlikely((usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_DEBUG_TRANSFERS) ||
3024         (pipe->flags & CVMX_USB_PIPE_FLAGS_DEBUG_TRANSFERS)))
3025         cvmx_dprintf("%s: Channel %d halted. Pipe %d transaction %d stage %d bytes=%d\n",
3026                      __FUNCTION__, channel,
3027                      __cvmx_usb_get_pipe_handle(usb, pipe),
3028                      __cvmx_usb_get_submit_handle(usb, transaction),
3029                      transaction->stage, bytes_this_transfer);
3030
3031     /* Add the bytes transferred to the running total. It is important that
3032         bytes_this_transfer doesn't count any data that needs to be
3033         retransmitted */
3034     transaction->actual_bytes += bytes_this_transfer;
3035     if (transaction->type == CVMX_USB_TRANSFER_ISOCHRONOUS)
3036         buffer_space_left = transaction->iso_packets[0].length - transaction->actual_bytes;
3037     else
3038         buffer_space_left = transaction->buffer_length - transaction->actual_bytes;
3039
3040     /* We need to remember the PID toggle state for the next transaction. The
3041         hardware already updated it for the next transaction */
3042     pipe->pid_toggle = !(usbc_hctsiz.s.pid == 0);
3043
3044     /* For high speed bulk out, assume the next transaction will need to do a
3045         ping before proceeding. If this isn't true the ACK processing below
3046         will clear this flag */
3047     if ((pipe->device_speed == CVMX_USB_SPEED_HIGH) &&
3048         (pipe->transfer_type == CVMX_USB_TRANSFER_BULK) &&
3049         (pipe->transfer_dir == CVMX_USB_DIRECTION_OUT))
3050         pipe->flags |= __CVMX_USB_PIPE_FLAGS_NEED_PING;
3051
3052     if (usbc_hcint.s.stall)
3053     {
3054         /* STALL as a response means this transaction cannot be completed
3055             because the device can't process transactions. Tell the user. Any
3056             data that was transferred will be counted on the actual bytes
3057             transferred */
3058         pipe->pid_toggle = 0;
3059         __cvmx_usb_perform_complete(usb, pipe, transaction, CVMX_USB_COMPLETE_STALL);
3060     }
3061     else if (usbc_hcint.s.xacterr)
3062     {
3063         /* We know at least one packet worked if we get a ACK or NAK. Reset the retry counter */
3064         if (usbc_hcint.s.nak || usbc_hcint.s.ack)
3065             transaction->retries = 0;
3066         transaction->retries++;
3067         if (transaction->retries > MAX_RETRIES)
3068         {
3069             /* XactErr as a response means the device signaled something wrong with
3070                 the transfer. For example, PID toggle errors cause these */
3071             __cvmx_usb_perform_complete(usb, pipe, transaction, CVMX_USB_COMPLETE_XACTERR);
3072         }
3073         else
3074         {
3075             /* If this was a split then clear our split in progress marker */
3076             if (usb->active_split == transaction)
3077                 usb->active_split = NULL;
3078             /* Rewind to the beginning of the transaction by anding off the
3079                 split complete bit */
3080             transaction->stage &= ~1;
3081             pipe->split_sc_frame = -1;
3082             pipe->next_tx_frame += pipe->interval;
3083             if (pipe->next_tx_frame < usb->frame_number)
3084                 pipe->next_tx_frame = usb->frame_number + pipe->interval -
3085                     (usb->frame_number - pipe->next_tx_frame) % pipe->interval;
3086         }
3087     }
3088     else if (usbc_hcint.s.bblerr)
3089     {
3090         /* Babble Error (BblErr) */
3091         __cvmx_usb_perform_complete(usb, pipe, transaction, CVMX_USB_COMPLETE_BABBLEERR);
3092     }
3093     else if (usbc_hcint.s.datatglerr)
3094     {
3095         /* We'll retry the exact same transaction again */
3096         transaction->retries++;
3097     }
3098     else if (usbc_hcint.s.nyet)
3099     {
3100         /* NYET as a response is only allowed in three cases: as a response to
3101             a ping, as a response to a split transaction, and as a response to
3102             a bulk out. The ping case is handled by hardware, so we only have
3103             splits and bulk out */
3104         if (!__cvmx_usb_pipe_needs_split(usb, pipe))
3105         {
3106             transaction->retries = 0;
3107             /* If there is more data to go then we need to try again. Otherwise
3108                 this transaction is complete */
3109             if ((buffer_space_left == 0) || (bytes_in_last_packet < pipe->max_packet))
3110                 __cvmx_usb_perform_complete(usb, pipe, transaction, CVMX_USB_COMPLETE_SUCCESS);
3111         }
3112         else
3113         {
3114             /* Split transactions retry the split complete 4 times then rewind
3115                 to the start split and do the entire transactions again */
3116             transaction->retries++;
3117             if ((transaction->retries & 0x3) == 0)
3118             {
3119                 /* Rewind to the beginning of the transaction by anding off the
3120                     split complete bit */
3121                 transaction->stage &= ~1;
3122                 pipe->split_sc_frame = -1;
3123             }
3124         }
3125     }
3126     else if (usbc_hcint.s.ack)
3127     {
3128         transaction->retries = 0;
3129         /* The ACK bit can only be checked after the other error bits. This is
3130             because a multi packet transfer may succeed in a number of packets
3131             and then get a different response on the last packet. In this case
3132             both ACK and the last response bit will be set. If none of the
3133             other response bits is set, then the last packet must have been an
3134             ACK */
3135
3136         /* Since we got an ACK, we know we don't need to do a ping on this
3137             pipe */
3138         pipe->flags &= ~__CVMX_USB_PIPE_FLAGS_NEED_PING;
3139
3140         switch (transaction->type)
3141         {
3142             case CVMX_USB_TRANSFER_CONTROL:
3143                 switch (transaction->stage)
3144                 {
3145                     case CVMX_USB_STAGE_NON_CONTROL:
3146                     case CVMX_USB_STAGE_NON_CONTROL_SPLIT_COMPLETE:
3147                         /* This should be impossible */
3148                         __cvmx_usb_perform_complete(usb, pipe, transaction, CVMX_USB_COMPLETE_ERROR);
3149                         break;
3150                     case CVMX_USB_STAGE_SETUP:
3151                         pipe->pid_toggle = 1;
3152                         if (__cvmx_usb_pipe_needs_split(usb, pipe))
3153                             transaction->stage = CVMX_USB_STAGE_SETUP_SPLIT_COMPLETE;
3154                         else
3155                         {
3156                             cvmx_usb_control_header_t *header = cvmx_phys_to_ptr(transaction->control_header);
3157                             if (header->s.length)
3158                                 transaction->stage = CVMX_USB_STAGE_DATA;
3159                             else
3160                                 transaction->stage = CVMX_USB_STAGE_STATUS;
3161                         }
3162                         break;
3163                     case CVMX_USB_STAGE_SETUP_SPLIT_COMPLETE:
3164                         {
3165                             cvmx_usb_control_header_t *header = cvmx_phys_to_ptr(transaction->control_header);
3166                             if (header->s.length)
3167                                 transaction->stage = CVMX_USB_STAGE_DATA;
3168                             else
3169                                 transaction->stage = CVMX_USB_STAGE_STATUS;
3170                         }
3171                         break;
3172                     case CVMX_USB_STAGE_DATA:
3173                         if (__cvmx_usb_pipe_needs_split(usb, pipe))
3174                         {
3175                             transaction->stage = CVMX_USB_STAGE_DATA_SPLIT_COMPLETE;
3176                             /* For setup OUT data that are splits, the hardware
3177                                 doesn't appear to count transferred data. Here
3178                                 we manually update the data transferred */
3179                             if (!usbc_hcchar.s.epdir)
3180                             {
3181                                 if (buffer_space_left < pipe->max_packet)
3182                                     transaction->actual_bytes += buffer_space_left;
3183                                 else
3184                                     transaction->actual_bytes += pipe->max_packet;
3185                             }
3186                         }
3187                         else if ((buffer_space_left == 0) || (bytes_in_last_packet < pipe->max_packet))
3188                         {
3189                             pipe->pid_toggle = 1;
3190                             transaction->stage = CVMX_USB_STAGE_STATUS;
3191                         }
3192                         break;
3193                     case CVMX_USB_STAGE_DATA_SPLIT_COMPLETE:
3194                         if ((buffer_space_left == 0) || (bytes_in_last_packet < pipe->max_packet))
3195                         {
3196                             pipe->pid_toggle = 1;
3197                             transaction->stage = CVMX_USB_STAGE_STATUS;
3198                         }
3199                         else
3200                         {
3201                             transaction->stage = CVMX_USB_STAGE_DATA;
3202                         }
3203                         break;
3204                     case CVMX_USB_STAGE_STATUS:
3205                         if (__cvmx_usb_pipe_needs_split(usb, pipe))
3206                             transaction->stage = CVMX_USB_STAGE_STATUS_SPLIT_COMPLETE;
3207                         else
3208                             __cvmx_usb_perform_complete(usb, pipe, transaction, CVMX_USB_COMPLETE_SUCCESS);
3209                         break;
3210                     case CVMX_USB_STAGE_STATUS_SPLIT_COMPLETE:
3211                         __cvmx_usb_perform_complete(usb, pipe, transaction, CVMX_USB_COMPLETE_SUCCESS);
3212                         break;
3213                 }
3214                 break;
3215             case CVMX_USB_TRANSFER_BULK:
3216             case CVMX_USB_TRANSFER_INTERRUPT:
3217                 /* The only time a bulk transfer isn't complete when
3218                     it finishes with an ACK is during a split transaction. For
3219                     splits we need to continue the transfer if more data is
3220                     needed */
3221                 if (__cvmx_usb_pipe_needs_split(usb, pipe))
3222                 {
3223                     if (transaction->stage == CVMX_USB_STAGE_NON_CONTROL)
3224                         transaction->stage = CVMX_USB_STAGE_NON_CONTROL_SPLIT_COMPLETE;
3225                     else
3226                     {
3227                         if (buffer_space_left && (bytes_in_last_packet == pipe->max_packet))
3228                             transaction->stage = CVMX_USB_STAGE_NON_CONTROL;
3229                         else
3230                         {
3231                             if (transaction->type == CVMX_USB_TRANSFER_INTERRUPT)
3232                                 pipe->next_tx_frame += pipe->interval;
3233                             __cvmx_usb_perform_complete(usb, pipe, transaction, CVMX_USB_COMPLETE_SUCCESS);
3234                         }
3235                     }
3236                 }
3237                 else
3238                 {
3239                     if ((pipe->device_speed == CVMX_USB_SPEED_HIGH) &&
3240                         (pipe->transfer_type == CVMX_USB_TRANSFER_BULK) &&
3241                         (pipe->transfer_dir == CVMX_USB_DIRECTION_OUT) &&
3242                         (usbc_hcint.s.nak))
3243                         pipe->flags |= __CVMX_USB_PIPE_FLAGS_NEED_PING;
3244                     if (!buffer_space_left || (bytes_in_last_packet < pipe->max_packet))
3245                     {
3246                         if (transaction->type == CVMX_USB_TRANSFER_INTERRUPT)
3247                             pipe->next_tx_frame += pipe->interval;
3248                         __cvmx_usb_perform_complete(usb, pipe, transaction, CVMX_USB_COMPLETE_SUCCESS);
3249                     }
3250                 }
3251                 break;
3252             case CVMX_USB_TRANSFER_ISOCHRONOUS:
3253                 if (__cvmx_usb_pipe_needs_split(usb, pipe))
3254                 {
3255                     /* ISOCHRONOUS OUT splits don't require a complete split stage.
3256                         Instead they use a sequence of begin OUT splits to transfer
3257                         the data 188 bytes at a time. Once the transfer is complete,
3258                         the pipe sleeps until the next schedule interval */
3259                     if (pipe->transfer_dir == CVMX_USB_DIRECTION_OUT)
3260                     {
3261                         /* If no space left or this wasn't a max size packet then
3262                             this transfer is complete. Otherwise start it again
3263                             to send the next 188 bytes */
3264                         if (!buffer_space_left || (bytes_this_transfer < 188))
3265                         {
3266                             pipe->next_tx_frame += pipe->interval;
3267                             __cvmx_usb_perform_complete(usb, pipe, transaction, CVMX_USB_COMPLETE_SUCCESS);
3268                         }
3269                     }
3270                     else
3271                     {
3272                         if (transaction->stage == CVMX_USB_STAGE_NON_CONTROL_SPLIT_COMPLETE)
3273                         {
3274                             /* We are in the incoming data phase. Keep getting
3275                                 data until we run out of space or get a small
3276                                 packet */
3277                             if ((buffer_space_left == 0) || (bytes_in_last_packet < pipe->max_packet))
3278                             {
3279                                 pipe->next_tx_frame += pipe->interval;
3280                                 __cvmx_usb_perform_complete(usb, pipe, transaction, CVMX_USB_COMPLETE_SUCCESS);
3281                             }
3282                         }
3283                         else
3284                             transaction->stage = CVMX_USB_STAGE_NON_CONTROL_SPLIT_COMPLETE;
3285                     }
3286                 }
3287                 else
3288                 {
3289                     pipe->next_tx_frame += pipe->interval;
3290                     __cvmx_usb_perform_complete(usb, pipe, transaction, CVMX_USB_COMPLETE_SUCCESS);
3291                 }
3292                 break;
3293         }
3294     }
3295     else if (usbc_hcint.s.nak)
3296     {
3297         /* If this was a split then clear our split in progress marker */
3298         if (usb->active_split == transaction)
3299             usb->active_split = NULL;
3300         /* NAK as a response means the device couldn't accept the transaction,
3301             but it should be retried in the future. Rewind to the beginning of
3302             the transaction by anding off the split complete bit. Retry in the
3303             next interval */
3304         transaction->retries = 0;
3305         transaction->stage &= ~1;
3306         pipe->next_tx_frame += pipe->interval;
3307         if (pipe->next_tx_frame < usb->frame_number)
3308             pipe->next_tx_frame = usb->frame_number + pipe->interval -
3309                 (usb->frame_number - pipe->next_tx_frame) % pipe->interval;
3310     }
3311     else
3312     {
3313         cvmx_usb_port_status_t port;
3314         port = cvmx_usb_get_status((cvmx_usb_state_t *)usb);
3315         if (port.port_enabled)
3316         {
3317             /* We'll retry the exact same transaction again */
3318             transaction->retries++;
3319         }
3320         else
3321         {
3322             /* We get channel halted interrupts with no result bits sets when the
3323                 cable is unplugged */
3324             __cvmx_usb_perform_complete(usb, pipe, transaction, CVMX_USB_COMPLETE_ERROR);
3325         }
3326     }
3327     CVMX_USB_RETURN(0);
3328 }
3329
3330
3331 /**
3332  * Poll the USB block for status and call all needed callback
3333  * handlers. This function is meant to be called in the interrupt
3334  * handler for the USB controller. It can also be called
3335  * periodically in a loop for non-interrupt based operation.
3336  *
3337  * @param state  USB device state populated by
3338  *               cvmx_usb_initialize().
3339  *
3340  * @return CVMX_USB_SUCCESS or a negative error code defined in
3341  *         cvmx_usb_status_t.
3342  */
3343 cvmx_usb_status_t cvmx_usb_poll(cvmx_usb_state_t *state)
3344 {
3345     cvmx_usbcx_hfnum_t usbc_hfnum;
3346     cvmx_usbcx_gintsts_t usbc_gintsts;
3347     cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
3348
3349     CVMX_PREFETCH(usb, 0);
3350     CVMX_PREFETCH(usb, 1*128);
3351     CVMX_PREFETCH(usb, 2*128);
3352     CVMX_PREFETCH(usb, 3*128);
3353     CVMX_PREFETCH(usb, 4*128);
3354
3355     CVMX_USB_LOG_CALLED();
3356     CVMX_USB_LOG_PARAM("%p", state);
3357
3358     /* Update the frame counter */
3359     usbc_hfnum.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HFNUM(usb->index));
3360     if ((usb->frame_number&0x3fff) > usbc_hfnum.s.frnum)
3361         usb->frame_number += 0x4000;
3362     usb->frame_number &= ~0x3fffull;
3363     usb->frame_number |= usbc_hfnum.s.frnum;
3364
3365     /* Read the pending interrupts */
3366     usbc_gintsts.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_GINTSTS(usb->index));
3367
3368     /* Clear the interrupts now that we know about them */
3369     __cvmx_usb_write_csr32(usb, CVMX_USBCX_GINTSTS(usb->index), usbc_gintsts.u32);
3370
3371     if (usbc_gintsts.s.rxflvl)
3372     {
3373         /* RxFIFO Non-Empty (RxFLvl)
3374             Indicates that there is at least one packet pending to be read
3375             from the RxFIFO. */
3376         /* In DMA mode this is handled by hardware */
3377         if (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_NO_DMA)
3378             __cvmx_usb_poll_rx_fifo(usb);
3379     }
3380     if (usbc_gintsts.s.ptxfemp || usbc_gintsts.s.nptxfemp)
3381     {
3382         /* Fill the Tx FIFOs when not in DMA mode */
3383         if (usb->init_flags & CVMX_USB_INITIALIZE_FLAGS_NO_DMA)
3384             __cvmx_usb_poll_tx_fifo(usb);
3385     }
3386     if (usbc_gintsts.s.disconnint || usbc_gintsts.s.prtint)
3387     {
3388         cvmx_usbcx_hprt_t usbc_hprt;
3389         /* Disconnect Detected Interrupt (DisconnInt)
3390             Asserted when a device disconnect is detected. */
3391
3392         /* Host Port Interrupt (PrtInt)
3393             The core sets this bit to indicate a change in port status of one
3394             of the O2P USB core ports in Host mode. The application must
3395             read the Host Port Control and Status (HPRT) register to
3396             determine the exact event that caused this interrupt. The
3397             application must clear the appropriate status bit in the Host Port
3398             Control and Status register to clear this bit. */
3399
3400         /* Call the user's port callback */
3401         __cvmx_usb_perform_callback(usb, NULL, NULL,
3402                                     CVMX_USB_CALLBACK_PORT_CHANGED,
3403                                     CVMX_USB_COMPLETE_SUCCESS);
3404         /* Clear the port change bits */
3405         usbc_hprt.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HPRT(usb->index));
3406         usbc_hprt.s.prtena = 0;
3407         __cvmx_usb_write_csr32(usb, CVMX_USBCX_HPRT(usb->index), usbc_hprt.u32);
3408     }
3409     if (usbc_gintsts.s.hchint)
3410     {
3411         /* Host Channels Interrupt (HChInt)
3412             The core sets this bit to indicate that an interrupt is pending on
3413             one of the channels of the core (in Host mode). The application
3414             must read the Host All Channels Interrupt (HAINT) register to
3415             determine the exact number of the channel on which the
3416             interrupt occurred, and then read the corresponding Host
3417             Channel-n Interrupt (HCINTn) register to determine the exact
3418             cause of the interrupt. The application must clear the
3419             appropriate status bit in the HCINTn register to clear this bit. */
3420         cvmx_usbcx_haint_t usbc_haint;
3421         usbc_haint.u32 = __cvmx_usb_read_csr32(usb, CVMX_USBCX_HAINT(usb->index));
3422         while (usbc_haint.u32)
3423         {
3424             int channel;
3425             CVMX_CLZ(channel, usbc_haint.u32);
3426             channel = 31 - channel;
3427             __cvmx_usb_poll_channel(usb, channel);
3428             usbc_haint.u32 ^= 1<<channel;
3429         }
3430     }
3431
3432     __cvmx_usb_schedule(usb, usbc_gintsts.s.sof);
3433
3434     CVMX_USB_RETURN(CVMX_USB_SUCCESS);
3435 }
3436 #ifdef CVMX_BUILD_FOR_LINUX_KERNEL
3437 EXPORT_SYMBOL(cvmx_usb_poll);
3438 #endif
3439
3440 extern void cvmx_usb_set_toggle(cvmx_usb_state_t *state, int endpoint_num, int toggle)
3441 {
3442     cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
3443     cvmx_usb_pipe_t *pipe = usb->pipe + endpoint_num;
3444
3445     pipe->pid_toggle = !!toggle;
3446 }
3447
3448 extern int cvmx_usb_get_toggle(cvmx_usb_state_t *state, int endpoint_num)
3449 {
3450     cvmx_usb_internal_state_t *usb = (cvmx_usb_internal_state_t*)state;
3451     cvmx_usb_pipe_t *pipe = usb->pipe + endpoint_num;
3452
3453     if (pipe->pid_toggle)
3454             return (1);
3455     return (0);
3456 }
3457