mirror of
https://github.com/arduino/Arduino.git
synced 2024-11-30 11:24:12 +01:00
407 lines
15 KiB
C
407 lines
15 KiB
C
/*
|
|
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_*/
|