xref: /freebsd-11-stable/sys/contrib/octeon-sdk/cvmx-usb.h

/***********************license start***************
 * Copyright (c) 2003-2010  Cavium Inc. (support@cavium.com). All rights
 * reserved.
 *
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 *   * Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *
 *   * Redistributions in binary form must reproduce the above
 *     copyright notice, this list of conditions and the following
 *     disclaimer in the documentation and/or other materials provided
 *     with the distribution.

 *   * Neither the name of Cavium Inc. nor the names of
 *     its contributors may be used to endorse or promote products
 *     derived from this software without specific prior written
 *     permission.

 * This Software, including technical data, may be subject to U.S. export  control
 * laws, including the U.S. Export Administration Act and its  associated
 * regulations, and may be subject to export or import  regulations in other
 * countries.

 * TO THE MAXIMUM EXTENT PERMITTED BY LAW, THE SOFTWARE IS PROVIDED "AS IS"
 * AND WITH ALL FAULTS AND CAVIUM INC. MAKES NO PROMISES, REPRESENTATIONS OR
 * WARRANTIES, EITHER EXPRESS, IMPLIED, STATUTORY, OR OTHERWISE, WITH RESPECT TO
 * THE SOFTWARE, INCLUDING ITS CONDITION, ITS CONFORMITY TO ANY REPRESENTATION OR
 * DESCRIPTION, OR THE EXISTENCE OF ANY LATENT OR PATENT DEFECTS, AND CAVIUM
 * SPECIFICALLY DISCLAIMS ALL IMPLIED (IF ANY) WARRANTIES OF TITLE,
 * MERCHANTABILITY, NONINFRINGEMENT, FITNESS FOR A PARTICULAR PURPOSE, LACK OF
 * VIRUSES, ACCURACY OR COMPLETENESS, QUIET ENJOYMENT, QUIET POSSESSION OR
 * CORRESPONDENCE TO DESCRIPTION. THE ENTIRE  RISK ARISING OUT OF USE OR
 * PERFORMANCE OF THE SOFTWARE LIES WITH YOU.
 ***********************license end**************************************/


