odp_pktio_t odp_pktio_lookup(const char *dev)
{
odp_pktio_t id = ODP_PKTIO_INVALID;
pktio_entry_t *entry;
int i;
odp_spinlock_lock(&pktio_tbl->lock);
for (i = 1; i <= ODP_CONFIG_PKTIO_ENTRIES; ++i) {
entry = get_pktio_entry(_odp_cast_scalar(odp_pktio_t, i));
if (!entry || is_free(entry))
continue;
lock_entry(entry);
if (!is_free(entry) &&
strncmp(entry->s.name, dev, IF_NAMESIZE) == 0)
id = _odp_cast_scalar(odp_pktio_t, i);
unlock_entry(entry);
if (id != ODP_PKTIO_INVALID)
break;
}
odp_spinlock_unlock(&pktio_tbl->lock);
return id;
}
int schedule_pktio_start(odp_pktio_t pktio, int prio)
{
odp_buffer_t buf;
sched_cmd_t *sched_cmd;
odp_queue_t pri_queue;
buf = odp_buffer_alloc(sched->pool);
if (buf == ODP_BUFFER_INVALID)
return -1;
sched_cmd = odp_buffer_addr(buf);
sched_cmd->cmd = SCHED_CMD_POLL_PKTIN;
sched_cmd->pktio = pktio;
sched_cmd->pe = get_pktio_entry(pktio);
sched_cmd->prio = prio;
pri_queue = pri_set_pktio(pktio, prio);
if (odp_queue_enq(pri_queue, odp_buffer_to_event(buf)))
ODP_ABORT("schedule_pktio_start failed\n");
return 0;
}
odp_queue_t odp_pktio_outq_getdef(odp_pktio_t id)
{
pktio_entry_t *pktio_entry = get_pktio_entry(id);
if (pktio_entry == NULL)
return ODP_QUEUE_INVALID;
return pktio_entry->s.outq_default;
}
static int free_pktio_entry(odp_pktio_t id)
{
pktio_entry_t *entry = get_pktio_entry(id);
if (entry == NULL)
return -1;
set_free(entry);
return 0;
}
int odp_pktio_send(odp_pktio_t id, odp_packet_t pkt_table[], int len)
{
pktio_entry_t *pktio_entry = get_pktio_entry(id);
int pkts;
if (pktio_entry == NULL)
return -1;
lock_entry(pktio_entry);
pkts = pktio_entry->s.ops->send(pktio_entry, pkt_table, len);
unlock_entry(pktio_entry);
return pkts;
}
static odp_pktio_t setup_pktio_entry(const char *dev, odp_pool_t pool)
{
odp_pktio_t id;
pktio_entry_t *pktio_entry;
int ret = -1;
int pktio_if;
if (strlen(dev) >= IF_NAMESIZE) {
/* ioctl names limitation */
ODP_ERR("pktio name %s is too big, limit is %d bytes\n",
dev, IF_NAMESIZE);
return ODP_PKTIO_INVALID;
}
id = alloc_lock_pktio_entry();
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_pktio_entry(id);
if (!pktio_entry) {
PRINT("get_pktio_entry is fail.\n");
return ODP_PKTIO_INVALID;
}
for (pktio_if = 0; pktio_if_ops[pktio_if]; ++pktio_if) {
ret = pktio_if_ops[pktio_if]->open(id, pktio_entry, dev, pool);
if (!ret) {
pktio_entry->s.ops = pktio_if_ops[pktio_if];
break;
}
}
if (ret != 0) {
unlock_entry_classifier(pktio_entry);
free_pktio_entry(id);
id = ODP_PKTIO_INVALID;
ODP_ERR("Unable to init any I/O type.\n");
} else {
snprintf(pktio_entry->s.name, IF_NAMESIZE, "%s", dev);
unlock_entry_classifier(pktio_entry);
}
pktio_entry->s.handle = id;
return id;
}
int odp_pktio_recv(odp_pktio_t id, odp_packet_t pkt_table[], unsigned int len)
{
pktio_entry_t *pktio_entry = get_pktio_entry(id);
int pkts;
if (pktio_entry == NULL)
return -1;
/* lock_entry(pktio_entry); */
pkts = pktio_entry->s.ops->recv(pktio_entry, pkt_table, len);
/* unlock_entry(pktio_entry); */
return pkts;
}
int odp_pktio_restart(odp_pktio_t id)
{
pktio_entry_t *entry;
uint8_t port_id;
int ret;
entry = get_pktio_entry(id);
if (entry == NULL) {
ODP_DBG("pktio entry %d does not exist\n",
id->unused_dummy_var);
return -1;
}
if (odp_unlikely(is_free(entry))) {
ODP_DBG("already freed pktio\n");
return -1;
}
if (odp_pktio_is_not_hns_eth(entry)) {
ODP_DBG("pktio entry %d is not ODP UMD pktio\n",
id->unused_dummy_var);
return -1;
}
port_id = entry->s.pkt_odp.portid;
if (!odp_eth_dev_is_valid_port(port_id)) {
ODP_DBG("pktio entry %d ODP UMD Invalid port_id=%d\n",
id->unused_dummy_var, port_id);
return -1;
}
/* Stop device */
odp_eth_dev_stop(port_id);
/* Start device */
ret = odp_eth_dev_start(port_id);
if (ret < 0) {
ODP_ERR("odp_eth_dev_start:err=%d, port=%u\n",
ret, (unsigned)port_id);
return -1;
}
ODP_DBG("odp pmd restart done\n\n");
return 0;
}
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_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_close(odp_pktio_t id)
{
pktio_entry_t *entry;
int res = -1;
entry = get_pktio_entry(id);
if (entry == NULL)
return -1;
lock_entry(entry);
if (!is_free(entry)) {
res = entry->s.ops->close(entry);
res |= free_pktio_entry(id);
}
unlock_entry(entry);
if (res != 0)
return -1;
return 0;
}
