#include <machine/rtems-bsd-kernel-space.h>
#include <rtems/bsd/local/opt_dpaa.h>
/* Copyright 2010 - 2015 Freescale Semiconductor, Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of Freescale Semiconductor nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* ALTERNATIVELY, this software may be distributed under the terms of the
* GNU General Public License ("GPL") as published by the Free Software
* Foundation, either version 2 of that License or (at your option) any
* later version.
*
* THIS SOFTWARE IS PROVIDED BY Freescale Semiconductor ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL Freescale Semiconductor BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "bman_test.h"
/* Test constants */
#define TEST_NUMBUFS 129728
#define TEST_EXIT 129536
#define TEST_ENTRY 129024
struct affine_test_data {
struct task_struct *t;
int cpu;
#ifndef __rtems__
int expect_affinity;
#endif /* __rtems__ */
int drain;
int num_enter;
int num_exit;
struct list_head node;
struct completion wakethread;
struct completion wakeparent;
};
static void cb_depletion(struct bman_portal *portal,
struct bman_pool *pool,
void *opaque,
int depleted)
{
struct affine_test_data *data = opaque;
int c = smp_processor_id();
pr_info("%s(): bpid=%d, depleted=%d, cpu=%d, original=%d\n", __func__,
bman_get_params(pool)->bpid, !!depleted, c, data->cpu);
/* We should be executing on the CPU of the thread that owns the pool if
* and that CPU has an affine portal (ie. it isn't slaved). */
#ifndef __rtems__
BUG_ON((c != data->cpu) && data->expect_affinity);
BUG_ON((c == data->cpu) && !data->expect_affinity);
#endif /* __rtems__ */
if (depleted)
data->num_enter++;
else
data->num_exit++;
}
/* Params used to set up a pool, this also dynamically allocates a BPID */
static const struct bman_pool_params params_nocb = {
.flags = BMAN_POOL_FLAG_DYNAMIC_BPID | BMAN_POOL_FLAG_THRESH,
.thresholds = { TEST_ENTRY, TEST_EXIT, 0, 0 }
};
/* Params used to set up each cpu's pool with callbacks enabled */
static struct bman_pool_params params_cb = {
.bpid = 0, /* will be replaced to match pool_nocb */
.flags = BMAN_POOL_FLAG_DEPLETION,
.cb = cb_depletion
};
static struct bman_pool *pool_nocb;
static LIST_HEAD(threads);
static int affine_test(void *__data)
{
struct bman_pool *pool;
struct affine_test_data *data = __data;
struct bman_pool_params my_params = params_cb;
pr_info("Thread %d: starting\n", data->cpu);
/* create the pool */
my_params.cb_ctx = data;
pool = bman_new_pool(&my_params);
BUG_ON(!pool);
complete(&data->wakeparent);
wait_for_completion(&data->wakethread);
init_completion(&data->wakethread);
/* if we're the drainer, we get signalled for that */
if (data->drain) {
struct bm_buffer buf;
int ret;
pr_info("Thread %d: draining...\n", data->cpu);
do {
ret = bman_acquire(pool, &buf, 1, 0);
} while (ret > 0);
pr_info("Thread %d: draining done.\n", data->cpu);
complete(&data->wakeparent);
wait_for_completion(&data->wakethread);
init_completion(&data->wakethread);
}
/* cleanup */
bman_free_pool(pool);
while (!kthread_should_stop())
cpu_relax();
pr_info("Thread %d: exiting\n", data->cpu);
return 0;
}
static struct affine_test_data *start_affine_test(int cpu, int drain)
{
struct affine_test_data *data = kmalloc(sizeof(*data), GFP_KERNEL);
if (!data)
return NULL;
data->cpu = cpu;
#ifndef __rtems__
data->expect_affinity = cpumask_test_cpu(cpu, bman_affine_cpus());
#endif /* __rtems__ */
data->drain = drain;
data->num_enter = 0;
data->num_exit = 0;
init_completion(&data->wakethread);
init_completion(&data->wakeparent);
list_add_tail(&data->node, &threads);
data->t = kthread_create(affine_test, data, "threshtest%d", cpu);
#ifndef __rtems__
BUG_ON(IS_ERR(data->t));
#else /* __rtems__ */
BUG_ON(data->t == NULL);
#endif /* __rtems__ */
kthread_bind(data->t, cpu);
wake_up_process(data->t);
return data;
}
void bman_test_thresh(void)
{
int loop = TEST_NUMBUFS;
int ret, num_cpus = 0;
struct affine_test_data *data, *drainer = NULL;
pr_info("%s(): Start\n", __func__);
/* allocate a BPID and seed it */
pool_nocb = bman_new_pool(¶ms_nocb);
BUG_ON(!pool_nocb);
while (loop--) {
struct bm_buffer buf;
bm_buffer_set64(&buf, 0x0badbeef + loop);
ret = bman_release(pool_nocb, &buf, 1,
BMAN_RELEASE_FLAG_WAIT);
BUG_ON(ret);
}
while (!bman_rcr_is_empty())
cpu_relax();
pr_info("%s(): Buffers are in\n", __func__);
/* create threads and wait for them to create pools */
params_cb.bpid = bman_get_params(pool_nocb)->bpid;
#ifndef __rtems__
for_each_cpu(loop, cpu_online_mask) {
#else /* __rtems__ */
for (loop = 0; loop < rtems_get_processor_count(); ++loop) {
#endif /* __rtems__ */
data = start_affine_test(loop, drainer ? 0 : 1);
BUG_ON(!data);
if (!drainer)
drainer = data;
num_cpus++;
wait_for_completion(&data->wakeparent);
}
/* signal the drainer to start draining */
complete(&drainer->wakethread);
wait_for_completion(&drainer->wakeparent);
init_completion(&drainer->wakeparent);
/* tear down */
list_for_each_entry_safe(data, drainer, &threads, node) {
complete(&data->wakethread);
ret = kthread_stop(data->t);
BUG_ON(ret);
list_del(&data->node);
/* check that we get the expected callbacks (and no others) */
BUG_ON(data->num_enter != 1);
BUG_ON(data->num_exit != 0);
kfree(data);
}
bman_free_pool(pool_nocb);
pr_info("%s(): Done\n", __func__);
}
