/**
* \brief Initializes the memory pool.
* \param[in] pool memory pool
* \param[in] mem pool memory
* \param[in] mem_size size of pool memory
* \param[in] buf_size size of a single buffer
* \param[in] num_bufs number of buffers
* \return Returns U_SUCC if successful.
*/
URET uffs_PoolInit(uffs_Pool *pool,
void *mem, u32 mem_size, u32 buf_size, u32 num_bufs)
{
unsigned int i;
uffs_PoolEntry *e1, *e2;
uffs_Assert(pool, "pool missing");
uffs_Assert(mem, "pool memory missing");
uffs_Assert(num_bufs > 0, "not enough buffers");
uffs_Assert(buf_size % sizeof(void *) == 0,
"buffer size not aligned to pointer size");
uffs_Assert(mem_size == num_bufs * buf_size,
"pool memory size is wrong");
pool->mem = (u8 *)mem;
pool->buf_size = buf_size;
pool->num_bufs = num_bufs;
pool->sem = uffs_SemCreate(1);
uffs_SemWait(pool->sem);
// Initialize the free_list
e1 = e2 = pool->free_list = (uffs_PoolEntry *) pool->mem;
for (i = 1; i < pool->num_bufs; i++) {
e2 = (uffs_PoolEntry *) (pool->mem + i * pool->buf_size);
e1->next = e2;
e1 = e2;
}
e2->next = NULL;
uffs_SemSignal(pool->sem);
return U_SUCC;
}
void uffs_DeviceLock(uffs_Device *dev)
{
uffs_SemWait(dev->lock.sem);
if (dev->lock.counter != 0) {
uffs_Perror(UFFS_MSG_NORMAL,
"Lock device, counter %d NOT zero?!", dev->lock.counter);
}
dev->lock.counter++;
}
/**
* \brief Get a buffer from the memory pool.
* This version is locked and should be used when multiple threads access the
* same memory pool.
* \param[in] pool memory pool
* \return Returns a pointer to the buffer or NULL if none is available.
*/
void *uffs_PoolGetLocked(uffs_Pool *pool)
{
uffs_PoolEntry *e;
uffs_Assert(pool, "pool missing");
uffs_SemWait(pool->sem);
e = pool->free_list;
if (e)
pool->free_list = e->next;
uffs_SemSignal(pool->sem);
return e;
}
/**
* \brief Puts a buffer back to the memory pool.
* This version is locked and should be used when multiple threads access the
* same memory pool.
* \param[in] pool memory pool
* \param[in] p buffer to put back
* \return Returns 0 if successful.
*/
int uffs_PoolPutLocked(uffs_Pool *pool, void *p)
{
uffs_PoolEntry *e = (uffs_PoolEntry *)p;
uffs_Assert(pool, "pool missing");
if (e) {
uffs_SemWait(pool->sem);
e->next = pool->free_list;
pool->free_list = e;
uffs_SemSignal(pool->sem);
return 0;
}
return -1;
}
/**
* \brief Puts a buffer back to the memory pool.
* This version is locked and should be used when multiple threads access the
* same memory pool.
* \param[in] pool memory pool
* \param[in] p buffer to put back
* \return Returns 0 if successful.
*/
int uffs_PoolPutLocked(uffs_Pool *pool, void *p)
{
uffs_PoolEntry *e = (uffs_PoolEntry *)p;
if (!uffs_Assert(pool != NULL, "pool missing"))
return -1;
if (!uffs_Assert(pool->sem != OSSEM_NOT_INITED, "pool semaphore not initialized"))
return -1;
if (e) {
uffs_SemWait(pool->sem);
e->next = pool->free_list;
pool->free_list = e;
uffs_SemSignal(pool->sem);
return 0;
}
return -1;
}
/**
* \brief Get a buffer from the memory pool.
* This version is locked and should be used when multiple threads access the
* same memory pool.
* \param[in] pool memory pool
* \return Returns a pointer to the buffer or NULL if none is available.
*/
void *uffs_PoolGetLocked(uffs_Pool *pool)
{
uffs_PoolEntry *e;
if (!uffs_Assert(pool != NULL, "pool missing"))
return NULL;
if (!uffs_Assert(pool->sem != OSSEM_NOT_INITED, "pool semaphore not initialized"))
return NULL;
uffs_SemWait(pool->sem);
e = pool->free_list;
if (e)
pool->free_list = e->next;
uffs_SemSignal(pool->sem);
return e;
}
/**
* \brief Initializes the memory pool.
* \param[in] pool memory pool
* \param[in] mem pool memory
* \param[in] mem_size size of pool memory
* \param[in] buf_size size of a single buffer
* \param[in] num_bufs number of buffers
* \param[in] lock create semaphore for locking the memory pool
* \return Returns U_SUCC if successful.
*/
URET uffs_PoolInit(uffs_Pool *pool,
void *mem, u32 mem_size, u32 buf_size, u32 num_bufs, UBOOL lock)
{
unsigned int i;
uffs_PoolEntry *e1, *e2;
if (!uffs_Assert(pool != NULL, "pool missing") ||
!uffs_Assert(mem != NULL, "pool memory missing") ||
!uffs_Assert(num_bufs > 0, "not enough buffers") ||
!uffs_Assert(buf_size % sizeof(void *) == 0,
"buffer size not aligned to pointer size") ||
!uffs_Assert(mem_size == num_bufs * buf_size,
"pool memory size is wrong"))
{
return U_FAIL;
}
pool->mem = (u8 *)mem;
pool->buf_size = buf_size;
pool->num_bufs = num_bufs;
pool->sem = OSSEM_NOT_INITED;
if (lock) {
uffs_SemCreate(&pool->sem);
uffs_SemWait(pool->sem);
}
// Initialize the free_list
e1 = e2 = pool->free_list = (uffs_PoolEntry *) pool->mem;
for (i = 1; i < pool->num_bufs; i++) {
e2 = (uffs_PoolEntry *) (pool->mem + i * pool->buf_size);
e1->next = e2;
e1 = e2;
}
e2->next = NULL;
if (lock)
uffs_SemSignal(pool->sem);
return U_SUCC;
}
void uffs_GlobalFsLockLock(void)
{
uffs_SemWait(_global_lock);
}
