| /***********************license start*************** |
| * Copyright (c) 2003-2010 Cavium Networks (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 Networks 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 NETWORKS 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); |
| |
| #ifdef __cplusplus |
| } |
| #endif |
| |
| #endif /* __CVMX_USB_H__ */ |
