gitbot/qmk_firmware
0
0
Fork 0
mirror of https://github.com/qmk/qmk_firmware.git synced 2025-07-16 04:41:28 +00:00
Code Issues Packages Projects Releases Wiki Activity

Oops - re-order Ringbuffer.h inline functions to prevent compile errors due to forward references.

Browse Source
This commit is contained in:
Dean Camera 2011-07-11 09:42:13 +00:00
parent 87ea060afe
commit d771b1ff8f
1 changed files with 25 additions and 25 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
LUFA/Drivers/Misc/RingBuffer.h
View File

@ -126,7 +126,7 @@
* \param[out] DataPtr Pointer to a global array that will hold the data stored into the ring buffer. * \param[out] DataPtr Pointer to a global array that will hold the data stored into the ring buffer.
* \param[out] Size Maximum number of bytes that can be stored in the underlying data array. * \param[out] Size Maximum number of bytes that can be stored in the underlying data array.
*/ */
static inline void RingBuffer_InitBuffer(RingBuffer_t* const Buffer, uint8_t* const DataPtr, const uint16_t Size) static inline void RingBuffer_InitBuffer(RingBuffer_t* Buffer, uint8_t* const DataPtr, const uint16_t Size)
{ {
GCC_FORCE_POINTER_ACCESS(Buffer); GCC_FORCE_POINTER_ACCESS(Buffer);
@ -143,23 +143,6 @@
SetGlobalInterruptMask(CurrentGlobalInt); SetGlobalInterruptMask(CurrentGlobalInt);
} }
/** Retrieves the free space in a particular buffer. This value is computed by entering an atomic lock
* on the buffer, so that the buffer cannot be modified while the computation takes place.
*
* \note The value returned by this function is guaranteed to only be the maximum number of bytes
* free in the given buffer; this value may change as other threads write new data, thus
* the returned number should be used only to determine how many successive writes may safely
* be performed on the buffer when there is a single writer thread.
*
* \param[in] Buffer Pointer to a ring buffer structure whose free count is to be computed.
*
* \return Number of free bytes in the buffer.
*/
static inline uint16_t RingBuffer_GetFreeCount(RingBuffer_t* const Buffer)
{
return (Buffer->Size - RingBuffer_GetCount(Buffer));
}
/** Retrieves the current number of bytes stored in a particular buffer. This value is computed /** Retrieves the current number of bytes stored in a particular buffer. This value is computed
* by entering an atomic lock on the buffer, so that the buffer cannot be modified while the * by entering an atomic lock on the buffer, so that the buffer cannot be modified while the
* computation takes place. This value should be cached when reading out the contents of the buffer, * computation takes place. This value should be cached when reading out the contents of the buffer,
@ -187,17 +170,21 @@
return Count; return Count;
} }
/** Atomically determines if the specified ring buffer contains any free space. This should /** Retrieves the free space in a particular buffer. This value is computed by entering an atomic lock
* be tested before storing data to the buffer, to ensure that no data is lost due to a * on the buffer, so that the buffer cannot be modified while the computation takes place.
* buffer overrun.
* *
* \param[in,out] Buffer Pointer to a ring buffer structure to insert into. * \note The value returned by this function is guaranteed to only be the maximum number of bytes
* free in the given buffer; this value may change as other threads write new data, thus
* the returned number should be used only to determine how many successive writes may safely
* be performed on the buffer when there is a single writer thread.
* *
* \return Boolean \c true if the buffer contains no free space, false otherwise. * \param[in] Buffer Pointer to a ring buffer structure whose free count is to be computed.
*
* \return Number of free bytes in the buffer.
*/ */
static inline bool RingBuffer_IsFull(RingBuffer_t* const Buffer) static inline uint16_t RingBuffer_GetFreeCount(RingBuffer_t* const Buffer)
{ {
return (RingBuffer_GetCount(Buffer) == Buffer->Size); return (Buffer->Size - RingBuffer_GetCount(Buffer));
} }
/** Atomically determines if the specified ring buffer contains any data. This should /** Atomically determines if the specified ring buffer contains any data. This should
@ -217,6 +204,19 @@
return (RingBuffer_GetCount(Buffer) == 0); return (RingBuffer_GetCount(Buffer) == 0);
} }
/** Atomically determines if the specified ring buffer contains any free space. This should
* be tested before storing data to the buffer, to ensure that no data is lost due to a
* buffer overrun.
*
* \param[in,out] Buffer Pointer to a ring buffer structure to insert into.
*
* \return Boolean \c true if the buffer contains no free space, false otherwise.
*/
static inline bool RingBuffer_IsFull(RingBuffer_t* const Buffer)
{
return (RingBuffer_GetCount(Buffer) == Buffer->Size);
}
/** Inserts an element into the ring buffer. /** Inserts an element into the ring buffer.
* *
* \note Only one execution thread (main program thread or an ISR) may insert into a single buffer * \note Only one execution thread (main program thread or an ISR) may insert into a single buffer