| /* |
| Copyright (c) 2011 Arduino. All right reserved. |
| |
| This library is free software; you can redistribute it and/or |
| modify it under the terms of the GNU Lesser General Public |
| License as published by the Free Software Foundation; either |
| version 2.1 of the License, or (at your option) any later version. |
| |
| This library is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| See the GNU Lesser General Public License for more details. |
| |
| You should have received a copy of the GNU Lesser General Public |
| License along with this library; if not, write to the Free Software |
| Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
| */ |
| |
| #ifndef _USB_DRIVER_ |
| #define _USB_DRIVER_ |
| |
| #include <stdint.h> |
| |
| extern void UDD_WaitIN(void) ; |
| extern void UDD_WaitOUT(void) ; |
| extern void UDD_ClearIN(void) ; |
| extern void UDD_ClearOUT(void) ; |
| extern uint32_t UDD_WaitForINOrOUT(void) ; |
| |
| extern void UDD_ClearRxFlag( unsigned char bEndpoint ) ; |
| |
| |
| extern uint32_t UDD_ReceivedSetupInt(void); |
| extern void UDD_ClearSetupInt(void); |
| |
| extern uint32_t UDD_ReadWriteAllowed(uint32_t ep) ; |
| |
| |
| extern uint32_t UDD_FifoByteCount(uint32_t ep) ; |
| extern uint8_t UDD_FifoFree(void) ; |
| |
| extern void UDD_ReleaseRX(uint32_t ep) ; |
| extern void UDD_ReleaseTX(uint32_t ep) ; |
| extern uint8_t UDD_FrameNumber(void) ; |
| |
| extern uint8_t UDD_GetConfiguration(void) ; |
| |
| |
| |
| |
| extern uint32_t UDD_Send(uint32_t ep, const void* data, uint32_t len); |
| extern void UDD_Send8(uint32_t ep, uint8_t data ); |
| extern uint8_t UDD_Recv8(uint32_t ep); |
| extern void UDD_Recv(uint32_t ep, uint8_t* data, uint32_t len); |
| |
| |
| |
| extern void UDD_InitEndpoints(const uint32_t* eps_table, const uint32_t ul_eps_table_size); |
| |
| extern void UDD_InitControl(int end) ; |
| |
| extern uint32_t UDD_Init(void) ; |
| extern void UDD_InitEP( uint32_t ul_ep, uint32_t ul_ep_cfg ); |
| |
| extern void UDD_Attach(void) ; |
| extern void UDD_Detach(void) ; |
| extern void UDD_SetStack(void (*pf_isr)(void)); |
| extern void UDD_SetAddress(uint32_t addr); |
| extern void UDD_Stall(void); |
| extern uint32_t UDD_GetFrameNumber(void); |
| |
| /*! \name Usual Types |
| */ |
| |
| //! @{ |
| |
| typedef unsigned char Bool; //!< Boolean. |
| #ifndef __cplusplus |
| #if !defined(__bool_true_false_are_defined) |
| typedef unsigned char bool; //!< Boolean. |
| #endif |
| #endif |
| typedef int8_t S8 ; //!< 8-bit signed integer. |
| typedef uint8_t U8 ; //!< 8-bit unsigned integer. |
| typedef int16_t S16; //!< 16-bit signed integer. |
| typedef uint16_t U16; //!< 16-bit unsigned integer. |
| typedef uint16_t le16_t; |
| typedef uint16_t be16_t; |
| typedef int32_t S32; //!< 32-bit signed integer. |
| typedef uint32_t U32; //!< 32-bit unsigned integer. |
| typedef uint32_t le32_t; |
| typedef uint32_t be32_t; |
| typedef int64_t S64; //!< 64-bit signed integer. |
| typedef uint64_t U64; //!< 64-bit unsigned integer. |
| typedef float F32; //!< 32-bit floating-point number. |
| typedef double F64; //!< 64-bit floating-point number. |
| typedef uint32_t iram_size_t; |
| |
| //! @} |
| |
| /*! \name Bit-Field Handling |
| */ |
| //! @{ |
| |
| /*! \brief Reads the bits of a value specified by a given bit-mask. |
| * |
| * \param value Value to read bits from. |
| * \param mask Bit-mask indicating bits to read. |
| * |
| * \return Read bits. |
| */ |
| #define Rd_bits( value, mask) ((value) & (mask)) |
| |
| /*! \brief Writes the bits of a C lvalue specified by a given bit-mask. |
| * |
| * \param lvalue C lvalue to write bits to. |
| * \param mask Bit-mask indicating bits to write. |
| * \param bits Bits to write. |
| * |
| * \return Resulting value with written bits. |
| */ |
| #define Wr_bits(lvalue, mask, bits) ((lvalue) = ((lvalue) & ~(mask)) |\ |
| ((bits ) & (mask))) |
| |
| /*! \brief Tests the bits of a value specified by a given bit-mask. |
| * |
| * \param value Value of which to test bits. |
| * \param mask Bit-mask indicating bits to test. |
| * |
| * \return \c 1 if at least one of the tested bits is set, else \c 0. |
| */ |
| #define Tst_bits( value, mask) (Rd_bits(value, mask) != 0) |
| |
| /*! \brief Clears the bits of a C lvalue specified by a given bit-mask. |
| * |
| * \param lvalue C lvalue of which to clear bits. |
| * \param mask Bit-mask indicating bits to clear. |
| * |
| * \return Resulting value with cleared bits. |
| */ |
| #define Clr_bits(lvalue, mask) ((lvalue) &= ~(mask)) |
| |
| /*! \brief Sets the bits of a C lvalue specified by a given bit-mask. |
| * |
| * \param lvalue C lvalue of which to set bits. |
| * \param mask Bit-mask indicating bits to set. |
| * |
| * \return Resulting value with set bits. |
| */ |
| #define Set_bits(lvalue, mask) ((lvalue) |= (mask)) |
| |
| /*! \brief Toggles the bits of a C lvalue specified by a given bit-mask. |
| * |
| * \param lvalue C lvalue of which to toggle bits. |
| * \param mask Bit-mask indicating bits to toggle. |
| * |
| * \return Resulting value with toggled bits. |
| */ |
| #define Tgl_bits(lvalue, mask) ((lvalue) ^= (mask)) |
| |
| /*! \brief Reads the bit-field of a value specified by a given bit-mask. |
| * |
| * \param value Value to read a bit-field from. |
| * \param mask Bit-mask indicating the bit-field to read. |
| * |
| * \return Read bit-field. |
| */ |
| #define Rd_bitfield( value, mask) (Rd_bits( value, mask) >> ctz(mask)) |
| |
| /*! \brief Writes the bit-field of a C lvalue specified by a given bit-mask. |
| * |
| * \param lvalue C lvalue to write a bit-field to. |
| * \param mask Bit-mask indicating the bit-field to write. |
| * \param bitfield Bit-field to write. |
| * |
| * \return Resulting value with written bit-field. |
| */ |
| #define Wr_bitfield(lvalue, mask, bitfield) (Wr_bits(lvalue, mask, (U32)(bitfield) << ctz(mask))) |
| |
| //! @} |
| |
| /*! \name Token Paste |
| * |
| * Paste N preprocessing tokens together, these tokens being allowed to be \#defined. |
| * |
| * May be used only within macros with the tokens passed as arguments if the tokens are \#defined. |
| * |
| * For example, writing TPASTE2(U, WIDTH) within a macro \#defined by |
| * UTYPE(WIDTH) and invoked as UTYPE(UL_WIDTH) with UL_WIDTH \#defined as 32 is |
| * equivalent to writing U32. |
| */ |
| |
| //! @{ |
| |
| #define TPASTE2( a, b) a##b |
| #define TPASTE3( a, b, c) a##b##c |
| #define TPASTE4( a, b, c, d) a##b##c##d |
| #define TPASTE5( a, b, c, d, e) a##b##c##d##e |
| #define TPASTE6( a, b, c, d, e, f) a##b##c##d##e##f |
| #define TPASTE7( a, b, c, d, e, f, g) a##b##c##d##e##f##g |
| #define TPASTE8( a, b, c, d, e, f, g, h) a##b##c##d##e##f##g##h |
| #define TPASTE9( a, b, c, d, e, f, g, h, i) a##b##c##d##e##f##g##h##i |
| #define TPASTE10(a, b, c, d, e, f, g, h, i, j) a##b##c##d##e##f##g##h##i##j |
| |
| //! @} |
| |
| /*! \name Absolute Token Paste |
| * |
| * Paste N preprocessing tokens together, these tokens being allowed to be \#defined. |
| * |
| * No restriction of use if the tokens are \#defined. |
| * |
| * For example, writing ATPASTE2(U, UL_WIDTH) anywhere with UL_WIDTH \#defined |
| * as 32 is equivalent to writing U32. |
| */ |
| |
| //! @{ |
| |
| #define ATPASTE2( a, b) TPASTE2( a, b) |
| #define ATPASTE3( a, b, c) TPASTE3( a, b, c) |
| #define ATPASTE4( a, b, c, d) TPASTE4( a, b, c, d) |
| #define ATPASTE5( a, b, c, d, e) TPASTE5( a, b, c, d, e) |
| #define ATPASTE6( a, b, c, d, e, f) TPASTE6( a, b, c, d, e, f) |
| #define ATPASTE7( a, b, c, d, e, f, g) TPASTE7( a, b, c, d, e, f, g) |
| #define ATPASTE8( a, b, c, d, e, f, g, h) TPASTE8( a, b, c, d, e, f, g, h) |
| #define ATPASTE9( a, b, c, d, e, f, g, h, i) TPASTE9( a, b, c, d, e, f, g, h, i) |
| #define ATPASTE10(a, b, c, d, e, f, g, h, i, j) TPASTE10(a, b, c, d, e, f, g, h, i, j) |
| |
| //! @} |
| |
| /*! \brief Counts the trailing zero bits of the given value considered as a 32-bit integer. |
| * |
| * \param u Value of which to count the trailing zero bits. |
| * |
| * \return The count of trailing zero bits in \a u. |
| */ |
| #if (defined __GNUC__) || (defined __CC_ARM) |
| # define ctz(u) __builtin_ctz(u) |
| #else |
| # define ctz(u) ((u) & (1ul << 0) ? 0 : \ |
| (u) & (1ul << 1) ? 1 : \ |
| (u) & (1ul << 2) ? 2 : \ |
| (u) & (1ul << 3) ? 3 : \ |
| (u) & (1ul << 4) ? 4 : \ |
| (u) & (1ul << 5) ? 5 : \ |
| (u) & (1ul << 6) ? 6 : \ |
| (u) & (1ul << 7) ? 7 : \ |
| (u) & (1ul << 8) ? 8 : \ |
| (u) & (1ul << 9) ? 9 : \ |
| (u) & (1ul << 10) ? 10 : \ |
| (u) & (1ul << 11) ? 11 : \ |
| (u) & (1ul << 12) ? 12 : \ |
| (u) & (1ul << 13) ? 13 : \ |
| (u) & (1ul << 14) ? 14 : \ |
| (u) & (1ul << 15) ? 15 : \ |
| (u) & (1ul << 16) ? 16 : \ |
| (u) & (1ul << 17) ? 17 : \ |
| (u) & (1ul << 18) ? 18 : \ |
| (u) & (1ul << 19) ? 19 : \ |
| (u) & (1ul << 20) ? 20 : \ |
| (u) & (1ul << 21) ? 21 : \ |
| (u) & (1ul << 22) ? 22 : \ |
| (u) & (1ul << 23) ? 23 : \ |
| (u) & (1ul << 24) ? 24 : \ |
| (u) & (1ul << 25) ? 25 : \ |
| (u) & (1ul << 26) ? 26 : \ |
| (u) & (1ul << 27) ? 27 : \ |
| (u) & (1ul << 28) ? 28 : \ |
| (u) & (1ul << 29) ? 29 : \ |
| (u) & (1ul << 30) ? 30 : \ |
| (u) & (1ul << 31) ? 31 : \ |
| 32) |
| #endif |
| |
| /*! \name Zero-Bit Counting |
| * |
| * Under GCC, __builtin_clz and __builtin_ctz behave like macros when |
| * applied to constant expressions (values known at compile time), so they are |
| * more optimized than the use of the corresponding assembly instructions and |
| * they can be used as constant expressions e.g. to initialize objects having |
| * static storage duration, and like the corresponding assembly instructions |
| * when applied to non-constant expressions (values unknown at compile time), so |
| * they are more optimized than an assembly periphrasis. Hence, clz and ctz |
| * ensure a possible and optimized behavior for both constant and non-constant |
| * expressions. |
| */ |
| //! @{ |
| |
| /*! \brief Counts the leading zero bits of the given value considered as a 32-bit integer. |
| * |
| * \param u Value of which to count the leading zero bits. |
| * |
| * \return The count of leading zero bits in \a u. |
| */ |
| #if (defined __GNUC__) || (defined __CC_ARM) |
| # define clz(u) __builtin_clz(u) |
| #elif (defined __ICCARM__) |
| # define clz(u) __CLZ(u) |
| #else |
| # define clz(u) (((u) == 0) ? 32 : \ |
| ((u) & (1ul << 31)) ? 0 : \ |
| ((u) & (1ul << 30)) ? 1 : \ |
| ((u) & (1ul << 29)) ? 2 : \ |
| ((u) & (1ul << 28)) ? 3 : \ |
| ((u) & (1ul << 27)) ? 4 : \ |
| ((u) & (1ul << 26)) ? 5 : \ |
| ((u) & (1ul << 25)) ? 6 : \ |
| ((u) & (1ul << 24)) ? 7 : \ |
| ((u) & (1ul << 23)) ? 8 : \ |
| ((u) & (1ul << 22)) ? 9 : \ |
| ((u) & (1ul << 21)) ? 10 : \ |
| ((u) & (1ul << 20)) ? 11 : \ |
| ((u) & (1ul << 19)) ? 12 : \ |
| ((u) & (1ul << 18)) ? 13 : \ |
| ((u) & (1ul << 17)) ? 14 : \ |
| ((u) & (1ul << 16)) ? 15 : \ |
| ((u) & (1ul << 15)) ? 16 : \ |
| ((u) & (1ul << 14)) ? 17 : \ |
| ((u) & (1ul << 13)) ? 18 : \ |
| ((u) & (1ul << 12)) ? 19 : \ |
| ((u) & (1ul << 11)) ? 20 : \ |
| ((u) & (1ul << 10)) ? 21 : \ |
| ((u) & (1ul << 9)) ? 22 : \ |
| ((u) & (1ul << 8)) ? 23 : \ |
| ((u) & (1ul << 7)) ? 24 : \ |
| ((u) & (1ul << 6)) ? 25 : \ |
| ((u) & (1ul << 5)) ? 26 : \ |
| ((u) & (1ul << 4)) ? 27 : \ |
| ((u) & (1ul << 3)) ? 28 : \ |
| ((u) & (1ul << 2)) ? 29 : \ |
| ((u) & (1ul << 1)) ? 30 : \ |
| 31) |
| #endif |
| |
| /*! \name Mathematics |
| * |
| * The same considerations as for clz and ctz apply here but GCC does not |
| * provide built-in functions to access the assembly instructions abs, min and |
| * max and it does not produce them by itself in most cases, so two sets of |
| * macros are defined here: |
| * - Abs, Min and Max to apply to constant expressions (values known at |
| * compile time); |
| * - abs, min and max to apply to non-constant expressions (values unknown at |
| * compile time), abs is found in stdlib.h. |
| */ |
| //! @{ |
| |
| /*! \brief Takes the absolute value of \a a. |
| * |
| * \param a Input value. |
| * |
| * \return Absolute value of \a a. |
| * |
| * \note More optimized if only used with values known at compile time. |
| */ |
| #define Abs(a) (((a) < 0 ) ? -(a) : (a)) |
| |
| /*! \brief Takes the minimal value of \a a and \a b. |
| * |
| * \param a Input value. |
| * \param b Input value. |
| * |
| * \return Minimal value of \a a and \a b. |
| * |
| * \note More optimized if only used with values known at compile time. |
| */ |
| #define Min(a, b) (((a) < (b)) ? (a) : (b)) |
| |
| /*! \brief Takes the maximal value of \a a and \a b. |
| * |
| * \param a Input value. |
| * \param b Input value. |
| * |
| * \return Maximal value of \a a and \a b. |
| * |
| * \note More optimized if only used with values known at compile time. |
| */ |
| #define Max(a, b) (((a) > (b)) ? (a) : (b)) |
| |
| // abs() is already defined by stdlib.h |
| |
| /*! \brief Takes the minimal value of \a a and \a b. |
| * |
| * \param a Input value. |
| * \param b Input value. |
| * |
| * \return Minimal value of \a a and \a b. |
| * |
| * \note More optimized if only used with values unknown at compile time. |
| */ |
| #define min(a, b) Min(a, b) |
| |
| /*! \brief Takes the maximal value of \a a and \a b. |
| * |
| * \param a Input value. |
| * \param b Input value. |
| * |
| * \return Maximal value of \a a and \a b. |
| * |
| * \note More optimized if only used with values unknown at compile time. |
| */ |
| #define max(a, b) Max(a, b) |
| |
| //! @} |
| |
| #endif /* _USB_DRIVER_*/ |
