return enic->pdev->id.device_id == PCI_DEVICE_ID_CISCO_VIC_ENET_VF;
}
-static int is_zero_addr(char *addr)
+static int is_zero_addr(uint8_t *addr)
{
return !(addr[0] | addr[1] | addr[2] | addr[3] | addr[4] | addr[5]);
}
-static int is_mcast_addr(char *addr)
+static int is_mcast_addr(uint8_t *addr)
{
return addr[0] & 1;
}
-static int is_eth_addr_valid(char *addr)
+static int is_eth_addr_valid(uint8_t *addr)
{
return !is_mcast_addr(addr) && !is_zero_addr(addr);
}
return m;
}
-static const struct rte_memzone *ring_dma_zone_reserve(
- struct rte_eth_dev *dev, const char *ring_name,
- uint16_t queue_id, uint32_t ring_size, int socket_id)
-{
- char z_name[RTE_MEMZONE_NAMESIZE];
- const struct rte_memzone *mz;
-
- snprintf(z_name, sizeof(z_name), "%s_%s_%d_%d",
- dev->driver->pci_drv.name, ring_name,
- dev->data->port_id, queue_id);
-
- mz = rte_memzone_lookup(z_name);
- if (mz)
- return mz;
-
- return rte_memzone_reserve_aligned(z_name, (uint64_t) ring_size,
- socket_id, RTE_MEMZONE_1GB, ENIC_ALIGN);
-}
-
void enic_set_hdr_split_size(struct enic *enic, u16 split_hdr_size)
{
vnic_set_hdr_split_size(enic->vdev, split_hdr_size);
}
-static void enic_free_wq_buf(struct vnic_wq *wq, struct vnic_wq_buf *buf)
+static void enic_free_wq_buf(__rte_unused struct vnic_wq *wq, struct vnic_wq_buf *buf)
{
struct rte_mbuf *mbuf = (struct rte_mbuf *)buf->os_buf;
}
static void enic_wq_free_buf(struct vnic_wq *wq,
- struct cq_desc *cq_desc, struct vnic_wq_buf *buf, void *opaque)
+ __rte_unused struct cq_desc *cq_desc,
+ struct vnic_wq_buf *buf,
+ __rte_unused void *opaque)
{
enic_free_wq_buf(wq, buf);
}
static int enic_wq_service(struct vnic_dev *vdev, struct cq_desc *cq_desc,
- u8 type, u16 q_number, u16 completed_index, void *opaque)
+ __rte_unused u8 type, u16 q_number, u16 completed_index, void *opaque)
{
struct enic *enic = vnic_dev_priv(vdev);
int enic_send_pkt(struct enic *enic, struct vnic_wq *wq,
struct rte_mbuf *tx_pkt, unsigned short len,
- u_int8_t sop, u_int8_t eop,
- u_int16_t ol_flags, u_int16_t vlan_tag)
+ uint8_t sop, uint8_t eop,
+ uint16_t ol_flags, uint16_t vlan_tag)
{
struct wq_enet_desc *desc = vnic_wq_next_desc(wq);
- u_int16_t mss = 0;
- u_int16_t header_length = 0;
- u_int8_t cq_entry = eop;
- u_int8_t vlan_tag_insert = 0;
- unsigned char *buf = (unsigned char *)(tx_pkt->buf_addr) +
- RTE_PKTMBUF_HEADROOM;
- u_int64_t bus_addr = (dma_addr_t)
+ uint16_t mss = 0;
+ uint8_t cq_entry = eop;
+ uint8_t vlan_tag_insert = 0;
+ uint64_t bus_addr = (dma_addr_t)
(tx_pkt->buf_physaddr + RTE_PKTMBUF_HEADROOM);
if (sop) {
{
struct vnic_stats *stats;
- memset(r_stats, 0, sizeof(*r_stats));
if (vnic_dev_stats_dump(enic->vdev, &stats)) {
dev_err(enic, "Error in getting stats\n");
return;
}
}
-static void enic_free_rq_buf(struct vnic_rq *rq, struct vnic_rq_buf *buf)
+static void
+enic_free_rq_buf(__rte_unused struct vnic_rq *rq, struct vnic_rq_buf *buf)
{
- struct enic *enic = vnic_dev_priv(rq->vdev);
-
if (!buf->os_buf)
return;
{
unsigned int error_interrupt_enable = 1;
unsigned int error_interrupt_offset = 0;
- int index = 0;
- unsigned int cq_index = 0;
+ unsigned int index = 0;
for (index = 0; index < enic->rq_count; index++) {
vnic_rq_init(&enic->rq[index],
static int enic_rq_alloc_buf(struct vnic_rq *rq)
{
struct enic *enic = vnic_dev_priv(rq->vdev);
- void *buf;
dma_addr_t dma_addr;
struct rq_enet_desc *desc = vnic_rq_next_desc(rq);
- u_int8_t type = RQ_ENET_TYPE_ONLY_SOP;
- u_int16_t len = ENIC_MAX_MTU + VLAN_ETH_HLEN;
+ uint8_t type = RQ_ENET_TYPE_ONLY_SOP;
u16 split_hdr_size = vnic_get_hdr_split_size(enic->vdev);
struct rte_mbuf *mbuf = enic_rxmbuf_alloc(rq->mp);
struct rte_mbuf *hdr_mbuf = NULL;
}
hdr_mbuf->data_off = RTE_PKTMBUF_HEADROOM;
- buf = rte_pktmbuf_mtod(hdr_mbuf, void *);
hdr_mbuf->nb_segs = 2;
- hdr_mbuf->port = rq->index;
+ hdr_mbuf->port = enic->port_id;
hdr_mbuf->next = mbuf;
dma_addr = (dma_addr_t)
type = RQ_ENET_TYPE_NOT_SOP;
} else {
mbuf->nb_segs = 1;
- mbuf->port = rq->index;
+ mbuf->port = enic->port_id;
}
mbuf->data_off = RTE_PKTMBUF_HEADROOM;
- buf = rte_pktmbuf_mtod(mbuf, void *);
mbuf->next = NULL;
dma_addr = (dma_addr_t)
&ipv4_csum_ok, &ipv6, &ipv4, &ipv4_fragment,
&fcs_ok);
- if (packet_error) {
- dev_err(enic, "packet error\n");
- return;
- }
-
rx_pkt = (struct rte_mbuf *)buf->os_buf;
buf->os_buf = NULL;
+ if (unlikely(packet_error)) {
+ dev_err(enic, "packet error\n");
+ rx_pkt->data_len = 0;
+ return 0;
+ }
+
if (unlikely(skipped)) {
rx_pkt->data_len = 0;
return 0;
}
static int enic_rq_service(struct vnic_dev *vdev, struct cq_desc *cq_desc,
- u8 type, u16 q_number, u16 completed_index, void *opaque)
+ __rte_unused u8 type, u16 q_number, u16 completed_index, void *opaque)
{
struct enic *enic = vnic_dev_priv(vdev);
return err;
}
-void *enic_alloc_consistent(void *priv, size_t size,
+static void *
+enic_alloc_consistent(__rte_unused void *priv, size_t size,
dma_addr_t *dma_handle, u8 *name)
{
- struct enic *enic = (struct enic *)priv;
void *vaddr;
const struct rte_memzone *rz;
*dma_handle = 0;
- rz = rte_memzone_reserve_aligned(name, size, 0, 0, ENIC_ALIGN);
+ rz = rte_memzone_reserve_aligned((const char *)name,
+ size, 0, 0, ENIC_ALIGN);
if (!rz) {
pr_err("%s : Failed to allocate memory requested for %s",
__func__, name);
return vaddr;
}
-void enic_free_consistent(struct rte_pci_device *hwdev, size_t size,
- void *vaddr, dma_addr_t dma_handle)
+static void
+enic_free_consistent(__rte_unused struct rte_pci_device *hwdev,
+ __rte_unused size_t size,
+ __rte_unused void *vaddr,
+ __rte_unused dma_addr_t dma_handle)
{
/* Nothing to be done */
}
-void enic_intr_handler(__rte_unused struct rte_intr_handle *handle,
+static void
+enic_intr_handler(__rte_unused struct rte_intr_handle *handle,
void *arg)
{
struct enic *enic = pmd_priv((struct rte_eth_dev *)arg);
- dev_err(enic, "Err intr.\n");
vnic_intr_return_all_credits(&enic->intr);
enic_log_q_error(enic);
int enic_enable(struct enic *enic)
{
- int index;
- void *res;
- char mz_name[RTE_MEMZONE_NAMESIZE];
- const struct rte_memzone *rmz;
+ unsigned int index;
struct rte_eth_dev *eth_dev = enic->rte_dev;
eth_dev->data->dev_link.link_speed = vnic_dev_port_speed(enic->vdev);
vnic_dev_enable_wait(enic->vdev);
-#ifndef VFIO_PRESENT
/* Register and enable error interrupt */
rte_intr_callback_register(&(enic->pdev->intr_handle),
enic_intr_handler, (void *)enic->rte_dev);
rte_intr_enable(&(enic->pdev->intr_handle));
-#endif
vnic_intr_unmask(&enic->intr);
return 0;
{
dma_addr_t rss_key_buf_pa;
union vnic_rss_key *rss_key_buf_va = NULL;
- union vnic_rss_key rss_key = {
- .key[0].b = {85, 67, 83, 97, 119, 101, 115, 111, 109, 101},
- .key[1].b = {80, 65, 76, 79, 117, 110, 105, 113, 117, 101},
- .key[2].b = {76, 73, 78, 85, 88, 114, 111, 99, 107, 115},
- .key[3].b = {69, 78, 73, 67, 105, 115, 99, 111, 111, 108},
+ static union vnic_rss_key rss_key = {
+ .key = {
+ [0] = {.b = {85, 67, 83, 97, 119, 101, 115, 111, 109, 101}},
+ [1] = {.b = {80, 65, 76, 79, 117, 110, 105, 113, 117, 101}},
+ [2] = {.b = {76, 73, 78, 85, 88, 114, 111, 99, 107, 115}},
+ [3] = {.b = {69, 78, 73, 67, 105, 115, 99, 111, 111, 108}},
+ }
};
int err;
- char name[NAME_MAX];
+ u8 name[NAME_MAX];
- snprintf(name, NAME_MAX, "rss_key-%s", enic->bdf_name);
+ snprintf((char *)name, NAME_MAX, "rss_key-%s", enic->bdf_name);
rss_key_buf_va = enic_alloc_consistent(enic, sizeof(union vnic_rss_key),
&rss_key_buf_pa, name);
if (!rss_key_buf_va)
{
dma_addr_t rss_cpu_buf_pa;
union vnic_rss_cpu *rss_cpu_buf_va = NULL;
- unsigned int i;
+ int i;
int err;
- char name[NAME_MAX];
+ u8 name[NAME_MAX];
- snprintf(name, NAME_MAX, "rss_cpu-%s", enic->bdf_name);
+ snprintf((char *)name, NAME_MAX, "rss_cpu-%s", enic->bdf_name);
rss_cpu_buf_va = enic_alloc_consistent(enic, sizeof(union vnic_rss_cpu),
&rss_cpu_buf_pa, name);
if (!rss_cpu_buf_va)
return 0;
}
-#ifdef VFIO_PRESENT
-static void enic_eventfd_init(struct enic *enic)
-{
- enic->eventfd = enic->pdev->intr_handle.fd;
-}
-
-void *enic_err_intr_handler(void *arg)
-{
- struct enic *enic = (struct enic *)arg;
- unsigned int intr = enic_msix_err_intr(enic);
- ssize_t size;
- uint64_t data;
-
- while (1) {
- size = read(enic->eventfd, &data, sizeof(data));
- dev_err(enic, "Err intr.\n");
- vnic_intr_return_all_credits(&enic->intr);
-
- enic_log_q_error(enic);
- }
-
- return NULL;
-}
-#endif
-
void enic_add_packet_filter(struct enic *enic)
{
/* Args -> directed, multicast, broadcast, promisc, allmulti */
return vnic_dev_link_status(enic->vdev);
}
-
-#ifdef VFIO_PRESENT
-static int enic_create_err_intr_thread(struct enic *enic)
-{
- pthread_attr_t intr_attr;
-
- /* create threads for error interrupt handling */
- pthread_attr_init(&intr_attr);
- pthread_attr_setstacksize(&intr_attr, 0x100000);
-
- /* ERR */
- if (pthread_create(&enic->err_intr_thread, &intr_attr,
- enic_err_intr_handler, (void *)enic)) {
- dev_err(enic, "Failed to create err interrupt handler threads\n");
- return -1;
- }
-
- pthread_attr_destroy(&intr_attr);
-
- return 0;
-}
-
-
-static int enic_set_intr_mode(struct enic *enic)
-{
- struct vfio_irq_set *irq_set;
- int *fds;
- int size;
- int ret = -1;
- int index;
-
- if (enic->intr_count < 1) {
- dev_err(enic, "Unsupported resource conf.\n");
- return -1;
- }
- vnic_dev_set_intr_mode(enic->vdev, VNIC_DEV_INTR_MODE_MSIX);
-
- enic->intr_count = 1;
-
- enic_eventfd_init(enic);
- size = sizeof(*irq_set) + (sizeof(int));
-
- irq_set = rte_zmalloc("enic_vfio_irq", size, 0);
- irq_set->argsz = size;
- irq_set->index = VFIO_PCI_MSIX_IRQ_INDEX;
- irq_set->start = 0;
- irq_set->count = 1; /* For error interrupt only */
- irq_set->flags = VFIO_IRQ_SET_DATA_EVENTFD |
- VFIO_IRQ_SET_ACTION_TRIGGER;
- fds = (int *)&irq_set->data;
-
- fds[0] = enic->eventfd;
-
- ret = ioctl(enic->pdev->intr_handle.vfio_dev_fd,
- VFIO_DEVICE_SET_IRQS, irq_set);
- rte_free(irq_set);
- if (ret) {
- dev_err(enic, "Failed to set eventfds for interrupts\n");
- return -1;
- }
-
- enic_create_err_intr_thread(enic);
- return 0;
-}
-
-static void enic_clear_intr_mode(struct enic *enic)
-{
- vnic_dev_set_intr_mode(enic->vdev, VNIC_DEV_INTR_MODE_UNKNOWN);
-}
-#endif
-
static void enic_dev_deinit(struct enic *enic)
{
- unsigned int i;
struct rte_eth_dev *eth_dev = enic->rte_dev;
- if (eth_dev->data->mac_addrs)
- rte_free(eth_dev->data->mac_addrs);
-
-#ifdef VFIO_PRESENT
- enic_clear_intr_mode(enic);
-#endif
+ rte_free(eth_dev->data->mac_addrs);
}
static int enic_dev_init(struct enic *enic)
{
- unsigned int i;
int err;
struct rte_eth_dev *eth_dev = enic->rte_dev;
*/
enic_get_res_counts(enic);
-#ifdef VFIO_PRESENT
- /* Set interrupt mode based on resource counts and system
- * capabilities
- */
- err = enic_set_intr_mode(enic);
- if (err) {
- rte_free(eth_dev->data->mac_addrs);
- enic_clear_intr_mode(enic);
- dev_err(dev, "Failed to set intr mode based on resource "\
- "counts and system capabilities, aborting\n");
- return err;
- }
-#endif
-
vnic_dev_set_reset_flag(enic->vdev, 0);
return 0;
int enic_probe(struct enic *enic)
{
- const char *bdf = enic->bdf_name;
struct rte_pci_device *pdev = enic->pdev;
- struct rte_eth_dev *eth_dev = enic->rte_dev;
- unsigned int i;
int err = -1;
- dev_info(enic, " Initializing ENIC PMD version %s\n", DRV_VERSION);
+ dev_debug(enic, " Initializing ENIC PMD version %s\n", DRV_VERSION);
enic->bar0.vaddr = (void *)pdev->mem_resource[0].addr;
enic->bar0.len = pdev->mem_resource[0].len;
git.droids-corp.org / dpdk.git / blobdiff