X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=drivers%2Fnet%2Fenic%2Fenic_res.c;h=9cfb857939da204f292a02f475fc85abc0a94f29;hb=2fe6f1b76279b13422e9562f8f94c35184e7ed0c;hp=abe004b241b3a7ba8c4d311a6e7a1364172bc3d3;hpb=323e7b667f18376c60351282950b28d4d0cc6165;p=dpdk.git diff --git a/drivers/net/enic/enic_res.c b/drivers/net/enic/enic_res.c index abe004b241..9cfb857939 100644 --- a/drivers/net/enic/enic_res.c +++ b/drivers/net/enic/enic_res.c @@ -4,7 +4,7 @@ */ #include "enic_compat.h" -#include "rte_ethdev_driver.h" +#include "ethdev_driver.h" #include "wq_enet_desc.h" #include "rq_enet_desc.h" #include "cq_enet_desc.h" @@ -25,6 +25,7 @@ int enic_get_vnic_config(struct enic *enic) { struct vnic_enet_config *c = &enic->config; int err; + uint64_t sizes; err = vnic_dev_get_mac_addr(enic->vdev, enic->mac_addr); if (err) { @@ -61,15 +62,15 @@ int enic_get_vnic_config(struct enic *enic) * and will be 0 for legacy firmware and VICs */ if (c->max_pkt_size > ENIC_DEFAULT_RX_MAX_PKT_SIZE) - enic->max_mtu = c->max_pkt_size - (ETHER_HDR_LEN + 4); + enic->max_mtu = c->max_pkt_size - RTE_ETHER_HDR_LEN; else - enic->max_mtu = ENIC_DEFAULT_RX_MAX_PKT_SIZE - - (ETHER_HDR_LEN + 4); + enic->max_mtu = ENIC_DEFAULT_RX_MAX_PKT_SIZE - + RTE_ETHER_HDR_LEN; if (c->mtu == 0) c->mtu = 1500; - enic->rte_dev->data->mtu = min_t(u16, enic->max_mtu, - max_t(u16, ENIC_MIN_MTU, c->mtu)); + enic->rte_dev->data->mtu = RTE_MIN(enic->max_mtu, + RTE_MAX((uint16_t)ENIC_MIN_MTU, c->mtu)); enic->adv_filters = vnic_dev_capable_adv_filters(enic->vdev); dev_info(enic, "Advanced Filters %savailable\n", ((enic->adv_filters) @@ -85,35 +86,34 @@ int enic_get_vnic_config(struct enic *enic) vnic_dev_capable_udp_rss_weak(enic->vdev, &enic->nic_cfg_chk, &enic->udp_rss_weak); - dev_info(enic, "Flow api filter mode: %s Actions: %s%s%s\n", + dev_info(enic, "Flow api filter mode: %s Actions: %s%s%s%s\n", + ((enic->flow_filter_mode == FILTER_FLOWMAN) ? "FLOWMAN" : ((enic->flow_filter_mode == FILTER_DPDK_1) ? "DPDK" : ((enic->flow_filter_mode == FILTER_USNIC_IP) ? "USNIC" : ((enic->flow_filter_mode == FILTER_IPV4_5TUPLE) ? "5TUPLE" : - "NONE"))), + "NONE")))), ((enic->filter_actions & FILTER_ACTION_RQ_STEERING_FLAG) ? "steer " : ""), ((enic->filter_actions & FILTER_ACTION_FILTER_ID_FLAG) ? "tag " : ""), ((enic->filter_actions & FILTER_ACTION_DROP_FLAG) ? - "drop " : "")); + "drop " : ""), + ((enic->filter_actions & FILTER_ACTION_COUNTER_FLAG) ? + "count " : "")); - c->wq_desc_count = - min_t(u32, ENIC_MAX_WQ_DESCS, - max_t(u32, ENIC_MIN_WQ_DESCS, - c->wq_desc_count)); + c->wq_desc_count = RTE_MIN((uint32_t)ENIC_MAX_WQ_DESCS, + RTE_MAX((uint32_t)ENIC_MIN_WQ_DESCS, c->wq_desc_count)); c->wq_desc_count &= 0xffffffe0; /* must be aligned to groups of 32 */ - c->rq_desc_count = - min_t(u32, ENIC_MAX_RQ_DESCS, - max_t(u32, ENIC_MIN_RQ_DESCS, - c->rq_desc_count)); + c->rq_desc_count = RTE_MIN((uint32_t)ENIC_MAX_RQ_DESCS, + RTE_MAX((uint32_t)ENIC_MIN_RQ_DESCS, c->rq_desc_count)); c->rq_desc_count &= 0xffffffe0; /* must be aligned to groups of 32 */ - c->intr_timer_usec = min_t(u32, c->intr_timer_usec, - vnic_dev_get_intr_coal_timer_max(enic->vdev)); + c->intr_timer_usec = RTE_MIN(c->intr_timer_usec, + vnic_dev_get_intr_coal_timer_max(enic->vdev)); dev_info(enic_get_dev(enic), - "vNIC MAC addr %02x:%02x:%02x:%02x:%02x:%02x " + "vNIC MAC addr " RTE_ETHER_ADDR_PRT_FMT "wq/rq %d/%d mtu %d, max mtu:%d\n", enic->mac_addr[0], enic->mac_addr[1], enic->mac_addr[2], enic->mac_addr[3], enic->mac_addr[4], enic->mac_addr[5], @@ -147,31 +147,31 @@ int enic_get_vnic_config(struct enic *enic) * IPV4 hash type handles both non-frag and frag packet types. * TCP/UDP is controlled via a separate flag below. */ - enic->flow_type_rss_offloads |= ETH_RSS_IPV4 | - ETH_RSS_FRAG_IPV4 | ETH_RSS_NONFRAG_IPV4_OTHER; + enic->flow_type_rss_offloads |= RTE_ETH_RSS_IPV4 | + RTE_ETH_RSS_FRAG_IPV4 | RTE_ETH_RSS_NONFRAG_IPV4_OTHER; if (ENIC_SETTING(enic, RSSHASH_TCPIPV4)) - enic->flow_type_rss_offloads |= ETH_RSS_NONFRAG_IPV4_TCP; + enic->flow_type_rss_offloads |= RTE_ETH_RSS_NONFRAG_IPV4_TCP; if (ENIC_SETTING(enic, RSSHASH_IPV6)) /* * The VIC adapter can perform RSS on IPv6 packets with and * without extension headers. An IPv6 "fragment" is an IPv6 * packet with the fragment extension header. */ - enic->flow_type_rss_offloads |= ETH_RSS_IPV6 | - ETH_RSS_IPV6_EX | ETH_RSS_FRAG_IPV6 | - ETH_RSS_NONFRAG_IPV6_OTHER; + enic->flow_type_rss_offloads |= RTE_ETH_RSS_IPV6 | + RTE_ETH_RSS_IPV6_EX | RTE_ETH_RSS_FRAG_IPV6 | + RTE_ETH_RSS_NONFRAG_IPV6_OTHER; if (ENIC_SETTING(enic, RSSHASH_TCPIPV6)) - enic->flow_type_rss_offloads |= ETH_RSS_NONFRAG_IPV6_TCP | - ETH_RSS_IPV6_TCP_EX; + enic->flow_type_rss_offloads |= RTE_ETH_RSS_NONFRAG_IPV6_TCP | + RTE_ETH_RSS_IPV6_TCP_EX; if (enic->udp_rss_weak) enic->flow_type_rss_offloads |= - ETH_RSS_NONFRAG_IPV4_UDP | ETH_RSS_NONFRAG_IPV6_UDP | - ETH_RSS_IPV6_UDP_EX; + RTE_ETH_RSS_NONFRAG_IPV4_UDP | RTE_ETH_RSS_NONFRAG_IPV6_UDP | + RTE_ETH_RSS_IPV6_UDP_EX; if (ENIC_SETTING(enic, RSSHASH_UDPIPV4)) - enic->flow_type_rss_offloads |= ETH_RSS_NONFRAG_IPV4_UDP; + enic->flow_type_rss_offloads |= RTE_ETH_RSS_NONFRAG_IPV4_UDP; if (ENIC_SETTING(enic, RSSHASH_UDPIPV6)) - enic->flow_type_rss_offloads |= ETH_RSS_NONFRAG_IPV6_UDP | - ETH_RSS_IPV6_UDP_EX; + enic->flow_type_rss_offloads |= RTE_ETH_RSS_NONFRAG_IPV6_UDP | + RTE_ETH_RSS_IPV6_UDP_EX; /* Zero offloads if RSS is not enabled */ if (!ENIC_SETTING(enic, RSS)) @@ -179,6 +179,21 @@ int enic_get_vnic_config(struct enic *enic) enic->vxlan = ENIC_SETTING(enic, VXLAN) && vnic_dev_capable_vxlan(enic->vdev); + enic->geneve = ENIC_SETTING(enic, GENEVE) && + vnic_dev_capable_geneve(enic->vdev); + + /* Supported CQ entry sizes */ + enic->cq_entry_sizes = vnic_dev_capable_cq_entry_size(enic->vdev); + sizes = enic->cq_entry_sizes; + dev_debug(NULL, "Supported CQ entry sizes:%s%s%s\n", + (sizes & VNIC_RQ_CQ_ENTRY_SIZE_16_CAPABLE) ? " 16" : "", + (sizes & VNIC_RQ_CQ_ENTRY_SIZE_32_CAPABLE) ? " 32" : "", + (sizes & VNIC_RQ_CQ_ENTRY_SIZE_64_CAPABLE) ? " 64" : ""); + /* Use 64B entry if requested and available */ + enic->cq64 = enic->cq64_request && + (sizes & VNIC_RQ_CQ_ENTRY_SIZE_64_CAPABLE); + dev_debug(NULL, "Using %sB CQ entry size\n", enic->cq64 ? "64" : "16"); + /* * Default hardware capabilities. enic_dev_init() may add additional * flags if it enables overlay offloads. @@ -186,61 +201,38 @@ int enic_get_vnic_config(struct enic *enic) enic->tx_queue_offload_capa = 0; enic->tx_offload_capa = enic->tx_queue_offload_capa | - DEV_TX_OFFLOAD_MULTI_SEGS | - DEV_TX_OFFLOAD_VLAN_INSERT | - DEV_TX_OFFLOAD_IPV4_CKSUM | - DEV_TX_OFFLOAD_UDP_CKSUM | - DEV_TX_OFFLOAD_TCP_CKSUM | - DEV_TX_OFFLOAD_TCP_TSO; + RTE_ETH_TX_OFFLOAD_MULTI_SEGS | + RTE_ETH_TX_OFFLOAD_VLAN_INSERT | + RTE_ETH_TX_OFFLOAD_IPV4_CKSUM | + RTE_ETH_TX_OFFLOAD_UDP_CKSUM | + RTE_ETH_TX_OFFLOAD_TCP_CKSUM | + RTE_ETH_TX_OFFLOAD_TCP_TSO; enic->rx_offload_capa = - DEV_RX_OFFLOAD_SCATTER | - DEV_RX_OFFLOAD_JUMBO_FRAME | - DEV_RX_OFFLOAD_VLAN_STRIP | - DEV_RX_OFFLOAD_IPV4_CKSUM | - DEV_RX_OFFLOAD_UDP_CKSUM | - DEV_RX_OFFLOAD_TCP_CKSUM; + RTE_ETH_RX_OFFLOAD_SCATTER | + RTE_ETH_RX_OFFLOAD_VLAN_STRIP | + RTE_ETH_RX_OFFLOAD_IPV4_CKSUM | + RTE_ETH_RX_OFFLOAD_UDP_CKSUM | + RTE_ETH_RX_OFFLOAD_TCP_CKSUM | + RTE_ETH_RX_OFFLOAD_RSS_HASH; enic->tx_offload_mask = - PKT_TX_VLAN_PKT | - PKT_TX_IP_CKSUM | - PKT_TX_L4_MASK | - PKT_TX_TCP_SEG; + RTE_MBUF_F_TX_IPV6 | + RTE_MBUF_F_TX_IPV4 | + RTE_MBUF_F_TX_VLAN | + RTE_MBUF_F_TX_IP_CKSUM | + RTE_MBUF_F_TX_L4_MASK | + RTE_MBUF_F_TX_TCP_SEG; return 0; } -int enic_add_vlan(struct enic *enic, u16 vlanid) -{ - u64 a0 = vlanid, a1 = 0; - int wait = 1000; - int err; - - err = vnic_dev_cmd(enic->vdev, CMD_VLAN_ADD, &a0, &a1, wait); - if (err) - dev_err(enic_get_dev(enic), "Can't add vlan id, %d\n", err); - - return err; -} - -int enic_del_vlan(struct enic *enic, u16 vlanid) -{ - u64 a0 = vlanid, a1 = 0; - int wait = 1000; - int err; - - err = vnic_dev_cmd(enic->vdev, CMD_VLAN_DEL, &a0, &a1, wait); - if (err) - dev_err(enic_get_dev(enic), "Can't delete vlan id, %d\n", err); - - return err; -} - -int enic_set_nic_cfg(struct enic *enic, u8 rss_default_cpu, u8 rss_hash_type, - u8 rss_hash_bits, u8 rss_base_cpu, u8 rss_enable, u8 tso_ipid_split_en, - u8 ig_vlan_strip_en) +int enic_set_nic_cfg(struct enic *enic, uint8_t rss_default_cpu, + uint8_t rss_hash_type, uint8_t rss_hash_bits, + uint8_t rss_base_cpu, uint8_t rss_enable, + uint8_t tso_ipid_split_en, uint8_t ig_vlan_strip_en) { enum vnic_devcmd_cmd cmd; - u64 a0, a1; - u32 nic_cfg; + uint64_t a0, a1; + uint32_t nic_cfg; int wait = 1000; vnic_set_nic_cfg(&nic_cfg, rss_default_cpu, @@ -253,17 +245,17 @@ int enic_set_nic_cfg(struct enic *enic, u8 rss_default_cpu, u8 rss_hash_type, return vnic_dev_cmd(enic->vdev, cmd, &a0, &a1, wait); } -int enic_set_rss_key(struct enic *enic, dma_addr_t key_pa, u64 len) +int enic_set_rss_key(struct enic *enic, dma_addr_t key_pa, uint64_t len) { - u64 a0 = (u64)key_pa, a1 = len; + uint64_t a0 = (uint64_t)key_pa, a1 = len; int wait = 1000; return vnic_dev_cmd(enic->vdev, CMD_RSS_KEY, &a0, &a1, wait); } -int enic_set_rss_cpu(struct enic *enic, dma_addr_t cpu_pa, u64 len) +int enic_set_rss_cpu(struct enic *enic, dma_addr_t cpu_pa, uint64_t len) { - u64 a0 = (u64)cpu_pa, a1 = len; + uint64_t a0 = (uint64_t)cpu_pa, a1 = len; int wait = 1000; return vnic_dev_cmd(enic->vdev, CMD_RSS_CPU, &a0, &a1, wait);