Lines Matching refs:pool
88 int gsi_trans_pool_init(struct gsi_trans_pool *pool, size_t size, u32 count,
102 /* By allocating a few extra entries in our pool (one less
105 * ever worrying about straddling the end of the pool array.
107 * we just allocate free entries from the beginning of the pool.
113 pool->base = virt;
115 pool->count = ksize(pool->base) / size;
116 pool->free = 0;
117 pool->max_alloc = max_alloc;
118 pool->size = size;
119 pool->addr = 0; /* Only used for DMA pools */
124 void gsi_trans_pool_exit(struct gsi_trans_pool *pool)
126 kfree(pool->base);
127 memset(pool, 0, sizeof(*pool));
130 /* Allocate the requested number of (zeroed) entries from the pool */
131 /* Home-grown DMA pool. This way we can preallocate and use the tre_count
134 * element from a DMA pool.
136 int gsi_trans_pool_init_dma(struct device *dev, struct gsi_trans_pool *pool,
168 pool->base = virt;
169 pool->count = total_size / size;
170 pool->free = 0;
171 pool->size = size;
172 pool->max_alloc = max_alloc;
173 pool->addr = addr;
178 void gsi_trans_pool_exit_dma(struct device *dev, struct gsi_trans_pool *pool)
180 size_t total_size = pool->count * pool->size;
182 dma_free_coherent(dev, total_size, pool->base, pool->addr);
183 memset(pool, 0, sizeof(*pool));
186 /* Return the byte offset of the next free entry in the pool */
187 static u32 gsi_trans_pool_alloc_common(struct gsi_trans_pool *pool, u32 count)
192 /* assert(count <= pool->max_alloc); */
195 if (count > pool->count - pool->free)
196 pool->free = 0;
198 offset = pool->free * pool->size;
199 pool->free += count;
200 memset(pool->base + offset, 0, count * pool->size);
205 /* Allocate a contiguous block of zeroed entries from a pool */
206 void *gsi_trans_pool_alloc(struct gsi_trans_pool *pool, u32 count)
208 return pool->base + gsi_trans_pool_alloc_common(pool, count);
211 /* Allocate a single zeroed entry from a DMA pool */
212 void *gsi_trans_pool_alloc_dma(struct gsi_trans_pool *pool, dma_addr_t *addr)
214 u32 offset = gsi_trans_pool_alloc_common(pool, 1);
216 *addr = pool->addr + offset;
218 return pool->base + offset;
221 /* Return the pool element that immediately follows the one given.
224 void *gsi_trans_pool_next(struct gsi_trans_pool *pool, void *element)
226 void *end = pool->base + pool->count * pool->size;
228 /* assert(element >= pool->base); */
230 /* assert(pool->max_alloc == 1); */
231 element += pool->size;
233 return element < end ? element : pool->base;
346 trans = gsi_trans_pool_alloc(&trans_info->pool, 1);
414 * Their payloads come from a pool whose memory is allocated
751 ret = gsi_trans_pool_init(&trans_info->pool, sizeof(struct gsi_trans),
790 gsi_trans_pool_exit(&trans_info->pool);
806 gsi_trans_pool_exit(&trans_info->pool);