void bman_test_high(void)
{
struct bman_pool_params pparams = {
.flags = BMAN_POOL_FLAG_DEPLETION | BMAN_POOL_FLAG_DYNAMIC_BPID,
.cb = depletion_cb,
.cb_ctx = POOL_OPAQUE,
};
int i, loops = LOOPS;
bufs_init();
pr_info("BMAN: --- starting high-level test ---\n");
pool = bman_new_pool(&pparams);
BUG_ON(!pool);
/*******************/
/* Release buffers */
/*******************/
do_loop:
i = 0;
while (i < NUM_BUFS) {
u32 flags = BMAN_RELEASE_FLAG_WAIT;
int num = 8;
if ((i + num) > NUM_BUFS)
num = NUM_BUFS - i;
if ((i + num) == NUM_BUFS)
flags |= BMAN_RELEASE_FLAG_WAIT_SYNC;
if (bman_release(pool, bufs_in + i, num, flags))
panic("bman_release() failed\n");
i += num;
}
/*******************/
/* Acquire buffers */
/*******************/
while (i > 0) {
int tmp, num = 8;
if (num > i)
num = i;
tmp = bman_acquire(pool, bufs_out + i - num, num, 0);
BUG_ON(tmp != num);
i -= num;
}
i = bman_acquire(pool, NULL, 1, 0);
BUG_ON(i > 0);
bufs_confirm();
if (--loops)
goto do_loop;
/************/
/* Clean up */
/************/
bman_free_pool(pool);
pr_info("BMAN: --- finished high-level test ---\n");
}
void fsl_buffer_pool_fill(struct packet_pool_cfg *pool_cfg)
{
int err;
int loop;
struct bman_pool *p;
struct packet_pool_cfg *bp = pool_cfg;
for (; bp->bpid != -1; bp++) {
struct bm_buffer bufs[8];
int num_bufs = 0;
p = helper_pool[bp->bpid];
err = 0;
/* Drain the pool of anything already in it. */
if (bp->num > 0) {
do {
if (err != 1)
err = bman_acquire(p, bufs, 8, 0);
if (err < 8)
err = bman_acquire(p, bufs, 1, 0);
if (err > 0)
num_bufs += err;
} while (err > 0);
}
if (num_bufs)
TRACE("warn: drained %u bufs from BPID %d\n",
num_bufs, bp->bpid);
/* Fill the pool */
for (num_bufs = 0; num_bufs < bp->num;) {
int rel = (bp->num - num_bufs) > 8 ? 8 :
(bp->num - num_bufs);
for (loop = 0; loop < rel; loop++) {
void *ptr = DMA_MEM_ALLOC(L1_CACHE_BYTES,
bp->size);
if (!ptr) {
TRACE("error: no space for bpid %d\n",
bp->bpid);
return;
}
bm_buffer_set64(&bufs[loop], vtop(ptr));
}
do {
err = bman_release(p, bufs, rel, 0);
} while (err == -EBUSY);
if (err)
TRACE("error: release failure\n");
num_bufs += rel;
}
TRACE("Release %u bufs to BPID %d\n", num_bufs, bp->bpid);
}
}
void fsl_buffer_free(void *bd, u32 pool_id)
{
int ret;
struct bm_buffer buf;
buf.addr = vtop(bd);
retry:
ret = bman_release(helper_pool[pool_id], &buf, 1, 0);
if (unlikely(ret == -EBUSY))
goto retry;
else if (ret)
TRACE("bman release failure, ret %d\n", ret);
}
/* Drop a frame (releases buffers to Bman) */
static inline void drop_frame(const struct qm_fd *fd)
{
struct bm_buffer buf;
int ret;
BUG_ON(fd->format != qm_fd_contig);
bm_buffer_set64(&buf, qm_fd_addr(fd));
retry:
ret = bman_release(pool[fd->bpid], &buf, 1, 0);
if (ret) {
cpu_spin(CPU_SPIN_BACKOFF_CYCLES);
goto retry;
}
}
static void
dpaa_buf_free(struct dpaa_bp_info *bp_info, uint64_t addr)
{
struct bm_buffer buf;
int ret;
DPAA_MEMPOOL_DEBUG("Free 0x%lx to bpid: %d", addr, bp_info->bpid);
bm_buffer_set64(&buf, addr);
retry:
ret = bman_release(bp_info->bp, &buf, 1, 0);
if (ret) {
DPAA_MEMPOOL_DEBUG("BMAN busy. Retrying...");
cpu_spin(CPU_SPIN_BACKOFF_CYCLES);
goto retry;
}
}
int dpa_bp_shared_port_seed(struct dpa_bp *bp)
{
/* In MAC-less and Shared-MAC scenarios the physical
* address of the buffer pool in device tree is set
* to 0 to specify that another entity (USDPAA) will
* allocate and seed the buffers
*/
if (!bp->paddr)
return 0;
/* allocate memory region for buffers */
devm_request_mem_region(bp->dev, bp->paddr,
bp->size * bp->config_count, KBUILD_MODNAME);
bp->vaddr = devm_ioremap_prot(bp->dev, bp->paddr,
bp->size * bp->config_count, 0);
if (bp->vaddr == NULL) {
pr_err("Could not map memory for pool %d\n", bp->bpid);
return -EIO;
}
/* seed pool with buffers from that memory region */
if (bp->seed_pool) {
int count = bp->target_count;
size_t addr = bp->paddr;
while (count) {
struct bm_buffer bufs[8];
int num_bufs = 0;
do {
BUG_ON(addr > 0xffffffffffffull);
bufs[num_bufs].bpid = bp->bpid;
bm_buffer_set64(&bufs[num_bufs++], addr);
addr += bp->size;
} while (--count && (num_bufs < 8));
while (bman_release(bp->pool, bufs, num_bufs, 0))
cpu_relax();
}
}
return 0;
}