/**
 * @file
 *
 * "cvmx-usb.h" defines a set of low level USB functions to help
 * developers create Octeon USB drivers for various operating
 * systems. These functions provide a generic API to the Octeon
 * USB blocks, hiding the internal hardware specific
 * operations.
 *
 * At a high level the device driver needs to:
 *
 * -# Call cvmx_usb_get_num_ports() to get the number of
 *  supported ports.
 * -# Call cvmx_usb_initialize() for each Octeon USB port.
 * -# Enable the port using cvmx_usb_enable().
 * -# Either periodically, or in an interrupt handler, call
 *  cvmx_usb_poll() to service USB events.
 * -# Manage pipes using cvmx_usb_open_pipe() and
 *  cvmx_usb_close_pipe().
 * -# Manage transfers using cvmx_usb_submit_*() and
 *  cvmx_usb_cancel*().
 * -# Shutdown USB on unload using cvmx_usb_shutdown().
 *
 * To monitor USB status changes, the device driver must use
 * cvmx_usb_register_callback() to register for events that it
 * is interested in. Below are a few hints on successfully
 * implementing a driver on top of this API.
 *
 * <h2>Initialization</h2>
 *
 * When a driver is first loaded, it is normally not necessary
 * to bring up the USB port completely. Most operating systems
 * expect to initialize and enable the port in two independent
 * steps. Normally an operating system will probe hardware,
 * initialize anything found, and then enable the hardware.
 *
 * In the probe phase you should:
 * -# Use cvmx_usb_get_num_ports() to determine the number of
 *  USB port to be supported.
 * -# Allocate space for a cvmx_usb_state_t structure for each
 *  port.
 * -# Tell the operating system about each port
 *
 * In the initialization phase you should:
 * -# Use cvmx_usb_initialize() on each port.
 * -# Do not call cvmx_usb_enable(). This leaves the USB port in
 *  the disabled state until the operating system is ready.
 *
 * Finally, in the enable phase you should:
 * -# Call cvmx_usb_enable() on the appropriate port.
 * -# Note that some operating system use a RESET instead of an
 *  enable call. To implement RESET, you should call
 *  cvmx_usb_disable() followed by cvmx_usb_enable().
 *
 * <h2>Locking</h2>
 *
 * All of the functions in the cvmx-usb API assume exclusive
 * access to the USB hardware and internal data structures. This
 * means that the driver must provide locking as necessary.
 *
 * In the single CPU state it is normally enough to disable
 * interrupts before every call to cvmx_usb*() and enable them
 * again after the call is complete. Keep in mind that it is
 * very common for the callback handlers to make additional
 * calls into cvmx-usb, so the disable/enable must be protected
 * against recursion. As an example, the Linux kernel
 * local_irq_save() and local_irq_restore() are perfect for this
 * in the non SMP case.
 *
 * In the SMP case, locking is more complicated. For SMP you not
 * only need to disable interrupts on the local core, but also
 * take a lock to make sure that another core cannot call
 * cvmx-usb.
 *
 * <h2>Port callback</h2>
 *
 * The port callback prototype needs to look as follows:
 *
 * void port_callback(cvmx_usb_state_t *usb,
 *                    cvmx_usb_callback_t reason,
 *                    cvmx_usb_complete_t status,
 *                    int pipe_handle,
 *                    int submit_handle,
 *                    int bytes_transferred,
 *                    void *user_data);
 * - @b usb is the cvmx_usb_state_t for the port.
 * - @b reason will always be
 *   CVMX_USB_CALLBACK_PORT_CHANGED.
 * - @b status will always be CVMX_USB_COMPLETE_SUCCESS.
 * - @b pipe_handle will always be -1.
 * - @b submit_handle will always be -1.
 * - @b bytes_transferred will always be 0.
 * - @b user_data is the void pointer originally passed along
 *   with the callback. Use this for any state information you
 *   need.
 *
 * The port callback will be called whenever the user plugs /
 * unplugs a device from the port. It will not be called when a
 * device is plugged / unplugged from a hub connected to the
 * root port. Normally all the callback needs to do is tell the
 * operating system to poll the root hub for status. Under
 * Linux, this is performed by calling usb_hcd_poll_rh_status().
 * In the Linux driver we use @b user_data. to pass around the
 * Linux "hcd" structure. Once the port callback completes,
 * Linux automatically calls octeon_usb_hub_status_data() which
 * uses cvmx_usb_get_status() to determine the root port status.
 *
 * <h2>Complete callback</h2>
 *
 * The completion callback prototype needs to look as follows:
 *
 * void complete_callback(cvmx_usb_state_t *usb,
 *                        cvmx_usb_callback_t reason,
 *                        cvmx_usb_complete_t status,
 *                        int pipe_handle,
 *                        int submit_handle,
 *                        int bytes_transferred,
 *                        void *user_data);
 * - @b usb is the cvmx_usb_state_t for the port.
 * - @b reason will always be
 *   CVMX_USB_CALLBACK_TRANSFER_COMPLETE.
 * - @b status will be one of the cvmx_usb_complete_t
 *   enumerations.
 * - @b pipe_handle is the handle to the pipe the transaction
 *   was originally submitted on.
 * - @b submit_handle is the handle returned by the original
 *   cvmx_usb_submit_* call.
 * - @b bytes_transferred is the number of bytes successfully
 *   transferred in the transaction. This will be zero on most
 *   error conditions.
 * - @b user_data is the void pointer originally passed along
 *   with the callback. Use this for any state information you
 *   need. For example, the Linux "urb" is stored in here in the
 *   Linux driver.
 *
 * In general your callback handler should use @b status and @b
 * bytes_transferred to tell the operating system the how the
 * transaction completed. Normally the pipe is not changed in
 * this callback.
 *
 * <h2>Canceling transactions</h2>
 *
 * When a transaction is cancelled using cvmx_usb_cancel*(), the
 * actual length of time until the complete callback is called
 * can vary greatly. It may be called before cvmx_usb_cancel*()
 * returns, or it may be called a number of usb frames in the
 * future once the hardware frees the transaction. In either of
 * these cases, the complete handler will receive
 * CVMX_USB_COMPLETE_CANCEL.
 *
 * <h2>Handling pipes</h2>
 *
 * USB "pipes" is a software construct created by this API to
 * enable the ordering of usb transactions to a device endpoint.
 * Octeon's underlying hardware doesn't have any concept
 * equivalent to "pipes". The hardware instead has eight
 * channels that can be used simultaneously to have up to eight
 * transaction in process at the same time. In order to maintain
 * ordering in a pipe, the transactions for a pipe will only be
 * active in one hardware channel at a time. From an API user's
 * perspective, this doesn't matter but it can be helpful to
 * keep this in mind when you are probing hardware while
 * debugging.
 *
 * Also keep in mind that usb transactions contain state
 * information about the previous transaction to the same
 * endpoint. Each transaction has a PID toggle that changes 0/1
 * between each sub packet. This is maintained in the pipe data
 * structures. For this reason, you generally cannot create and
 * destroy a pipe for every transaction. A sequence of
 * transaction to the same endpoint must use the same pipe.
 *
 * <h2>Root Hub</h2>
 *
 * Some operating systems view the usb root port as a normal usb
 * hub. These systems attempt to control the root hub with
 * messages similar to the usb 2.0 spec for hub control and
 * status. For these systems it may be necessary to write
 * function to decode standard usb control messages into
 * equivalent cvmx-usb API calls. As an example, the following
 * code is used under Linux for some of the basic hub control
 * messages.
 *
 * @code
 * static int octeon_usb_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue, u16 wIndex, char *buf, u16 wLength)
 * {
 *     cvmx_usb_state_t *usb = (cvmx_usb_state_t *)hcd->hcd_priv;
 *     cvmx_usb_port_status_t usb_port_status;
 *     int port_status;
 *     struct usb_hub_descriptor *desc;
 *     unsigned long flags;
 *
 *     switch (typeReq)
 *     {
 *         case ClearHubFeature:
 *             DEBUG_ROOT_HUB("OcteonUSB: ClearHubFeature\n");
 *             switch (wValue)
 *             {
 *                 case C_HUB_LOCAL_POWER:
 *                 case C_HUB_OVER_CURRENT:
 *                     // Nothing required here
 *                     break;
 *                 default:
 *                     return -EINVAL;
 *             }
 *             break;
 *         case ClearPortFeature:
 *             DEBUG_ROOT_HUB("OcteonUSB: ClearPortFeature");
 *             if (wIndex != 1)
 *             {
 *                 DEBUG_ROOT_HUB(" INVALID\n");
 *                 return -EINVAL;
 *             }
 *
 *             switch (wValue)
 *             {
 *                 case USB_PORT_FEAT_ENABLE:
 *                     DEBUG_ROOT_HUB(" ENABLE");
 *                     local_irq_save(flags);
 *                     cvmx_usb_disable(usb);
 *                     local_irq_restore(flags);
 *                     break;
 *                 case USB_PORT_FEAT_SUSPEND:
 *                     DEBUG_ROOT_HUB(" SUSPEND");
 *                     // Not supported on Octeon
 *                     break;
 *                 case USB_PORT_FEAT_POWER:
 *                     DEBUG_ROOT_HUB(" POWER");
 *                     // Not supported on Octeon
 *                     break;
 *                 case USB_PORT_FEAT_INDICATOR:
 *                     DEBUG_ROOT_HUB(" INDICATOR");
 *                     // Port inidicator not supported
 *                     break;
 *                 case USB_PORT_FEAT_C_CONNECTION:
 *                     DEBUG_ROOT_HUB(" C_CONNECTION");
 *                     // Clears drivers internal connect status change flag
 *                     cvmx_usb_set_status(usb, cvmx_usb_get_status(usb));
 *                     break;
 *                 case USB_PORT_FEAT_C_RESET:
 *                     DEBUG_ROOT_HUB(" C_RESET");
 *                     // Clears the driver's internal Port Reset Change flag
 *                     cvmx_usb_set_status(usb, cvmx_usb_get_status(usb));
 *                     break;
 *                 case USB_PORT_FEAT_C_ENABLE:
 *                     DEBUG_ROOT_HUB(" C_ENABLE");
 *                     // Clears the driver's internal Port Enable/Disable Change flag
 *                     cvmx_usb_set_status(usb, cvmx_usb_get_status(usb));
 *                     break;
 *                 case USB_PORT_FEAT_C_SUSPEND:
 *                     DEBUG_ROOT_HUB(" C_SUSPEND");
 *                     // Clears the driver's internal Port Suspend Change flag,
 *                         which is set when resume signaling on the host port is
 *                         complete
 *                     break;
 *                 case USB_PORT_FEAT_C_OVER_CURRENT:
 *                     DEBUG_ROOT_HUB(" C_OVER_CURRENT");
 *                     // Clears the driver's overcurrent Change flag
 *                     cvmx_usb_set_status(usb, cvmx_usb_get_status(usb));
 *                     break;
 *                 default:
 *                     DEBUG_ROOT_HUB(" UNKNOWN\n");
 *                     return -EINVAL;
 *             }
 *             DEBUG_ROOT_HUB("\n");
 *             break;
 *         case GetHubDescriptor:
 *             DEBUG_ROOT_HUB("OcteonUSB: GetHubDescriptor\n");
 *             desc = (struct usb_hub_descriptor *)buf;
 *             desc->bDescLength = 9;
 *             desc->bDescriptorType = 0x29;
 *             desc->bNbrPorts = 1;
 *             desc->wHubCharacteristics = 0x08;
 *             desc->bPwrOn2PwrGood = 1;
 *             desc->bHubContrCurrent = 0;
 *             desc->bitmap[0] = 0;
 *             desc->bitmap[1] = 0xff;
 *             break;
 *         case GetHubStatus:
 *             DEBUG_ROOT_HUB("OcteonUSB: GetHubStatus\n");
 *             *(__le32 *)buf = 0;
 *             break;
 *         case GetPortStatus:
 *             DEBUG_ROOT_HUB("OcteonUSB: GetPortStatus");
 *             if (wIndex != 1)
 *             {
 *                 DEBUG_ROOT_HUB(" INVALID\n");
 *                 return -EINVAL;
 *             }
 *
 *             usb_port_status = cvmx_usb_get_status(usb);
 *             port_status = 0;
 *
 *             if (usb_port_status.connect_change)
 *             {
 *                 port_status |= (1 << USB_PORT_FEAT_C_CONNECTION);
 *                 DEBUG_ROOT_HUB(" C_CONNECTION");
 *             }
 *
 *             if (usb_port_status.port_enabled)
 *             {
 *                 port_status |= (1 << USB_PORT_FEAT_C_ENABLE);
 *                 DEBUG_ROOT_HUB(" C_ENABLE");
 *             }
 *
 *             if (usb_port_status.connected)
 *             {
 *                 port_status |= (1 << USB_PORT_FEAT_CONNECTION);
 *                 DEBUG_ROOT_HUB(" CONNECTION");
 *             }
 *
 *             if (usb_port_status.port_enabled)
 *             {
 *                 port_status |= (1 << USB_PORT_FEAT_ENABLE);
 *                 DEBUG_ROOT_HUB(" ENABLE");
 *             }
 *
 *             if (usb_port_status.port_over_current)
 *             {
 *                 port_status |= (1 << USB_PORT_FEAT_OVER_CURRENT);
 *                 DEBUG_ROOT_HUB(" OVER_CURRENT");
 *             }
 *
 *             if (usb_port_status.port_powered)
 *             {
 *                 port_status |= (1 << USB_PORT_FEAT_POWER);
 *                 DEBUG_ROOT_HUB(" POWER");
 *             }
 *
 *             if (usb_port_status.port_speed == CVMX_USB_SPEED_HIGH)
 *             {
 *                 port_status |= (1 << USB_PORT_FEAT_HIGHSPEED);
 *                 DEBUG_ROOT_HUB(" HIGHSPEED");
 *             }
 *             else if (usb_port_status.port_speed == CVMX_USB_SPEED_LOW)
 *             {
 *                 port_status |= (1 << USB_PORT_FEAT_LOWSPEED);
 *                 DEBUG_ROOT_HUB(" LOWSPEED");
 *             }
 *
 *             *((__le32 *)buf) = cpu_to_le32(port_status);
 *             DEBUG_ROOT_HUB("\n");
 *             break;
 *         case SetHubFeature:
 *             DEBUG_ROOT_HUB("OcteonUSB: SetHubFeature\n");
 *             // No HUB features supported
 *             break;
 *         case SetPortFeature:
 *             DEBUG_ROOT_HUB("OcteonUSB: SetPortFeature");
 *             if (wIndex != 1)
 *             {
 *                 DEBUG_ROOT_HUB(" INVALID\n");
 *                 return -EINVAL;
 *             }
 *
 *             switch (wValue)
 *             {
 *                 case USB_PORT_FEAT_SUSPEND:
 *                     DEBUG_ROOT_HUB(" SUSPEND\n");
 *                     return -EINVAL;
 *                 case USB_PORT_FEAT_POWER:
 *                     DEBUG_ROOT_HUB(" POWER\n");
 *                     return -EINVAL;
 *                 case USB_PORT_FEAT_RESET:
 *                     DEBUG_ROOT_HUB(" RESET\n");
 *                     local_irq_save(flags);
 *                     cvmx_usb_disable(usb);
 *                     if (cvmx_usb_enable(usb))
 *                         DEBUG_ERROR("Failed to enable the port\n");
 *                     local_irq_restore(flags);
 *                     return 0;
 *                 case USB_PORT_FEAT_INDICATOR:
 *                     DEBUG_ROOT_HUB(" INDICATOR\n");
 *                     // Not supported
 *                     break;
 *                 default:
 *                     DEBUG_ROOT_HUB(" UNKNOWN\n");
 *                     return -EINVAL;
 *             }
 *             break;
 *         default:
 *             DEBUG_ROOT_HUB("OcteonUSB: Unknown root hub request\n");
 *             return -EINVAL;
 *     }
 *     return 0;
 * }
 * @endcode
 *
 * <h2>Interrupts</h2>
 *
 * If you plan on using usb interrupts, cvmx_usb_poll() must be
 * called on every usb interrupt. It will read the usb state,
 * call any needed callbacks, and schedule transactions as
 * needed. Your device driver needs only to hookup an interrupt
 * handler and call cvmx_usb_poll(). Octeon's usb port 0 causes
 * CIU bit CIU_INT*_SUM0[USB] to be set (bit 56). For port 1,
 * CIU bit CIU_INT_SUM1[USB1] is set (bit 17). How these bits
 * are turned into interrupt numbers is operating system
 * specific. For Linux, there are the convenient defines
 * OCTEON_IRQ_USB0 and OCTEON_IRQ_USB1 for the IRQ numbers.
 *
 * If you aren't using interrupts, simple call cvmx_usb_poll()
 * in your main processing loop.
 *
 * <hr>$Revision: 32636 $<hr>
 */

