static void on_receive_block(struct r3964_info *pInfo)
{
unsigned int length;
struct r3964_client_info *pClient;
struct r3964_block_header *pBlock;
length = pInfo->rx_position;
/* compare byte checksum characters: */
if (pInfo->flags & R3964_BCC) {
if (pInfo->bcc != pInfo->last_rx) {
TRACE_PE("checksum error - got %x but expected %x",
pInfo->last_rx, pInfo->bcc);
pInfo->flags |= R3964_CHECKSUM;
}
}
/* check for errors (parity, overrun,...): */
if (pInfo->flags & R3964_ERROR) {
TRACE_PE("on_receive_block - transmission failed error %x",
pInfo->flags & R3964_ERROR);
put_char(pInfo, NAK);
flush(pInfo);
if (pInfo->nRetry < R3964_MAX_RETRIES) {
pInfo->state = R3964_WAIT_FOR_RX_REPEAT;
pInfo->nRetry++;
mod_timer(&pInfo->tmr, jiffies + R3964_TO_RX_PANIC);
} else {
TRACE_PE("on_receive_block - failed after max retries");
pInfo->state = R3964_IDLE;
}
return;
}
/* received block; submit DLE: */
put_char(pInfo, DLE);
flush(pInfo);
del_timer_sync(&pInfo->tmr);
TRACE_PS(" rx success: got %d chars", length);
/* prepare struct r3964_block_header: */
pBlock = kmalloc(length + sizeof(struct r3964_block_header),
GFP_KERNEL);
TRACE_M("on_receive_block - kmalloc %p", pBlock);
if (pBlock == NULL)
return;
pBlock->length = length;
pBlock->data = ((unsigned char *)pBlock) +
sizeof(struct r3964_block_header);
pBlock->locks = 0;
pBlock->next = NULL;
pBlock->owner = NULL;
memcpy(pBlock->data, pInfo->rx_buf, length);
/* queue block into rx_queue: */
add_rx_queue(pInfo, pBlock);
/* notify attached client processes: */
for (pClient = pInfo->firstClient; pClient; pClient = pClient->next) {
if (pClient->sig_flags & R3964_SIG_DATA) {
add_msg(pClient, R3964_MSG_DATA, length, R3964_OK,
pBlock);
}
}
wake_up_interruptible(&pInfo->read_wait);
pInfo->state = R3964_IDLE;
trigger_transmit(pInfo);
}
int
rte_event_eth_rx_adapter_queue_add(uint8_t id,
uint8_t eth_dev_id,
int32_t rx_queue_id,
const struct rte_event_eth_rx_adapter_queue_conf *queue_conf)
{
int ret;
uint32_t cap;
struct rte_event_eth_rx_adapter *rx_adapter;
struct rte_eventdev *dev;
struct eth_device_info *dev_info;
int start_service;
RTE_EVENT_ETH_RX_ADAPTER_ID_VALID_OR_ERR_RET(id, -EINVAL);
RTE_ETH_VALID_PORTID_OR_ERR_RET(eth_dev_id, -EINVAL);
rx_adapter = id_to_rx_adapter(id);
if ((rx_adapter == NULL) || (queue_conf == NULL))
return -EINVAL;
dev = &rte_eventdevs[rx_adapter->eventdev_id];
ret = rte_event_eth_rx_adapter_caps_get(rx_adapter->eventdev_id,
eth_dev_id,
&cap);
if (ret) {
RTE_EDEV_LOG_ERR("Failed to get adapter caps edev %" PRIu8
"eth port %" PRIu8, id, eth_dev_id);
return ret;
}
if ((cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_OVERRIDE_FLOW_ID) == 0
&& (queue_conf->rx_queue_flags &
RTE_EVENT_ETH_RX_ADAPTER_QUEUE_FLOW_ID_VALID)) {
RTE_EDEV_LOG_ERR("Flow ID override is not supported,"
" eth port: %" PRIu8 " adapter id: %" PRIu8,
eth_dev_id, id);
return -EINVAL;
}
if ((cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_MULTI_EVENTQ) == 0 &&
(rx_queue_id != -1)) {
RTE_EDEV_LOG_ERR("Rx queues can only be connected to single "
"event queue id %u eth port %u", id, eth_dev_id);
return -EINVAL;
}
if (rx_queue_id != -1 && (uint16_t)rx_queue_id >=
rte_eth_devices[eth_dev_id].data->nb_rx_queues) {
RTE_EDEV_LOG_ERR("Invalid rx queue_id %" PRIu16,
(uint16_t)rx_queue_id);
return -EINVAL;
}
start_service = 0;
dev_info = &rx_adapter->eth_devices[eth_dev_id];
if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_INTERNAL_PORT) {
RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->eth_rx_adapter_queue_add,
-ENOTSUP);
if (dev_info->rx_queue == NULL) {
dev_info->rx_queue =
rte_zmalloc_socket(rx_adapter->mem_name,
dev_info->dev->data->nb_rx_queues *
sizeof(struct eth_rx_queue_info), 0,
rx_adapter->socket_id);
if (dev_info->rx_queue == NULL)
return -ENOMEM;
}
ret = (*dev->dev_ops->eth_rx_adapter_queue_add)(dev,
&rte_eth_devices[eth_dev_id],
rx_queue_id, queue_conf);
if (ret == 0) {
update_queue_info(rx_adapter,
&rx_adapter->eth_devices[eth_dev_id],
rx_queue_id,
1);
}
} else {
rte_spinlock_lock(&rx_adapter->rx_lock);
ret = init_service(rx_adapter, id);
if (ret == 0)
ret = add_rx_queue(rx_adapter, eth_dev_id, rx_queue_id,
queue_conf);
rte_spinlock_unlock(&rx_adapter->rx_lock);
if (ret == 0)
start_service = !!sw_rx_adapter_queue_count(rx_adapter);
}
if (ret)
return ret;
if (start_service)
rte_service_component_runstate_set(rx_adapter->service_id, 1);
return 0;
}
