int queue_sched_atomic(odp_queue_t handle)
{
queue_entry_t *queue;
queue = queue_to_qentry(handle);
return queue->s.param.sched.sync == ODP_SCHED_SYNC_ATOMIC;
}
odp_buffer_t queue_sched_buf(odp_queue_t handle)
{
queue_entry_t *queue;
queue = queue_to_qentry(handle);
return queue->s.sched_buf;
}
odp_schedule_prio_t odp_queue_sched_prio(odp_queue_t handle)
{
queue_entry_t *queue;
queue = queue_to_qentry(handle);
return queue->s.param.sched.prio;
}
odp_schedule_group_t odp_queue_sched_group(odp_queue_t handle)
{
queue_entry_t *queue;
queue = queue_to_qentry(handle);
return queue->s.param.sched.group;
}
odp_queue_type_t odp_queue_type(odp_queue_t handle)
{
queue_entry_t *queue;
queue = queue_to_qentry(handle);
return queue->s.type;
}
odp_schedule_sync_t odp_queue_sched_type(odp_queue_t handle)
{
queue_entry_t *queue;
queue = queue_to_qentry(handle);
return queue->s.param.sched.sync;
}
int odp_queue_set_context(odp_queue_t handle, void *context)
{
queue_entry_t *queue;
queue = queue_to_qentry(handle);
odp_sync_stores();
queue->s.param.context = context;
odp_sync_stores();
return 0;
}
int odp_queue_enq(odp_queue_t handle, odp_buffer_t buf)
{
odp_buffer_hdr_t *buf_hdr;
queue_entry_t *queue;
queue = queue_to_qentry(handle);
buf_hdr = odp_buf_to_hdr(buf);
return queue->s.enqueue(queue, buf_hdr);
}
int odp_queue_enq(odp_queue_t handle, odp_event_t ev)
{
odp_buffer_hdr_t *buf_hdr;
queue_entry_t *queue;
queue = queue_to_qentry(handle);
buf_hdr = odp_buf_to_hdr(odp_buffer_from_event(ev));
return queue->s.enqueue(queue, buf_hdr);
}
odp_pktio_t odp_pktio_open(const char *dev, odp_buffer_pool_t pool,
odp_pktio_params_t *params)
{
odp_pktio_t id;
pktio_entry_t *pktio_entry;
char name[ODP_QUEUE_NAME_LEN];
queue_entry_t *queue_entry;
odp_queue_t qid = ODP_QUEUE_INVALID;
if (params == NULL) {
ODP_ERR("Invalid pktio params\n");
return ODP_PKTIO_INVALID;
}
ODP_DBG("Allocating HW pktio\n");
id = alloc_lock_pktio_entry(params);
if (id == ODP_PKTIO_INVALID) {
ODP_ERR("No resources available.\n");
return ODP_PKTIO_INVALID;
}
/* if successful, alloc_pktio_entry() returns with the entry locked */
pktio_entry = get_entry(id);
/* Create a default output queue for each pktio resource */
snprintf(name, sizeof(name), "%i-pktio_outq_default", (int)id);
name[ODP_QUEUE_NAME_LEN-1] = '\0';
pktio_entry->s.dev = _odp_pktio_dev_lookup(dev);
if (!pktio_entry->s.dev) {
free_pktio_entry(id);
id = ODP_PKTIO_INVALID;
goto unlock;
}
qid = _odp_queue_create(name, ODP_QUEUE_TYPE_PKTOUT, NULL,
pktio_entry->s.dev->tx_hw_queue);
ODP_DBG("Created queue %u for hw queue %d\n", (uint32_t)qid,
pktio_entry->s.dev->tx_hw_queue);
if (qid == ODP_QUEUE_INVALID) {
free_pktio_entry(id);
id = ODP_PKTIO_INVALID;
goto unlock;
}
pktio_entry->s.in_pool = pool;
pktio_entry->s.outq_default = qid;
queue_entry = queue_to_qentry(qid);
queue_entry->s.pktout = id;
queue_entry->s.out_port_id = pktio_entry->s.dev->port_id;
unlock:
unlock_entry(pktio_entry);
return id;
}
int odp_pktio_init_global(void)
{
char name[ODP_QUEUE_NAME_LEN];
pktio_entry_t *pktio_entry;
queue_entry_t *queue_entry;
odp_queue_t qid;
int id;
odp_shm_t shm;
int pktio_if;
shm = odp_shm_reserve("odp_pktio_entries",
sizeof(pktio_table_t),
sizeof(pktio_entry_t), 0);
pktio_tbl = odp_shm_addr(shm);
if (pktio_tbl == NULL)
return -1;
memset(pktio_tbl, 0, sizeof(pktio_table_t));
odp_spinlock_init(&pktio_tbl->lock);
for (id = 1; id <= ODP_CONFIG_PKTIO_ENTRIES; ++id) {
pktio_entry = &pktio_tbl->entries[id - 1];
odp_spinlock_init(&pktio_entry->s.lock);
odp_spinlock_init(&pktio_entry->s.cls.lock);
odp_spinlock_init(&pktio_entry->s.cls.l2_cos_table.lock);
odp_spinlock_init(&pktio_entry->s.cls.l3_cos_table.lock);
pktio_entry_ptr[id - 1] = pktio_entry;
/* Create a default output queue for each pktio resource */
snprintf(name, sizeof(name), "%i-pktio_outq_default", (int)id);
name[ODP_QUEUE_NAME_LEN - 1] = '\0';
qid = odp_queue_create(name, ODP_QUEUE_TYPE_PKTOUT, NULL);
if (qid == ODP_QUEUE_INVALID)
return -1;
pktio_entry->s.outq_default = qid;
queue_entry = queue_to_qentry(qid);
queue_entry->s.pktout = _odp_cast_scalar(odp_pktio_t, id);
}
for (pktio_if = 0; pktio_if_ops[pktio_if]; ++pktio_if)
if (pktio_if_ops[pktio_if]->init)
if (pktio_if_ops[pktio_if]->init())
ODP_ERR("failed to initialized pktio type %d", pktio_if);
return 0;
}
static int loopback_send(pktio_entry_t *pktio_entry, odp_packet_t pkt_tbl[],
unsigned len)
{
odp_buffer_hdr_t *hdr_tbl[QUEUE_MULTI_MAX];
queue_entry_t *qentry;
unsigned i;
for (i = 0; i < len; ++i)
hdr_tbl[i] = odp_buf_to_hdr(_odp_packet_to_buffer(pkt_tbl[i]));
qentry = queue_to_qentry(pktio_entry->s.pkt_loop.loopq);
return queue_enq_multi(qentry, hdr_tbl, len);
}
odp_event_t odp_queue_deq(odp_queue_t handle)
{
queue_entry_t *queue;
odp_buffer_hdr_t *buf_hdr;
queue = queue_to_qentry(handle);
buf_hdr = queue->s.dequeue(queue);
if (buf_hdr)
return odp_buffer_to_event(buf_hdr->handle.handle);
return ODP_EVENT_INVALID;
}
odp_buffer_t odp_queue_deq(odp_queue_t handle)
{
queue_entry_t *queue;
odp_buffer_hdr_t *buf_hdr;
queue = queue_to_qentry(handle);
buf_hdr = queue->s.dequeue(queue);
if (buf_hdr)
return buf_hdr->handle.handle;
return ODP_BUFFER_INVALID;
}
int odp_queue_enq_multi(odp_queue_t handle, const odp_event_t ev[], int num)
{
odp_buffer_hdr_t *buf_hdr[QUEUE_MULTI_MAX];
queue_entry_t *queue;
int i;
if (num > QUEUE_MULTI_MAX)
num = QUEUE_MULTI_MAX;
queue = queue_to_qentry(handle);
for (i = 0; i < num; i++)
buf_hdr[i] = odp_buf_to_hdr(odp_buffer_from_event(ev[i]));
return queue->s.enqueue_multi(queue, buf_hdr, num);
}
static int loopback_recv(pktio_entry_t *pktio_entry, odp_packet_t pkts[],
unsigned len)
{
int nbr, i;
odp_buffer_hdr_t *hdr_tbl[QUEUE_MULTI_MAX];
queue_entry_t *qentry;
qentry = queue_to_qentry(pktio_entry->s.pkt_loop.loopq);
nbr = queue_deq_multi(qentry, hdr_tbl, len);
for (i = 0; i < nbr; ++i) {
pkts[i] = _odp_packet_from_buffer(odp_hdr_to_buf(hdr_tbl[i]));
_odp_packet_reset_parse(pkts[i]);
}
return nbr;
}
int odp_queue_deq_multi(odp_queue_t handle, odp_event_t events[], int num)
{
queue_entry_t *queue;
odp_buffer_hdr_t *buf_hdr[QUEUE_MULTI_MAX];
int i, ret;
if (num > QUEUE_MULTI_MAX)
num = QUEUE_MULTI_MAX;
queue = queue_to_qentry(handle);
ret = queue->s.dequeue_multi(queue, buf_hdr, num);
for (i = 0; i < ret; i++)
events[i] = odp_buffer_to_event(buf_hdr[i]->handle.handle);
return ret;
}
int odp_pktio_inq_setdef(odp_pktio_t id, odp_queue_t queue)
{
pktio_entry_t *pktio_entry = get_pktio_entry(id);
queue_entry_t *qentry;
if (pktio_entry == NULL || queue == ODP_QUEUE_INVALID)
return -1;
qentry = queue_to_qentry(queue);
if (qentry->s.type != ODP_QUEUE_TYPE_PKTIN)
return -1;
lock_entry(pktio_entry);
pktio_entry->s.inq_default = queue;
unlock_entry(pktio_entry);
switch (qentry->s.type) {
/* Change to ODP_QUEUE_TYPE_POLL when ODP_QUEUE_TYPE_PKTIN is removed */
case ODP_QUEUE_TYPE_PKTIN:
/* User polls the input queue */
queue_lock(qentry);
qentry->s.pktin = id;
queue_unlock(qentry);
/* Uncomment when ODP_QUEUE_TYPE_PKTIN is removed
break;
case ODP_QUEUE_TYPE_SCHED:
*/
/* Packet input through the scheduler */
if (schedule_pktio_start(id, ODP_SCHED_PRIO_LOWEST)) {
ODP_ERR("Schedule pktio start failed\n");
return -1;
}
break;
default:
ODP_ABORT("Bad queue type\n");
}
return 0;
}
int odp_queue_destroy(odp_queue_t handle)
{
queue_entry_t *queue;
queue = queue_to_qentry(handle);
LOCK(queue);
INVALIDATE(queue);
if (queue->s.status == QUEUE_STATUS_FREE) {
UNLOCK(queue);
ODP_ERR("queue \"%s\" already free\n", queue->s.name);
return -1;
}
if (queue->s.status == QUEUE_STATUS_DESTROYED) {
UNLOCK(queue);
ODP_ERR("queue \"%s\" already destroyed\n", queue->s.name);
return -1;
}
if (queue->s.head != NULL) {
UNLOCK(queue);
ODP_ERR("queue \"%s\" not empty\n", queue->s.name);
return -1;
}
switch (queue->s.status) {
case QUEUE_STATUS_READY:
queue->s.status = QUEUE_STATUS_FREE;
break;
case QUEUE_STATUS_NOTSCHED:
queue->s.status = QUEUE_STATUS_FREE;
schedule_queue_destroy(queue);
break;
case QUEUE_STATUS_SCHED:
/* Queue is still in scheduling */
queue->s.status = QUEUE_STATUS_DESTROYED;
break;
default:
ODP_ABORT("Unexpected queue status\n");
}
UNLOCK(queue);
return 0;
}
int odp_pktio_inq_setdef(odp_pktio_t id, odp_queue_t queue)
{
pktio_entry_t *pktio_entry = get_entry(id);
queue_entry_t *qentry = queue_to_qentry(queue);
if (pktio_entry == NULL || qentry == NULL)
return -1;
if (qentry->s.type != ODP_QUEUE_TYPE_PKTIN)
return -1;
pktio_entry->s.inq_default = queue;
{
uint32_t free_queue =
_odp_pool_get_free_queue(pktio_entry->s.in_pool);
ti_em_osal_cppi_rx_channel_close(Cppi_CpDma_PASS_CPDMA,
pktio_entry->s.dev->rx_channel);
ti_em_osal_cppi_rx_flow_open(Cppi_CpDma_PASS_CPDMA,
pktio_entry->s.dev->rx_flow,
qentry->s.hw_queue,
free_queue,
0);
ti_em_osal_cppi_rx_channel_open(Cppi_CpDma_PASS_CPDMA,
pktio_entry->s.dev->rx_channel);
ODP_DBG("%s: Opened rx flow %u with dest queue: %u and free queue: %u\n",
__func__,
pktio_entry->s.dev->rx_flow,
qentry->s.hw_queue,
free_queue);
}
queue_lock(qentry);
qentry->s.pktin = id;
qentry->s.status = QUEUE_STATUS_SCHED;
queue_unlock(qentry);
odp_schedule_queue(queue, qentry->s.param.sched.prio);
return 0;
}
int odp_pktio_inq_remdef(odp_pktio_t id)
{
pktio_entry_t *pktio_entry = get_pktio_entry(id);
odp_queue_t queue;
queue_entry_t *qentry;
if (pktio_entry == NULL)
return -1;
lock_entry(pktio_entry);
queue = pktio_entry->s.inq_default;
qentry = queue_to_qentry(queue);
queue_lock(qentry);
qentry->s.pktin = ODP_PKTIO_INVALID;
queue_unlock(qentry);
pktio_entry->s.inq_default = ODP_QUEUE_INVALID;
unlock_entry(pktio_entry);
return 0;
}
int odp_pktio_inq_setdef(odp_pktio_t id, odp_queue_t queue)
{
pktio_entry_t *pktio_entry = get_entry(id);
queue_entry_t *qentry = queue_to_qentry(queue);
if (pktio_entry == NULL || qentry == NULL)
return -1;
if (qentry->s.type != ODP_QUEUE_TYPE_PKTIN)
return -1;
lock_entry(pktio_entry);
pktio_entry->s.inq_default = queue;
unlock_entry(pktio_entry);
queue_lock(qentry);
qentry->s.pktin = id;
qentry->s.status = QUEUE_STATUS_SCHED;
queue_unlock(qentry);
odp_schedule_queue(queue, qentry->s.param.sched.prio);
return 0;
}
int odp_pktio_init_global(void)
{
char name[ODP_QUEUE_NAME_LEN];
pktio_entry_t *pktio_entry;
queue_entry_t *queue_entry;
odp_queue_t qid;
int id;
pktio_tbl = odp_shm_reserve("odp_pktio_entries",
sizeof(pktio_table_t),
sizeof(pktio_entry_t));
if (pktio_tbl == NULL)
return -1;
memset(pktio_tbl, 0, sizeof(pktio_table_t));
for (id = 1; id <= ODP_CONFIG_PKTIO_ENTRIES; ++id) {
pktio_entry = get_entry(id);
odp_spinlock_init(&pktio_entry->s.lock);
/* Create a default output queue for each pktio resource */
snprintf(name, sizeof(name), "%i-pktio_outq_default", (int)id);
name[ODP_QUEUE_NAME_LEN-1] = '\0';
qid = odp_queue_create(name, ODP_QUEUE_TYPE_PKTOUT, NULL);
if (qid == ODP_QUEUE_INVALID)
return -1;
pktio_entry->s.outq_default = qid;
queue_entry = queue_to_qentry(qid);
queue_entry->s.pktout = id;
}
return 0;
}
static int loopback_recv(pktio_entry_t *pktio_entry, odp_packet_t pkts[],
unsigned len)
{
int nbr, i, j;
odp_buffer_hdr_t *hdr_tbl[QUEUE_MULTI_MAX];
queue_entry_t *qentry;
odp_packet_hdr_t *pkt_hdr;
odp_packet_t pkt;
nbr = 0;
qentry = queue_to_qentry(pktio_entry->s.pkt_loop.loopq);
nbr = queue_deq_multi(qentry, hdr_tbl, len);
if (pktio_cls_enabled(pktio_entry)) {
for (i = 0, j = 0; i < nbr; i++) {
pkt = _odp_packet_from_buffer(odp_hdr_to_buf
(hdr_tbl[i]));
pkt_hdr = odp_packet_hdr(pkt);
packet_parse_reset(pkt_hdr);
packet_parse_l2(pkt_hdr);
if (0 > _odp_packet_classifier(pktio_entry, pkt))
pkts[j++] = pkt;
}
nbr = j;
} else {
for (i = 0; i < nbr; ++i) {
pkts[i] = _odp_packet_from_buffer(odp_hdr_to_buf
(hdr_tbl[i]));
pkt_hdr = odp_packet_hdr(pkts[i]);
packet_parse_reset(pkt_hdr);
packet_parse_l2(pkt_hdr);
}
}
return nbr;
}
void *odp_queue_get_context(odp_queue_t handle)
{
queue_entry_t *queue;
queue = queue_to_qentry(handle);
return queue->s.param.context;
}