#ifndef __CVMX_USB_H__
#define __CVMX_USB_H__

#ifdef	__cplusplus
extern "C" {
#endif

/**
 * Enumerations representing the status of function calls.
 */
typedef enum
{
    CVMX_USB_SUCCESS = 0,           /**< There were no errors */
    CVMX_USB_INVALID_PARAM = -1,    /**< A parameter to the function was invalid */
    CVMX_USB_NO_MEMORY = -2,        /**< Insufficient resources were available for the request */
    CVMX_USB_BUSY = -3,             /**< The resource is busy and cannot service the request */
    CVMX_USB_TIMEOUT = -4,          /**< Waiting for an action timed out */
    CVMX_USB_INCORRECT_MODE = -5,   /**< The function call doesn't work in the current USB
                                         mode. This happens when host only functions are
                                         called in device mode or vice versa */
} cvmx_usb_status_t;

/**
 * Enumerations representing the possible USB device speeds
 */
typedef enum
{
    CVMX_USB_SPEED_HIGH = 0,        /**< Device is operation at 480Mbps */
    CVMX_USB_SPEED_FULL = 1,        /**< Device is operation at 12Mbps */
    CVMX_USB_SPEED_LOW = 2,         /**< Device is operation at 1.5Mbps */
} cvmx_usb_speed_t;

/**
 * Enumeration representing the possible USB transfer types.
 */
typedef enum
{
    CVMX_USB_TRANSFER_CONTROL = 0,      /**< USB transfer type control for hub and status transfers */
    CVMX_USB_TRANSFER_ISOCHRONOUS = 1,  /**< USB transfer type isochronous for low priority periodic transfers */
    CVMX_USB_TRANSFER_BULK = 2,         /**< USB transfer type bulk for large low priority transfers */
    CVMX_USB_TRANSFER_INTERRUPT = 3,    /**< USB transfer type interrupt for high priority periodic transfers */
} cvmx_usb_transfer_t;

/**
 * Enumeration of the transfer directions
 */
typedef enum
{
    CVMX_USB_DIRECTION_OUT,         /**< Data is transferring from Octeon to the device/host */
    CVMX_USB_DIRECTION_IN,          /**< Data is transferring from the device/host to Octeon */
} cvmx_usb_direction_t;

/**
 * Enumeration of all possible status codes passed to callback
 * functions.
 */
typedef enum
{
    CVMX_USB_COMPLETE_SUCCESS,      /**< The transaction / operation finished without any errors */
    CVMX_USB_COMPLETE_SHORT,        /**< FIXME: This is currently not implemented */
    CVMX_USB_COMPLETE_CANCEL,       /**< The transaction was canceled while in flight by a user call to cvmx_usb_cancel* */
    CVMX_USB_COMPLETE_ERROR,        /**< The transaction aborted with an unexpected error status */
    CVMX_USB_COMPLETE_STALL,        /**< The transaction received a USB STALL response from the device */
    CVMX_USB_COMPLETE_XACTERR,      /**< The transaction failed with an error from the device even after a number of retries */
    CVMX_USB_COMPLETE_DATATGLERR,   /**< The transaction failed with a data toggle error even after a number of retries */
    CVMX_USB_COMPLETE_BABBLEERR,    /**< The transaction failed with a babble error */
    CVMX_USB_COMPLETE_FRAMEERR,     /**< The transaction failed with a frame error even after a number of retries */
} cvmx_usb_complete_t;

/**
 * Structure returned containing the USB port status information.
 */
typedef struct
{
    uint32_t reserved           : 25;
    uint32_t port_enabled       : 1; /**< 1 = Usb port is enabled, 0 = disabled */
    uint32_t port_over_current  : 1; /**< 1 = Over current detected, 0 = Over current not detected. Octeon doesn't support over current detection */
    uint32_t port_powered       : 1; /**< 1 = Port power is being supplied to the device, 0 = power is off. Octeon doesn't support turning port power off */
    cvmx_usb_speed_t port_speed : 2; /**< Current port speed */
    uint32_t connected          : 1; /**< 1 = A device is connected to the port, 0 = No device is connected */
    uint32_t connect_change     : 1; /**< 1 = Device connected state changed since the last set status call */
} cvmx_usb_port_status_t;

/**
 * This is the structure of a Control packet header
 */
typedef union
{
    uint64_t u64;
    struct
    {
        uint64_t request_type   : 8;  /**< Bit 7 tells the direction: 1=IN, 0=OUT */
        uint64_t request        : 8;  /**< The standard usb request to make */
        uint64_t value          : 16; /**< Value parameter for the request in little endian format */
        uint64_t index          : 16; /**< Index for the request in little endian format */
        uint64_t length         : 16; /**< Length of the data associated with this request in little endian format */
    } s;
} cvmx_usb_control_header_t;

/**
 * Descriptor for Isochronous packets
 */
typedef struct
{
    int offset;                     /**< This is the offset in bytes into the main buffer where this data is stored */
    int length;                     /**< This is the length in bytes of the data */
    cvmx_usb_complete_t status;     /**< This is the status of this individual packet transfer */
} cvmx_usb_iso_packet_t;

/**
 * Possible callback reasons for the USB API.
 */
typedef enum
{
    CVMX_USB_CALLBACK_TRANSFER_COMPLETE,
                                    /**< A callback of this type is called when a submitted transfer
                                        completes. The completion callback will be called even if the
                                        transfer fails or is canceled. The status parameter will
                                        contain details of why he callback was called. */
    CVMX_USB_CALLBACK_PORT_CHANGED, /**< The status of the port changed. For example, someone may have
                                        plugged a device in. The status parameter contains
                                        CVMX_USB_COMPLETE_SUCCESS. Use cvmx_usb_get_status() to get
                                        the new port status. */
    __CVMX_USB_CALLBACK_END         /**< Do not use. Used internally for array bounds */
} cvmx_usb_callback_t;

/**
 * USB state internal data. The contents of this structure
 * may change in future SDKs. No data in it should be referenced
 * by user's of this API.
 */
typedef struct
{
    char data[65536];
} cvmx_usb_state_t;

/**
 * USB callback functions are always of the following type.
 * The parameters are as follows:
 *      - state = USB device state populated by
 *        cvmx_usb_initialize().
 *      - reason = The cvmx_usb_callback_t used to register
 *        the callback.
 *      - status = The cvmx_usb_complete_t representing the
 *        status code of a transaction.
 *      - pipe_handle = The Pipe that caused this callback, or
 *        -1 if this callback wasn't associated with a pipe.
 *      - submit_handle = Transfer submit handle causing this
 *        callback, or -1 if this callback wasn't associated
 *        with a transfer.
 *      - Actual number of bytes transfer.
 *      - user_data = The user pointer supplied to the
 *        function cvmx_usb_submit() or
 *        cvmx_usb_register_callback() */
typedef void (*cvmx_usb_callback_func_t)(cvmx_usb_state_t *state,
                                         cvmx_usb_callback_t reason,
                                         cvmx_usb_complete_t status,
                                         int pipe_handle, int submit_handle,
                                         int bytes_transferred, void *user_data);

/**
 * Flags to pass the initialization function.
 */
typedef enum
{
    CVMX_USB_INITIALIZE_FLAGS_CLOCK_XO_XI = 1<<0,       /**< The USB port uses a 12MHz crystal as clock source
                                                            at USB_XO and USB_XI. */
    CVMX_USB_INITIALIZE_FLAGS_CLOCK_XO_GND = 1<<1,      /**< The USB port uses 12/24/48MHz 2.5V board clock
                                                            source at USB_XO. USB_XI should be tied to GND.*/
    CVMX_USB_INITIALIZE_FLAGS_CLOCK_AUTO = 0,           /**< Automatically determine clock type based on function
                                                             in cvmx-helper-board.c. */
    CVMX_USB_INITIALIZE_FLAGS_CLOCK_MHZ_MASK  = 3<<3,       /**< Mask for clock speed field */
    CVMX_USB_INITIALIZE_FLAGS_CLOCK_12MHZ = 1<<3,       /**< Speed of reference clock or crystal */
    CVMX_USB_INITIALIZE_FLAGS_CLOCK_24MHZ = 2<<3,       /**< Speed of reference clock */
    CVMX_USB_INITIALIZE_FLAGS_CLOCK_48MHZ = 3<<3,       /**< Speed of reference clock */
    /* Bits 3-4 used to encode the clock frequency */
    CVMX_USB_INITIALIZE_FLAGS_NO_DMA = 1<<5,            /**< Disable DMA and used polled IO for data transfer use for the USB  */
    CVMX_USB_INITIALIZE_FLAGS_DEBUG_TRANSFERS = 1<<16,  /**< Enable extra console output for debugging USB transfers */
    CVMX_USB_INITIALIZE_FLAGS_DEBUG_CALLBACKS = 1<<17,  /**< Enable extra console output for debugging USB callbacks */
    CVMX_USB_INITIALIZE_FLAGS_DEBUG_INFO = 1<<18,       /**< Enable extra console output for USB informational data */
    CVMX_USB_INITIALIZE_FLAGS_DEBUG_CALLS = 1<<19,      /**< Enable extra console output for every function call */
    CVMX_USB_INITIALIZE_FLAGS_DEBUG_CSRS = 1<<20,       /**< Enable extra console output for every CSR access */
    CVMX_USB_INITIALIZE_FLAGS_DEBUG_ALL = ((CVMX_USB_INITIALIZE_FLAGS_DEBUG_CSRS<<1)-1) - (CVMX_USB_INITIALIZE_FLAGS_DEBUG_TRANSFERS-1),
} cvmx_usb_initialize_flags_t;

/**
 * Flags for passing when a pipe is created. Currently no flags
 * need to be passed.
 */
typedef enum
{
    CVMX_USB_PIPE_FLAGS_DEBUG_TRANSFERS = 1<<15,/**< Used to display CVMX_USB_INITIALIZE_FLAGS_DEBUG_TRANSFERS for a specific pipe only */
    __CVMX_USB_PIPE_FLAGS_OPEN = 1<<16,         /**< Used internally to determine if a pipe is open. Do not use */
    __CVMX_USB_PIPE_FLAGS_SCHEDULED = 1<<17,    /**< Used internally to determine if a pipe is actively using hardware. Do not use */
    __CVMX_USB_PIPE_FLAGS_NEED_PING = 1<<18,    /**< Used internally to determine if a high speed pipe is in the ping state. Do not use */
} cvmx_usb_pipe_flags_t;

/**
 * Return the number of USB ports supported by this Octeon
 * chip. If the chip doesn't support USB, or is not supported
 * by this API, a zero will be returned. Most Octeon chips
 * support one usb port, but some support two ports.
 * cvmx_usb_initialize() must be called on independent
 * cvmx_usb_state_t structures.
 *
 * @return Number of port, zero if usb isn't supported
 */
extern int cvmx_usb_get_num_ports(void);

/**
 * Initialize a USB port for use. This must be called before any
 * other access to the Octeon USB port is made. The port starts
 * off in the disabled state.
 *
 * @param state  Pointer to an empty cvmx_usb_state_t structure
 *               that will be populated by the initialize call.
 *               This structure is then passed to all other USB
 *               functions.
 * @param usb_port_number
 *               Which Octeon USB port to initialize.
 * @param flags  Flags to control hardware initialization. See
 *               cvmx_usb_initialize_flags_t for the flag
 *               definitions. Some flags are mandatory.
 *
 * @return CVMX_USB_SUCCESS or a negative error code defined in
 *         cvmx_usb_status_t.
 */
extern cvmx_usb_status_t cvmx_usb_initialize(cvmx_usb_state_t *state,
                                             int usb_port_number,
                                             cvmx_usb_initialize_flags_t flags);

/**
 * Shutdown a USB port after a call to cvmx_usb_initialize().
 * The port should be disabled with all pipes closed when this
 * function is called.
 *
 * @param state  USB device state populated by
 *               cvmx_usb_initialize().
 *
 * @return CVMX_USB_SUCCESS or a negative error code defined in
 *         cvmx_usb_status_t.
 */
extern cvmx_usb_status_t cvmx_usb_shutdown(cvmx_usb_state_t *state);

/**
 * Enable a USB port. After this call succeeds, the USB port is
 * online and servicing requests.
 *
 * @param state  USB device state populated by
 *               cvmx_usb_initialize().
 *
 * @return CVMX_USB_SUCCESS or a negative error code defined in
 *         cvmx_usb_status_t.
 */
extern cvmx_usb_status_t cvmx_usb_enable(cvmx_usb_state_t *state);

/**
 * Disable a USB port. After this call the USB port will not
 * generate data transfers and will not generate events.
 * Transactions in process will fail and call their
 * associated callbacks.
 *
 * @param state  USB device state populated by
 *               cvmx_usb_initialize().
 *
 * @return CVMX_USB_SUCCESS or a negative error code defined in
 *         cvmx_usb_status_t.
 */
extern cvmx_usb_status_t cvmx_usb_disable(cvmx_usb_state_t *state);

/**
 * Get the current state of the USB port. Use this call to
 * determine if the usb port has anything connected, is enabled,
 * or has some sort of error condition. The return value of this
 * call has "changed" bits to signal of the value of some fields
 * have changed between calls. These "changed" fields are based
 * on the last call to cvmx_usb_set_status(). In order to clear
 * them, you must update the status through cvmx_usb_set_status().
 *
 * @param state  USB device state populated by
 *               cvmx_usb_initialize().
 *
 * @return Port status information
 */
extern cvmx_usb_port_status_t cvmx_usb_get_status(cvmx_usb_state_t *state);

/**
 * Set the current state of the USB port. The status is used as
 * a reference for the "changed" bits returned by
 * cvmx_usb_get_status(). Other than serving as a reference, the
 * status passed to this function is not used. No fields can be
 * changed through this call.
 *
 * @param state  USB device state populated by
 *               cvmx_usb_initialize().
 * @param port_status
 *               Port status to set, most like returned by cvmx_usb_get_status()
 */
extern void cvmx_usb_set_status(cvmx_usb_state_t *state, cvmx_usb_port_status_t port_status);

/**
 * Open a virtual pipe between the host and a USB device. A pipe
 * must be opened before data can be transferred between a device
 * and Octeon.
 *
 * @param state      USB device state populated by
 *                   cvmx_usb_initialize().
 * @param flags      Optional pipe flags defined in
 *                   cvmx_usb_pipe_flags_t.
 * @param device_addr
 *                   USB device address to open the pipe to
 *                   (0-127).
 * @param endpoint_num
 *                   USB endpoint number to open the pipe to
 *                   (0-15).
 * @param device_speed
 *                   The speed of the device the pipe is going
 *                   to. This must match the device's speed,
 *                   which may be different than the port speed.
 * @param max_packet The maximum packet length the device can
 *                   transmit/receive (low speed=0-8, full
 *                   speed=0-1023, high speed=0-1024). This value
 *                   comes from the standard endpoint descriptor
 *                   field wMaxPacketSize bits <10:0>.
 * @param transfer_type
 *                   The type of transfer this pipe is for.
 * @param transfer_dir
 *                   The direction the pipe is in. This is not
 *                   used for control pipes.
 * @param interval   For ISOCHRONOUS and INTERRUPT transfers,
 *                   this is how often the transfer is scheduled
 *                   for. All other transfers should specify
 *                   zero. The units are in frames (8000/sec at
 *                   high speed, 1000/sec for full speed).
 * @param multi_count
 *                   For high speed devices, this is the maximum
 *                   allowed number of packet per microframe.
 *                   Specify zero for non high speed devices. This
 *                   value comes from the standard endpoint descriptor
 *                   field wMaxPacketSize bits <12:11>.
 * @param hub_device_addr
 *                   Hub device address this device is connected
 *                   to. Devices connected directly to Octeon
 *                   use zero. This is only used when the device
 *                   is full/low speed behind a high speed hub.
 *                   The address will be of the high speed hub,
 *                   not and full speed hubs after it.
 * @param hub_port   Which port on the hub the device is
 *                   connected. Use zero for devices connected
 *                   directly to Octeon. Like hub_device_addr,
 *                   this is only used for full/low speed
 *                   devices behind a high speed hub.
 *
 * @return A non negative value is a pipe handle. Negative
 *         values are failure codes from cvmx_usb_status_t.
 */
extern int cvmx_usb_open_pipe(cvmx_usb_state_t *state,
                              cvmx_usb_pipe_flags_t flags,
                              int device_addr, int endpoint_num,
                              cvmx_usb_speed_t device_speed, int max_packet,
                              cvmx_usb_transfer_t transfer_type,
                              cvmx_usb_direction_t transfer_dir, int interval,
                              int multi_count, int hub_device_addr,
                              int hub_port);

/**
 * Call to submit a USB Bulk transfer to a pipe.
 *
 * @param state     USB device state populated by
 *                  cvmx_usb_initialize().
 * @param pipe_handle
 *                  Handle to the pipe for the transfer.
 * @param buffer    Physical address of the data buffer in
 *                  memory. Note that this is NOT A POINTER, but
 *                  the full 64bit physical address of the
 *                  buffer. This may be zero if buffer_length is
 *                  zero.
 * @param buffer_length
 *                  Length of buffer in bytes.
 * @param callback  Function to call when this transaction
 *                  completes. If the return value of this
 *                  function isn't an error, then this function
 *                  is guaranteed to be called when the
 *                  transaction completes. If this parameter is
 *                  NULL, then the generic callback registered
 *                  through cvmx_usb_register_callback is
 *                  called. If both are NULL, then there is no
 *                  way to know when a transaction completes.
 * @param user_data User supplied data returned when the
 *                  callback is called. This is only used if
 *                  callback in not NULL.
 *
 * @return A submitted transaction handle or negative on
 *         failure. Negative values are failure codes from
 *         cvmx_usb_status_t.
 */
extern int cvmx_usb_submit_bulk(cvmx_usb_state_t *state, int pipe_handle,
                                uint64_t buffer, int buffer_length,
                                cvmx_usb_callback_func_t callback,
                                void *user_data);

/**
 * Call to submit a USB Interrupt transfer to a pipe.
 *
 * @param state     USB device state populated by
 *                  cvmx_usb_initialize().
 * @param pipe_handle
 *                  Handle to the pipe for the transfer.
 * @param buffer    Physical address of the data buffer in
 *                  memory. Note that this is NOT A POINTER, but
 *                  the full 64bit physical address of the
 *                  buffer. This may be zero if buffer_length is
 *                  zero.
 * @param buffer_length
 *                  Length of buffer in bytes.
 * @param callback  Function to call when this transaction
 *                  completes. If the return value of this
 *                  function isn't an error, then this function
 *                  is guaranteed to be called when the
 *                  transaction completes. If this parameter is
 *                  NULL, then the generic callback registered
 *                  through cvmx_usb_register_callback is
 *                  called. If both are NULL, then there is no
 *                  way to know when a transaction completes.
 * @param user_data User supplied data returned when the
 *                  callback is called. This is only used if
 *                  callback in not NULL.
 *
 * @return A submitted transaction handle or negative on
 *         failure. Negative values are failure codes from
 *         cvmx_usb_status_t.
 */
extern int cvmx_usb_submit_interrupt(cvmx_usb_state_t *state, int pipe_handle,
                                     uint64_t buffer, int buffer_length,
                                     cvmx_usb_callback_func_t callback,
                                     void *user_data);

/**
 * Call to submit a USB Control transfer to a pipe.
 *
 * @param state     USB device state populated by
 *                  cvmx_usb_initialize().
 * @param pipe_handle
 *                  Handle to the pipe for the transfer.
 * @param control_header
 *                  USB 8 byte control header physical address.
 *                  Note that this is NOT A POINTER, but the
 *                  full 64bit physical address of the buffer.
 * @param buffer    Physical address of the data buffer in
 *                  memory. Note that this is NOT A POINTER, but
 *                  the full 64bit physical address of the
 *                  buffer. This may be zero if buffer_length is
 *                  zero.
 * @param buffer_length
 *                  Length of buffer in bytes.
 * @param callback  Function to call when this transaction
 *                  completes. If the return value of this
 *                  function isn't an error, then this function
 *                  is guaranteed to be called when the
 *                  transaction completes. If this parameter is
 *                  NULL, then the generic callback registered
 *                  through cvmx_usb_register_callback is
 *                  called. If both are NULL, then there is no
 *                  way to know when a transaction completes.
 * @param user_data User supplied data returned when the
 *                  callback is called. This is only used if
 *                  callback in not NULL.
 *
 * @return A submitted transaction handle or negative on
 *         failure. Negative values are failure codes from
 *         cvmx_usb_status_t.
 */
extern int cvmx_usb_submit_control(cvmx_usb_state_t *state, int pipe_handle,
                                   uint64_t control_header,
                                   uint64_t buffer, int buffer_length,
                                   cvmx_usb_callback_func_t callback,
                                   void *user_data);

/**
 * Flags to pass the cvmx_usb_submit_isochronous() function.
 */
typedef enum
{
    CVMX_USB_ISOCHRONOUS_FLAGS_ALLOW_SHORT = 1<<0,  /**< Do not return an error if a transfer is less than the maximum packet size of the device */
    CVMX_USB_ISOCHRONOUS_FLAGS_ASAP = 1<<1,         /**< Schedule the transaction as soon as possible */
} cvmx_usb_isochronous_flags_t;

/**
 * Call to submit a USB Isochronous transfer to a pipe.
 *
 * @param state     USB device state populated by
 *                  cvmx_usb_initialize().
 * @param pipe_handle
 *                  Handle to the pipe for the transfer.
 * @param start_frame
 *                  Number of frames into the future to schedule
 *                  this transaction.
 * @param flags     Flags to control the transfer. See
 *                  cvmx_usb_isochronous_flags_t for the flag
 *                  definitions.
 * @param number_packets
 *                  Number of sequential packets to transfer.
 *                  "packets" is a pointer to an array of this
 *                  many packet structures.
 * @param packets   Description of each transfer packet as
 *                  defined by cvmx_usb_iso_packet_t. The array
 *                  pointed to here must stay valid until the
 *                  complete callback is called.
 * @param buffer    Physical address of the data buffer in
 *                  memory. Note that this is NOT A POINTER, but
 *                  the full 64bit physical address of the
 *                  buffer. This may be zero if buffer_length is
 *                  zero.
 * @param buffer_length
 *                  Length of buffer in bytes.
 * @param callback  Function to call when this transaction
 *                  completes. If the return value of this
 *                  function isn't an error, then this function
 *                  is guaranteed to be called when the
 *                  transaction completes. If this parameter is
 *                  NULL, then the generic callback registered
 *                  through cvmx_usb_register_callback is
 *                  called. If both are NULL, then there is no
 *                  way to know when a transaction completes.
 * @param user_data User supplied data returned when the
 *                  callback is called. This is only used if
 *                  callback in not NULL.
 *
 * @return A submitted transaction handle or negative on
 *         failure. Negative values are failure codes from
 *         cvmx_usb_status_t.
 */
extern int cvmx_usb_submit_isochronous(cvmx_usb_state_t *state, int pipe_handle,
                                       int start_frame, int flags,
                                       int number_packets,
                                       cvmx_usb_iso_packet_t packets[],
                                       uint64_t buffer, int buffer_length,
                                       cvmx_usb_callback_func_t callback,
                                       void *user_data);

/**
 * Cancel one outstanding request in a pipe. Canceling a request
 * can fail if the transaction has already completed before cancel
 * is called. Even after a successful cancel call, it may take
 * a frame or two for the cvmx_usb_poll() function to call the
 * associated callback.
 *
 * @param state  USB device state populated by
 *               cvmx_usb_initialize().
 * @param pipe_handle
 *               Pipe handle to cancel requests in.
 * @param submit_handle
 *               Handle to transaction to cancel, returned by the submit function.
 *
 * @return CVMX_USB_SUCCESS or a negative error code defined in
 *         cvmx_usb_status_t.
 */
extern cvmx_usb_status_t cvmx_usb_cancel(cvmx_usb_state_t *state,
                                         int pipe_handle, int submit_handle);


/**
 * Cancel all outstanding requests in a pipe. Logically all this
 * does is call cvmx_usb_cancel() in a loop.
 *
 * @param state  USB device state populated by
 *               cvmx_usb_initialize().
 * @param pipe_handle
 *               Pipe handle to cancel requests in.
 *
 * @return CVMX_USB_SUCCESS or a negative error code defined in
 *         cvmx_usb_status_t.
 */
extern cvmx_usb_status_t cvmx_usb_cancel_all(cvmx_usb_state_t *state,
                                             int pipe_handle);

/**
 * Close a pipe created with cvmx_usb_open_pipe().
 *
 * @param state  USB device state populated by
 *               cvmx_usb_initialize().
 * @param pipe_handle
 *               Pipe handle to close.
 *
 * @return CVMX_USB_SUCCESS or a negative error code defined in
 *         cvmx_usb_status_t. CVMX_USB_BUSY is returned if the
 *         pipe has outstanding transfers.
 */
extern cvmx_usb_status_t cvmx_usb_close_pipe(cvmx_usb_state_t *state,
                                             int pipe_handle);

/**
 * Register a function to be called when various USB events occur.
 *
 * @param state     USB device state populated by
 *                  cvmx_usb_initialize().
 * @param reason    Which event to register for.
 * @param callback  Function to call when the event occurs.
 * @param user_data User data parameter to the function.
 *
 * @return CVMX_USB_SUCCESS or a negative error code defined in
 *         cvmx_usb_status_t.
 */
extern cvmx_usb_status_t cvmx_usb_register_callback(cvmx_usb_state_t *state,
                                                    cvmx_usb_callback_t reason,
                                                    cvmx_usb_callback_func_t callback,
                                                    void *user_data);

/**
 * Get the current USB protocol level frame number. The frame
 * number is always in the range of 0-0x7ff.
 *
 * @param state  USB device state populated by
 *               cvmx_usb_initialize().
 *
 * @return USB frame number
 */
extern int cvmx_usb_get_frame_number(cvmx_usb_state_t *state);

/**
 * Poll the USB block for status and call all needed callback
 * handlers. This function is meant to be called in the interrupt
 * handler for the USB controller. It can also be called
 * periodically in a loop for non-interrupt based operation.
 *
 * @param state  USB device state populated by
 *               cvmx_usb_initialize().
 *
 * @return CVMX_USB_SUCCESS or a negative error code defined in
 *         cvmx_usb_status_t.
 */
extern cvmx_usb_status_t cvmx_usb_poll(cvmx_usb_state_t *state);

/*
 * The FreeBSD host driver uses these functions to manipulate the toggle to deal
 * more easily with endpoint management.
 */
extern void cvmx_usb_set_toggle(cvmx_usb_state_t *state, int endpoint_num, int toggle);
extern int cvmx_usb_get_toggle(cvmx_usb_state_t *state, int endpoint_num);

#ifdef	__cplusplus
}
#endif

#endif  /* __CVMX_USB_H__ */