Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright(c) 2024 ZTE Corporation
3 : : */
4 : :
5 : : #include <ethdev_pci.h>
6 : : #include <bus_pci_driver.h>
7 : : #include <rte_ethdev.h>
8 : : #include <rte_malloc.h>
9 : :
10 : : #include "zxdh_ethdev.h"
11 : : #include "zxdh_logs.h"
12 : : #include "zxdh_pci.h"
13 : : #include "zxdh_msg.h"
14 : : #include "zxdh_common.h"
15 : : #include "zxdh_queue.h"
16 : : #include "zxdh_np.h"
17 : : #include "zxdh_tables.h"
18 : : #include "zxdh_rxtx.h"
19 : : #include "zxdh_ethdev_ops.h"
20 : :
21 : : struct zxdh_hw_internal zxdh_hw_internal[RTE_MAX_ETHPORTS];
22 : : struct zxdh_dev_shared_data g_dev_sd[ZXDH_SLOT_MAX];
23 : : static rte_spinlock_t zxdh_shared_data_lock = RTE_SPINLOCK_INITIALIZER;
24 : : struct zxdh_shared_data *zxdh_shared_data;
25 : : struct zxdh_net_hdr_dl g_net_hdr_dl[RTE_MAX_ETHPORTS];
26 : : struct zxdh_mtr_res g_mtr_res;
27 : :
28 : : #define ZXDH_INVALID_DTBQUE 0xFFFF
29 : : #define ZXDH_INVALID_SLOT_IDX 0xFFFF
30 : : #define ZXDH_PF_QUEUE_PAIRS_ADDR 0x5742
31 : : #define ZXDH_VF_QUEUE_PAIRS_ADDR 0x5744
32 : : #define ZXDH_QUEUE_POOL_ADDR 0x56A0
33 : :
34 : : uint16_t
35 : 0 : zxdh_vport_to_vfid(union zxdh_virport_num v)
36 : : {
37 : : /* epid > 4 is local soft queue. return 1192 */
38 [ # # ]: 0 : if (v.epid > 4)
39 : : return 1192;
40 [ # # ]: 0 : if (v.vf_flag)
41 : 0 : return v.epid * 256 + v.vfid;
42 : : else
43 : 0 : return (v.epid * 8 + v.pfid) + 1152;
44 : : }
45 : :
46 : : static int32_t
47 : 0 : zxdh_dev_infos_get(struct rte_eth_dev *dev,
48 : : struct rte_eth_dev_info *dev_info)
49 : : {
50 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
51 : :
52 : 0 : dev_info->speed_capa = rte_eth_speed_bitflag(hw->speed, RTE_ETH_LINK_FULL_DUPLEX);
53 : 0 : dev_info->max_rx_queues = hw->max_queue_pairs;
54 : 0 : dev_info->max_tx_queues = hw->max_queue_pairs;
55 : 0 : dev_info->min_rx_bufsize = ZXDH_MIN_RX_BUFSIZE;
56 : 0 : dev_info->max_rx_pktlen = ZXDH_MAX_RX_PKTLEN;
57 : 0 : dev_info->max_mac_addrs = ZXDH_MAX_MAC_ADDRS;
58 : : dev_info->rx_offload_capa = (RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
59 : : RTE_ETH_RX_OFFLOAD_VLAN_FILTER |
60 : : RTE_ETH_RX_OFFLOAD_QINQ_STRIP);
61 : : dev_info->rx_offload_capa |= (RTE_ETH_RX_OFFLOAD_IPV4_CKSUM |
62 : : RTE_ETH_RX_OFFLOAD_UDP_CKSUM |
63 : : RTE_ETH_RX_OFFLOAD_TCP_CKSUM |
64 : : RTE_ETH_RX_OFFLOAD_OUTER_IPV4_CKSUM);
65 : : dev_info->rx_offload_capa |= (RTE_ETH_RX_OFFLOAD_SCATTER);
66 : : dev_info->rx_offload_capa |= RTE_ETH_RX_OFFLOAD_TCP_LRO;
67 : 0 : dev_info->rx_offload_capa |= RTE_ETH_RX_OFFLOAD_RSS_HASH;
68 : :
69 : 0 : dev_info->reta_size = RTE_ETH_RSS_RETA_SIZE_256;
70 : 0 : dev_info->flow_type_rss_offloads = ZXDH_RSS_HF;
71 : :
72 : 0 : dev_info->max_mtu = ZXDH_MAX_RX_PKTLEN - RTE_ETHER_HDR_LEN -
73 : : RTE_VLAN_HLEN - ZXDH_DL_NET_HDR_SIZE;
74 : 0 : dev_info->min_mtu = ZXDH_ETHER_MIN_MTU;
75 : :
76 : : dev_info->tx_offload_capa = (RTE_ETH_TX_OFFLOAD_MULTI_SEGS);
77 : : dev_info->tx_offload_capa |= (RTE_ETH_TX_OFFLOAD_TCP_TSO |
78 : : RTE_ETH_TX_OFFLOAD_UDP_TSO);
79 : : dev_info->tx_offload_capa |= (RTE_ETH_TX_OFFLOAD_VLAN_INSERT |
80 : : RTE_ETH_TX_OFFLOAD_QINQ_INSERT |
81 : : RTE_ETH_TX_OFFLOAD_VXLAN_TNL_TSO);
82 : 0 : dev_info->tx_offload_capa |= (RTE_ETH_TX_OFFLOAD_IPV4_CKSUM |
83 : : RTE_ETH_TX_OFFLOAD_UDP_CKSUM |
84 : : RTE_ETH_TX_OFFLOAD_TCP_CKSUM |
85 : : RTE_ETH_TX_OFFLOAD_OUTER_IPV4_CKSUM |
86 : : RTE_ETH_TX_OFFLOAD_OUTER_UDP_CKSUM);
87 : :
88 : 0 : return 0;
89 : : }
90 : :
91 : : static void
92 : 0 : zxdh_queues_unbind_intr(struct rte_eth_dev *dev)
93 : : {
94 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
95 : : int32_t i;
96 : :
97 [ # # ]: 0 : for (i = 0; i < dev->data->nb_rx_queues; ++i)
98 : 0 : ZXDH_VTPCI_OPS(hw)->set_queue_irq(hw, hw->vqs[i * 2], ZXDH_MSI_NO_VECTOR);
99 : :
100 [ # # ]: 0 : for (i = 0; i < dev->data->nb_tx_queues; ++i)
101 : 0 : ZXDH_VTPCI_OPS(hw)->set_queue_irq(hw, hw->vqs[i * 2 + 1], ZXDH_MSI_NO_VECTOR);
102 : 0 : }
103 : :
104 : :
105 : : static int32_t
106 : 0 : zxdh_intr_unmask(struct rte_eth_dev *dev)
107 : : {
108 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
109 : :
110 [ # # ]: 0 : if (rte_intr_ack(dev->intr_handle) < 0)
111 : : return -1;
112 : :
113 : 0 : hw->use_msix = zxdh_pci_msix_detect(RTE_ETH_DEV_TO_PCI(dev));
114 : :
115 : 0 : return 0;
116 : : }
117 : :
118 : : static void
119 : 0 : zxdh_devconf_intr_handler(void *param)
120 : : {
121 : : struct rte_eth_dev *dev = param;
122 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
123 : :
124 : 0 : uint8_t isr = zxdh_pci_isr(hw);
125 : :
126 [ # # ]: 0 : if (zxdh_intr_unmask(dev) < 0)
127 : 0 : PMD_DRV_LOG(ERR, "interrupt enable failed");
128 [ # # ]: 0 : if (isr & ZXDH_PCI_ISR_CONFIG) {
129 [ # # ]: 0 : if (zxdh_dev_link_update(dev, 0) == 0)
130 : 0 : rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_INTR_LSC, NULL);
131 : : }
132 : 0 : }
133 : :
134 : :
135 : : /* Interrupt handler triggered by NIC for handling specific interrupt. */
136 : : static void
137 : 0 : zxdh_fromriscv_intr_handler(void *param)
138 : : {
139 : : struct rte_eth_dev *dev = param;
140 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
141 : 0 : uint64_t virt_addr = (uint64_t)(hw->bar_addr[ZXDH_BAR0_INDEX] + ZXDH_CTRLCH_OFFSET);
142 : :
143 [ # # ]: 0 : if (hw->is_pf) {
144 : 0 : PMD_DRV_LOG(DEBUG, "zxdh_risc2pf_intr_handler");
145 : 0 : zxdh_bar_irq_recv(ZXDH_MSG_CHAN_END_RISC, ZXDH_MSG_CHAN_END_PF, virt_addr, dev);
146 : : } else {
147 : 0 : PMD_DRV_LOG(DEBUG, "zxdh_riscvf_intr_handler");
148 : 0 : zxdh_bar_irq_recv(ZXDH_MSG_CHAN_END_RISC, ZXDH_MSG_CHAN_END_VF, virt_addr, dev);
149 : : }
150 : 0 : }
151 : :
152 : : /* Interrupt handler triggered by NIC for handling specific interrupt. */
153 : : static void
154 : 0 : zxdh_frompfvf_intr_handler(void *param)
155 : : {
156 : : struct rte_eth_dev *dev = param;
157 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
158 : 0 : uint64_t virt_addr = (uint64_t)(hw->bar_addr[ZXDH_BAR0_INDEX] +
159 : : ZXDH_MSG_CHAN_PFVFSHARE_OFFSET);
160 : :
161 [ # # ]: 0 : if (hw->is_pf) {
162 : 0 : PMD_DRV_LOG(DEBUG, "zxdh_vf2pf_intr_handler");
163 : 0 : zxdh_bar_irq_recv(ZXDH_MSG_CHAN_END_VF, ZXDH_MSG_CHAN_END_PF, virt_addr, dev);
164 : : } else {
165 : 0 : PMD_DRV_LOG(DEBUG, "zxdh_pf2vf_intr_handler");
166 : 0 : zxdh_bar_irq_recv(ZXDH_MSG_CHAN_END_PF, ZXDH_MSG_CHAN_END_VF, virt_addr, dev);
167 : : }
168 : 0 : }
169 : :
170 : : static void
171 : 0 : zxdh_intr_cb_reg(struct rte_eth_dev *dev)
172 : : {
173 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
174 : :
175 [ # # ]: 0 : if (dev->data->dev_flags & RTE_ETH_DEV_INTR_LSC)
176 : 0 : rte_intr_callback_unregister(dev->intr_handle, zxdh_devconf_intr_handler, dev);
177 : :
178 : : /* register callback to update dev config intr */
179 : 0 : rte_intr_callback_register(dev->intr_handle, zxdh_devconf_intr_handler, dev);
180 : : /* Register rsic_v to pf interrupt callback */
181 : 0 : struct rte_intr_handle *tmp = hw->risc_intr +
182 : : (ZXDH_MSIX_FROM_PFVF - ZXDH_MSIX_INTR_MSG_VEC_BASE);
183 : :
184 : 0 : rte_intr_callback_register(tmp, zxdh_frompfvf_intr_handler, dev);
185 : :
186 : 0 : tmp = hw->risc_intr + (ZXDH_MSIX_FROM_RISCV - ZXDH_MSIX_INTR_MSG_VEC_BASE);
187 : 0 : rte_intr_callback_register(tmp, zxdh_fromriscv_intr_handler, dev);
188 : 0 : }
189 : :
190 : : static void
191 : 0 : zxdh_intr_cb_unreg(struct rte_eth_dev *dev)
192 : : {
193 [ # # ]: 0 : if (dev->data->dev_flags & RTE_ETH_DEV_INTR_LSC)
194 : 0 : rte_intr_callback_unregister(dev->intr_handle, zxdh_devconf_intr_handler, dev);
195 : :
196 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
197 : :
198 : : /* register callback to update dev config intr */
199 : 0 : rte_intr_callback_unregister(dev->intr_handle, zxdh_devconf_intr_handler, dev);
200 : : /* Register rsic_v to pf interrupt callback */
201 : 0 : struct rte_intr_handle *tmp = hw->risc_intr +
202 : : (ZXDH_MSIX_FROM_PFVF - ZXDH_MSIX_INTR_MSG_VEC_BASE);
203 : :
204 : 0 : rte_intr_callback_unregister(tmp, zxdh_frompfvf_intr_handler, dev);
205 : 0 : tmp = hw->risc_intr + (ZXDH_MSIX_FROM_RISCV - ZXDH_MSIX_INTR_MSG_VEC_BASE);
206 : 0 : rte_intr_callback_unregister(tmp, zxdh_fromriscv_intr_handler, dev);
207 : 0 : }
208 : :
209 : : static int32_t
210 : 0 : zxdh_intr_disable(struct rte_eth_dev *dev)
211 : : {
212 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
213 : :
214 [ # # ]: 0 : if (!hw->intr_enabled)
215 : : return 0;
216 : :
217 : 0 : zxdh_intr_cb_unreg(dev);
218 [ # # ]: 0 : if (rte_intr_disable(dev->intr_handle) < 0)
219 : : return -1;
220 : :
221 : 0 : hw->intr_enabled = 0;
222 : 0 : return 0;
223 : : }
224 : :
225 : : static int32_t
226 : 0 : zxdh_intr_enable(struct rte_eth_dev *dev)
227 : : {
228 : : int ret = 0;
229 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
230 : :
231 [ # # ]: 0 : if (!hw->intr_enabled) {
232 : 0 : zxdh_intr_cb_reg(dev);
233 : 0 : ret = rte_intr_enable(dev->intr_handle);
234 [ # # ]: 0 : if (unlikely(ret))
235 : 0 : PMD_DRV_LOG(ERR, "Failed to enable %s intr", dev->data->name);
236 : :
237 : 0 : hw->intr_enabled = 1;
238 : : }
239 : 0 : return ret;
240 : : }
241 : :
242 : : static int32_t
243 : 0 : zxdh_intr_release(struct rte_eth_dev *dev)
244 : : {
245 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
246 : :
247 [ # # ]: 0 : if (dev->data->dev_flags & RTE_ETH_DEV_INTR_LSC)
248 : 0 : ZXDH_VTPCI_OPS(hw)->set_config_irq(hw, ZXDH_MSI_NO_VECTOR);
249 : :
250 : 0 : zxdh_queues_unbind_intr(dev);
251 : 0 : zxdh_intr_disable(dev);
252 : :
253 : 0 : rte_intr_efd_disable(dev->intr_handle);
254 : 0 : rte_intr_vec_list_free(dev->intr_handle);
255 : 0 : rte_free(hw->risc_intr);
256 : 0 : hw->risc_intr = NULL;
257 : 0 : rte_free(hw->dtb_intr);
258 : 0 : hw->dtb_intr = NULL;
259 : 0 : return 0;
260 : : }
261 : :
262 : : static int32_t
263 : 0 : zxdh_setup_risc_interrupts(struct rte_eth_dev *dev)
264 : : {
265 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
266 : : uint8_t i;
267 : :
268 [ # # ]: 0 : if (!hw->risc_intr) {
269 : 0 : PMD_DRV_LOG(ERR, "to allocate risc_intr");
270 : 0 : hw->risc_intr = rte_zmalloc("risc_intr",
271 : : ZXDH_MSIX_INTR_MSG_VEC_NUM * sizeof(struct rte_intr_handle), 0);
272 [ # # ]: 0 : if (hw->risc_intr == NULL) {
273 : 0 : PMD_DRV_LOG(ERR, "Failed to allocate risc_intr");
274 : 0 : return -ENOMEM;
275 : : }
276 : : }
277 : :
278 [ # # ]: 0 : for (i = 0; i < ZXDH_MSIX_INTR_MSG_VEC_NUM; i++) {
279 [ # # ]: 0 : if (dev->intr_handle->efds[i] < 0) {
280 : 0 : PMD_DRV_LOG(ERR, "[%u]risc interrupt fd is invalid", i);
281 : 0 : rte_free(hw->risc_intr);
282 : 0 : hw->risc_intr = NULL;
283 : 0 : return -1;
284 : : }
285 : :
286 : 0 : struct rte_intr_handle *intr_handle = hw->risc_intr + i;
287 : :
288 : 0 : intr_handle->fd = dev->intr_handle->efds[i];
289 : 0 : intr_handle->type = dev->intr_handle->type;
290 : : }
291 : :
292 : : return 0;
293 : : }
294 : :
295 : : static int32_t
296 : 0 : zxdh_setup_dtb_interrupts(struct rte_eth_dev *dev)
297 : : {
298 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
299 : :
300 [ # # ]: 0 : if (!hw->dtb_intr) {
301 : 0 : hw->dtb_intr = rte_zmalloc("dtb_intr", sizeof(struct rte_intr_handle), 0);
302 [ # # ]: 0 : if (hw->dtb_intr == NULL) {
303 : 0 : PMD_DRV_LOG(ERR, "Failed to allocate dtb_intr");
304 : 0 : return -ENOMEM;
305 : : }
306 : : }
307 : :
308 [ # # ]: 0 : if (dev->intr_handle->efds[ZXDH_MSIX_INTR_DTB_VEC - 1] < 0) {
309 : 0 : PMD_DRV_LOG(ERR, "[%d]dtb interrupt fd is invalid", ZXDH_MSIX_INTR_DTB_VEC - 1);
310 : 0 : rte_free(hw->dtb_intr);
311 : 0 : hw->dtb_intr = NULL;
312 : 0 : return -1;
313 : : }
314 : 0 : hw->dtb_intr->fd = dev->intr_handle->efds[ZXDH_MSIX_INTR_DTB_VEC - 1];
315 : 0 : hw->dtb_intr->type = dev->intr_handle->type;
316 : 0 : return 0;
317 : : }
318 : :
319 : : static int32_t
320 : 0 : zxdh_queues_bind_intr(struct rte_eth_dev *dev)
321 : : {
322 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
323 : : int32_t i;
324 : : uint16_t vec;
325 : :
326 [ # # ]: 0 : if (!dev->data->dev_conf.intr_conf.rxq) {
327 [ # # ]: 0 : for (i = 0; i < dev->data->nb_rx_queues; ++i) {
328 : 0 : vec = ZXDH_VTPCI_OPS(hw)->set_queue_irq(hw,
329 : 0 : hw->vqs[i * 2], ZXDH_MSI_NO_VECTOR);
330 : 0 : PMD_DRV_LOG(DEBUG, "vq%d irq set 0x%x, get 0x%x",
331 : : i * 2, ZXDH_MSI_NO_VECTOR, vec);
332 : : }
333 : : } else {
334 [ # # ]: 0 : for (i = 0; i < dev->data->nb_rx_queues; ++i) {
335 : 0 : vec = ZXDH_VTPCI_OPS(hw)->set_queue_irq(hw,
336 : 0 : hw->vqs[i * 2], i + ZXDH_QUEUE_INTR_VEC_BASE);
337 : 0 : PMD_DRV_LOG(DEBUG, "vq%d irq set %d, get %d",
338 : : i * 2, i + ZXDH_QUEUE_INTR_VEC_BASE, vec);
339 : : }
340 : : }
341 : : /* mask all txq intr */
342 [ # # ]: 0 : for (i = 0; i < dev->data->nb_tx_queues; ++i) {
343 : 0 : vec = ZXDH_VTPCI_OPS(hw)->set_queue_irq(hw,
344 : 0 : hw->vqs[(i * 2) + 1], ZXDH_MSI_NO_VECTOR);
345 : 0 : PMD_DRV_LOG(DEBUG, "vq%d irq set 0x%x, get 0x%x",
346 : : (i * 2) + 1, ZXDH_MSI_NO_VECTOR, vec);
347 : : }
348 : 0 : return 0;
349 : : }
350 : :
351 : : static int32_t
352 : 0 : zxdh_configure_intr(struct rte_eth_dev *dev)
353 : : {
354 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
355 : : int32_t ret = 0;
356 : :
357 [ # # ]: 0 : if (!rte_intr_cap_multiple(dev->intr_handle)) {
358 : 0 : PMD_DRV_LOG(ERR, "Multiple intr vector not supported");
359 : 0 : return -ENOTSUP;
360 : : }
361 : 0 : zxdh_intr_release(dev);
362 : : uint8_t nb_efd = ZXDH_MSIX_INTR_DTB_VEC_NUM + ZXDH_MSIX_INTR_MSG_VEC_NUM;
363 : :
364 [ # # ]: 0 : if (dev->data->dev_conf.intr_conf.rxq)
365 : 0 : nb_efd += dev->data->nb_rx_queues;
366 : :
367 [ # # ]: 0 : if (rte_intr_efd_enable(dev->intr_handle, nb_efd)) {
368 : 0 : PMD_DRV_LOG(ERR, "Fail to create eventfd");
369 : 0 : return -1;
370 : : }
371 : :
372 [ # # ]: 0 : if (rte_intr_vec_list_alloc(dev->intr_handle, "intr_vec",
373 : 0 : hw->max_queue_pairs + ZXDH_INTR_NONQUE_NUM)) {
374 : 0 : PMD_DRV_LOG(ERR, "Failed to allocate %u rxq vectors",
375 : : hw->max_queue_pairs + ZXDH_INTR_NONQUE_NUM);
376 : 0 : return -ENOMEM;
377 : : }
378 : 0 : PMD_DRV_LOG(DEBUG, "allocate %u rxq vectors", dev->intr_handle->vec_list_size);
379 [ # # ]: 0 : if (zxdh_setup_risc_interrupts(dev) != 0) {
380 : 0 : PMD_DRV_LOG(ERR, "Error setting up rsic_v interrupts!");
381 : : ret = -1;
382 : 0 : goto free_intr_vec;
383 : : }
384 [ # # ]: 0 : if (zxdh_setup_dtb_interrupts(dev) != 0) {
385 : 0 : PMD_DRV_LOG(ERR, "Error setting up dtb interrupts!");
386 : : ret = -1;
387 : 0 : goto free_intr_vec;
388 : : }
389 : :
390 [ # # ]: 0 : if (zxdh_queues_bind_intr(dev) < 0) {
391 : 0 : PMD_DRV_LOG(ERR, "Failed to bind queue/interrupt");
392 : : ret = -1;
393 : 0 : goto free_intr_vec;
394 : : }
395 : :
396 [ # # ]: 0 : if (zxdh_intr_enable(dev) < 0) {
397 : 0 : PMD_DRV_LOG(ERR, "interrupt enable failed");
398 : : ret = -1;
399 : 0 : goto free_intr_vec;
400 : : }
401 : : return 0;
402 : :
403 : 0 : free_intr_vec:
404 : 0 : zxdh_intr_release(dev);
405 : 0 : return ret;
406 : : }
407 : :
408 : : static void
409 : 0 : zxdh_update_net_hdr_dl(struct zxdh_hw *hw)
410 : : {
411 : 0 : struct zxdh_net_hdr_dl *net_hdr_dl = &g_net_hdr_dl[hw->port_id];
412 : : memset(net_hdr_dl, 0, ZXDH_DL_NET_HDR_SIZE);
413 : :
414 [ # # ]: 0 : if (zxdh_tx_offload_enabled(hw)) {
415 : 0 : net_hdr_dl->type_hdr.port = ZXDH_PORT_DTP;
416 : 0 : net_hdr_dl->type_hdr.pd_len = ZXDH_DL_NET_HDR_SIZE >> 1;
417 : :
418 : 0 : net_hdr_dl->pipd_hdr_dl.pi_hdr.pi_len = (ZXDH_PI_HDR_SIZE >> 4) - 1;
419 : 0 : net_hdr_dl->pipd_hdr_dl.pi_hdr.pkt_flag_hi8 = ZXDH_PI_FLAG | ZXDH_PI_TYPE_PI;
420 : 0 : net_hdr_dl->pipd_hdr_dl.pi_hdr.pkt_type = ZXDH_PKT_FORM_CPU;
421 : 0 : hw->dl_net_hdr_len = ZXDH_DL_NET_HDR_SIZE;
422 : :
423 : : } else {
424 : 0 : net_hdr_dl->type_hdr.port = ZXDH_PORT_NP;
425 : 0 : net_hdr_dl->type_hdr.pd_len = ZXDH_DL_NET_HDR_NOPI_SIZE >> 1;
426 : 0 : hw->dl_net_hdr_len = ZXDH_DL_NET_HDR_NOPI_SIZE;
427 : : }
428 : 0 : }
429 : :
430 : : static int32_t
431 : 0 : zxdh_features_update(struct zxdh_hw *hw,
432 : : const struct rte_eth_rxmode *rxmode,
433 : : const struct rte_eth_txmode *txmode)
434 : : {
435 : 0 : uint64_t rx_offloads = rxmode->offloads;
436 : 0 : uint64_t tx_offloads = txmode->offloads;
437 : 0 : uint64_t req_features = hw->guest_features;
438 : :
439 [ # # ]: 0 : if (rx_offloads & (RTE_ETH_RX_OFFLOAD_UDP_CKSUM | RTE_ETH_RX_OFFLOAD_TCP_CKSUM))
440 : 0 : req_features |= (1ULL << ZXDH_NET_F_GUEST_CSUM);
441 : :
442 [ # # ]: 0 : if (rx_offloads & RTE_ETH_RX_OFFLOAD_TCP_LRO)
443 : 0 : req_features |= (1ULL << ZXDH_NET_F_GUEST_TSO4) |
444 : : (1ULL << ZXDH_NET_F_GUEST_TSO6);
445 : :
446 [ # # ]: 0 : if (tx_offloads & (RTE_ETH_RX_OFFLOAD_UDP_CKSUM | RTE_ETH_RX_OFFLOAD_TCP_CKSUM))
447 : 0 : req_features |= (1ULL << ZXDH_NET_F_CSUM);
448 : :
449 [ # # ]: 0 : if (tx_offloads & RTE_ETH_TX_OFFLOAD_TCP_TSO)
450 : 0 : req_features |= (1ULL << ZXDH_NET_F_HOST_TSO4) |
451 : : (1ULL << ZXDH_NET_F_HOST_TSO6);
452 : :
453 [ # # ]: 0 : if (tx_offloads & RTE_ETH_TX_OFFLOAD_UDP_TSO)
454 : 0 : req_features |= (1ULL << ZXDH_NET_F_HOST_UFO);
455 : :
456 : 0 : req_features = req_features & hw->host_features;
457 : 0 : hw->guest_features = req_features;
458 : :
459 : 0 : ZXDH_VTPCI_OPS(hw)->set_features(hw, req_features);
460 : :
461 [ # # # # ]: 0 : if ((rx_offloads & (RTE_ETH_TX_OFFLOAD_UDP_CKSUM | RTE_ETH_TX_OFFLOAD_TCP_CKSUM)) &&
462 : : !zxdh_pci_with_feature(hw, ZXDH_NET_F_GUEST_CSUM)) {
463 : 0 : PMD_DRV_LOG(ERR, "rx checksum not available on this host");
464 : 0 : return -ENOTSUP;
465 : : }
466 : :
467 [ # # # # ]: 0 : if ((rx_offloads & RTE_ETH_RX_OFFLOAD_TCP_LRO) &&
468 [ # # ]: 0 : (!zxdh_pci_with_feature(hw, ZXDH_NET_F_GUEST_TSO4) ||
469 : : !zxdh_pci_with_feature(hw, ZXDH_NET_F_GUEST_TSO6))) {
470 : 0 : PMD_DRV_LOG(ERR, "Large Receive Offload not available on this host");
471 : 0 : return -ENOTSUP;
472 : : }
473 : : return 0;
474 : : }
475 : :
476 : : static void
477 : 0 : zxdh_dev_free_mbufs(struct rte_eth_dev *dev)
478 : : {
479 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
480 : : struct zxdh_virtqueue *vq;
481 : : struct rte_mbuf *buf;
482 : : int i;
483 : :
484 [ # # ]: 0 : if (hw->vqs == NULL)
485 : : return;
486 : :
487 [ # # ]: 0 : for (i = 0; i < hw->rx_qnum; i++) {
488 : 0 : vq = hw->vqs[i * 2];
489 [ # # ]: 0 : if (!vq)
490 : 0 : continue;
491 [ # # ]: 0 : while ((buf = zxdh_queue_detach_unused(vq)) != NULL)
492 : 0 : rte_pktmbuf_free(buf);
493 : 0 : PMD_DRV_LOG(DEBUG, "freeing %s[%d] used and unused buf",
494 : : "rxq", i * 2);
495 : : }
496 [ # # ]: 0 : for (i = 0; i < hw->tx_qnum; i++) {
497 : 0 : vq = hw->vqs[i * 2 + 1];
498 [ # # ]: 0 : if (!vq)
499 : 0 : continue;
500 [ # # ]: 0 : while ((buf = zxdh_queue_detach_unused(vq)) != NULL)
501 : 0 : rte_pktmbuf_free(buf);
502 : 0 : PMD_DRV_LOG(DEBUG, "freeing %s[%d] used and unused buf",
503 : : "txq", i * 2 + 1);
504 : : }
505 : : }
506 : :
507 : : static int32_t
508 : 0 : zxdh_get_available_channel(struct rte_eth_dev *dev, uint8_t queue_type)
509 : : {
510 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
511 : 0 : uint16_t base = (queue_type == ZXDH_VTNET_RQ) ? 0 : 1; /* txq only polls odd bits*/
512 : : uint16_t j = 0;
513 : : uint16_t done = 0;
514 : : uint32_t phy_vq_reg = 0;
515 : 0 : uint16_t total_queue_num = hw->queue_pool_count * 2;
516 : 0 : uint16_t start_qp_id = hw->queue_pool_start * 2;
517 : 0 : uint32_t phy_vq_reg_oft = start_qp_id / 32;
518 : 0 : uint32_t inval_bit = start_qp_id % 32;
519 : 0 : uint32_t res_bit = (total_queue_num + inval_bit) % 32;
520 [ # # ]: 0 : uint32_t vq_reg_num = (total_queue_num + inval_bit) / 32 + (res_bit ? 1 : 0);
521 : : int32_t ret = 0;
522 : :
523 : 0 : ret = zxdh_timedlock(hw, 1000);
524 [ # # ]: 0 : if (ret) {
525 : 0 : PMD_DRV_LOG(ERR, "Acquiring hw lock got failed, timeout");
526 : 0 : return -1;
527 : : }
528 : :
529 [ # # ]: 0 : for (phy_vq_reg = 0; phy_vq_reg < vq_reg_num; phy_vq_reg++) {
530 : 0 : uint32_t addr = ZXDH_QUERES_SHARE_BASE +
531 : 0 : (phy_vq_reg + phy_vq_reg_oft) * sizeof(uint32_t);
532 : 0 : uint32_t var = zxdh_read_bar_reg(dev, ZXDH_BAR0_INDEX, addr);
533 [ # # ]: 0 : if (phy_vq_reg == 0) {
534 [ # # ]: 0 : for (j = (inval_bit + base); j < 32; j += 2) {
535 : : /* Got the available channel & update COI table */
536 [ # # ]: 0 : if ((var & (1 << j)) == 0) {
537 : 0 : var |= (1 << j);
538 : 0 : zxdh_write_bar_reg(dev, ZXDH_BAR0_INDEX, addr, var);
539 : : done = 1;
540 : : break;
541 : : }
542 : : }
543 : : if (done)
544 : : break;
545 [ # # # # ]: 0 : } else if ((phy_vq_reg == (vq_reg_num - 1)) && (res_bit != 0)) {
546 [ # # ]: 0 : for (j = base; j < res_bit; j += 2) {
547 : : /* Got the available channel & update COI table */
548 [ # # ]: 0 : if ((var & (1 << j)) == 0) {
549 : 0 : var |= (1 << j);
550 : 0 : zxdh_write_bar_reg(dev, ZXDH_BAR0_INDEX, addr, var);
551 : : done = 1;
552 : : break;
553 : : }
554 : : }
555 : : if (done)
556 : : break;
557 : : } else {
558 [ # # ]: 0 : for (j = base; j < 32; j += 2) {
559 : : /* Got the available channel & update COI table */
560 [ # # ]: 0 : if ((var & (1 << j)) == 0) {
561 : 0 : var |= (1 << j);
562 : 0 : zxdh_write_bar_reg(dev, ZXDH_BAR0_INDEX, addr, var);
563 : : done = 1;
564 : : break;
565 : : }
566 : : }
567 : : if (done)
568 : : break;
569 : : }
570 : : }
571 : :
572 : 0 : zxdh_release_lock(hw);
573 : : /* check for no channel condition */
574 [ # # ]: 0 : if (done != 1) {
575 : 0 : PMD_DRV_LOG(ERR, "NO availd queues");
576 : 0 : return -1;
577 : : }
578 : : /* reruen available channel ID */
579 : 0 : return (phy_vq_reg + phy_vq_reg_oft) * 32 + j;
580 : : }
581 : :
582 : : static int32_t
583 : 0 : zxdh_acquire_channel(struct rte_eth_dev *dev, uint16_t lch)
584 : : {
585 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
586 : :
587 [ # # ]: 0 : if (hw->channel_context[lch].valid == 1) {
588 : 0 : PMD_DRV_LOG(DEBUG, "Logic channel:%u already acquired Physics channel:%u",
589 : : lch, hw->channel_context[lch].ph_chno);
590 : 0 : return hw->channel_context[lch].ph_chno;
591 : : }
592 : 0 : int32_t pch = zxdh_get_available_channel(dev, zxdh_get_queue_type(lch));
593 : :
594 [ # # ]: 0 : if (pch < 0) {
595 : 0 : PMD_DRV_LOG(ERR, "Failed to acquire channel");
596 : 0 : return -1;
597 : : }
598 : 0 : hw->channel_context[lch].ph_chno = (uint16_t)pch;
599 : 0 : hw->channel_context[lch].valid = 1;
600 : 0 : PMD_DRV_LOG(DEBUG, "Acquire channel success lch:%u --> pch:%d", lch, pch);
601 : 0 : return 0;
602 : : }
603 : :
604 : : static void
605 : 0 : zxdh_init_vring(struct zxdh_virtqueue *vq)
606 : : {
607 : 0 : int32_t size = vq->vq_nentries;
608 : 0 : uint8_t *ring_mem = vq->vq_ring_virt_mem;
609 : :
610 : 0 : memset(ring_mem, 0, vq->vq_ring_size);
611 : :
612 : 0 : vq->vq_used_cons_idx = 0;
613 : 0 : vq->vq_desc_head_idx = 0;
614 : 0 : vq->vq_avail_idx = 0;
615 : 0 : vq->vq_desc_tail_idx = (uint16_t)(vq->vq_nentries - 1);
616 : 0 : vq->vq_free_cnt = vq->vq_nentries;
617 : 0 : memset(vq->vq_descx, 0, sizeof(struct zxdh_vq_desc_extra) * vq->vq_nentries);
618 : 0 : zxdh_vring_init_packed(&vq->vq_packed.ring, ring_mem, ZXDH_PCI_VRING_ALIGN, size);
619 : : zxdh_vring_desc_init_packed(vq, size);
620 : : zxdh_queue_disable_intr(vq);
621 : 0 : }
622 : :
623 : : static int32_t
624 : 0 : zxdh_init_queue(struct rte_eth_dev *dev, uint16_t vtpci_logic_qidx)
625 : : {
626 : 0 : char vq_name[ZXDH_VIRTQUEUE_MAX_NAME_SZ] = {0};
627 : 0 : char vq_hdr_name[ZXDH_VIRTQUEUE_MAX_NAME_SZ] = {0};
628 : : const struct rte_memzone *mz = NULL;
629 : : const struct rte_memzone *hdr_mz = NULL;
630 : : uint32_t size = 0;
631 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
632 : : struct zxdh_virtnet_rx *rxvq = NULL;
633 : : struct zxdh_virtnet_tx *txvq = NULL;
634 : : struct zxdh_virtqueue *vq = NULL;
635 : : size_t sz_hdr_mz = 0;
636 : : void *sw_ring = NULL;
637 : 0 : int32_t queue_type = zxdh_get_queue_type(vtpci_logic_qidx);
638 : 0 : int32_t numa_node = dev->device->numa_node;
639 : : uint16_t vtpci_phy_qidx = 0;
640 : : uint32_t vq_size = 0;
641 : : int32_t ret = 0;
642 : :
643 [ # # ]: 0 : if (hw->channel_context[vtpci_logic_qidx].valid == 0) {
644 : 0 : PMD_DRV_LOG(ERR, "lch %d is invalid", vtpci_logic_qidx);
645 : 0 : return -EINVAL;
646 : : }
647 : 0 : vtpci_phy_qidx = hw->channel_context[vtpci_logic_qidx].ph_chno;
648 : :
649 : 0 : PMD_DRV_LOG(DEBUG, "vtpci_logic_qidx :%d setting up physical queue: %u on NUMA node %d",
650 : : vtpci_logic_qidx, vtpci_phy_qidx, numa_node);
651 : :
652 : : vq_size = ZXDH_QUEUE_DEPTH;
653 : :
654 [ # # ]: 0 : if (ZXDH_VTPCI_OPS(hw)->set_queue_num != NULL)
655 : 0 : ZXDH_VTPCI_OPS(hw)->set_queue_num(hw, vtpci_phy_qidx, vq_size);
656 : :
657 [ # # ]: 0 : snprintf(vq_name, sizeof(vq_name), "port%d_vq%d", dev->data->port_id, vtpci_phy_qidx);
658 : :
659 : : size = RTE_ALIGN_CEIL(sizeof(*vq) + vq_size * sizeof(struct zxdh_vq_desc_extra),
660 : : RTE_CACHE_LINE_SIZE);
661 [ # # ]: 0 : if (queue_type == ZXDH_VTNET_TQ) {
662 : : /*
663 : : * For each xmit packet, allocate a zxdh_net_hdr
664 : : * and indirect ring elements
665 : : */
666 : : sz_hdr_mz = vq_size * sizeof(struct zxdh_tx_region);
667 : : }
668 : :
669 : 0 : vq = rte_zmalloc_socket(vq_name, size, RTE_CACHE_LINE_SIZE, numa_node);
670 [ # # ]: 0 : if (vq == NULL) {
671 : 0 : PMD_DRV_LOG(ERR, "can not allocate vq");
672 : 0 : return -ENOMEM;
673 : : }
674 : 0 : hw->vqs[vtpci_logic_qidx] = vq;
675 : :
676 : 0 : vq->hw = hw;
677 : 0 : vq->vq_queue_index = vtpci_phy_qidx;
678 : 0 : vq->vq_nentries = vq_size;
679 : :
680 : 0 : vq->vq_packed.used_wrap_counter = 1;
681 : 0 : vq->vq_packed.cached_flags = ZXDH_VRING_PACKED_DESC_F_AVAIL;
682 : 0 : vq->vq_packed.event_flags_shadow = 0;
683 [ # # ]: 0 : if (queue_type == ZXDH_VTNET_RQ)
684 : 0 : vq->vq_packed.cached_flags |= ZXDH_VRING_DESC_F_WRITE;
685 : :
686 : : /*
687 : : * Reserve a memzone for vring elements
688 : : */
689 : 0 : size = zxdh_vring_size(hw, vq_size, ZXDH_PCI_VRING_ALIGN);
690 : 0 : vq->vq_ring_size = RTE_ALIGN_CEIL(size, ZXDH_PCI_VRING_ALIGN);
691 : 0 : PMD_DRV_LOG(DEBUG, "vring_size: %d, rounded_vring_size: %d", size, vq->vq_ring_size);
692 : :
693 : 0 : mz = rte_memzone_reserve_aligned(vq_name, vq->vq_ring_size,
694 : : numa_node, RTE_MEMZONE_IOVA_CONTIG,
695 : : ZXDH_PCI_VRING_ALIGN);
696 [ # # ]: 0 : if (mz == NULL) {
697 [ # # ]: 0 : if (rte_errno == EEXIST)
698 : 0 : mz = rte_memzone_lookup(vq_name);
699 [ # # ]: 0 : if (mz == NULL) {
700 : : ret = -ENOMEM;
701 : 0 : goto fail_q_alloc;
702 : : }
703 : : }
704 : :
705 : 0 : memset(mz->addr, 0, mz->len);
706 : :
707 : 0 : vq->vq_ring_mem = mz->iova;
708 : 0 : vq->vq_ring_virt_mem = mz->addr;
709 : :
710 : 0 : zxdh_init_vring(vq);
711 : :
712 [ # # ]: 0 : if (sz_hdr_mz) {
713 : 0 : snprintf(vq_hdr_name, sizeof(vq_hdr_name), "port%d_vq%d_hdr",
714 : 0 : dev->data->port_id, vtpci_phy_qidx);
715 : 0 : hdr_mz = rte_memzone_reserve_aligned(vq_hdr_name, sz_hdr_mz,
716 : : numa_node, RTE_MEMZONE_IOVA_CONTIG,
717 : : RTE_CACHE_LINE_SIZE);
718 [ # # ]: 0 : if (hdr_mz == NULL) {
719 [ # # ]: 0 : if (rte_errno == EEXIST)
720 : 0 : hdr_mz = rte_memzone_lookup(vq_hdr_name);
721 [ # # ]: 0 : if (hdr_mz == NULL) {
722 : : ret = -ENOMEM;
723 : 0 : goto fail_q_alloc;
724 : : }
725 : : }
726 : : }
727 : :
728 [ # # ]: 0 : if (queue_type == ZXDH_VTNET_RQ) {
729 : : size_t sz_sw = (ZXDH_MBUF_BURST_SZ + vq_size) * sizeof(vq->sw_ring[0]);
730 : :
731 : 0 : sw_ring = rte_zmalloc_socket("sw_ring", sz_sw, RTE_CACHE_LINE_SIZE, numa_node);
732 [ # # ]: 0 : if (!sw_ring) {
733 : 0 : PMD_DRV_LOG(ERR, "can not allocate RX soft ring");
734 : : ret = -ENOMEM;
735 : 0 : goto fail_q_alloc;
736 : : }
737 : :
738 : 0 : vq->sw_ring = sw_ring;
739 : : rxvq = &vq->rxq;
740 : 0 : rxvq->vq = vq;
741 : 0 : rxvq->port_id = dev->data->port_id;
742 : 0 : rxvq->mz = mz;
743 : : } else { /* queue_type == VTNET_TQ */
744 : 0 : txvq = &vq->txq;
745 : 0 : txvq->vq = vq;
746 : 0 : txvq->port_id = dev->data->port_id;
747 : 0 : txvq->mz = mz;
748 : 0 : txvq->zxdh_net_hdr_mz = hdr_mz;
749 : 0 : txvq->zxdh_net_hdr_mem = hdr_mz->iova;
750 : : }
751 : :
752 : 0 : vq->offset = offsetof(struct rte_mbuf, buf_iova);
753 [ # # ]: 0 : if (queue_type == ZXDH_VTNET_TQ) {
754 : 0 : struct zxdh_tx_region *txr = hdr_mz->addr;
755 : : uint32_t i;
756 : :
757 : : memset(txr, 0, vq_size * sizeof(*txr));
758 [ # # ]: 0 : for (i = 0; i < vq_size; i++) {
759 : : /* first indirect descriptor is always the tx header */
760 : 0 : struct zxdh_vring_packed_desc *start_dp = txr[i].tx_packed_indir;
761 : :
762 : : zxdh_vring_desc_init_indirect_packed(start_dp,
763 : : RTE_DIM(txr[i].tx_packed_indir));
764 : 0 : start_dp->addr = txvq->zxdh_net_hdr_mem + i * sizeof(*txr) +
765 : : offsetof(struct zxdh_tx_region, tx_hdr);
766 : : /* length will be updated to actual pi hdr size when xmit pkt */
767 : 0 : start_dp->len = 0;
768 : : }
769 : : }
770 [ # # ]: 0 : if (ZXDH_VTPCI_OPS(hw)->setup_queue(hw, vq) < 0) {
771 : 0 : PMD_DRV_LOG(ERR, "setup_queue failed");
772 : 0 : return -EINVAL;
773 : : }
774 : : return 0;
775 : 0 : fail_q_alloc:
776 : 0 : rte_free(sw_ring);
777 : 0 : rte_memzone_free(hdr_mz);
778 : 0 : rte_memzone_free(mz);
779 : 0 : rte_free(vq);
780 : 0 : return ret;
781 : : }
782 : :
783 : : static int32_t
784 : 0 : zxdh_alloc_queues(struct rte_eth_dev *dev)
785 : : {
786 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
787 : 0 : u_int16_t rxq_num = hw->rx_qnum;
788 : 0 : u_int16_t txq_num = hw->tx_qnum;
789 [ # # ]: 0 : uint16_t nr_vq = (rxq_num > txq_num) ? 2 * rxq_num : 2 * txq_num;
790 : 0 : hw->vqs = rte_zmalloc(NULL, sizeof(struct zxdh_virtqueue *) * nr_vq, 0);
791 : : uint16_t lch, i;
792 : :
793 [ # # ]: 0 : if (!hw->vqs) {
794 : 0 : PMD_DRV_LOG(ERR, "Failed to allocate %d vqs", nr_vq);
795 : 0 : return -ENOMEM;
796 : : }
797 [ # # ]: 0 : for (i = 0 ; i < rxq_num; i++) {
798 : 0 : lch = i * 2;
799 [ # # ]: 0 : if (zxdh_acquire_channel(dev, lch) < 0) {
800 : 0 : PMD_DRV_LOG(ERR, "Failed to acquire the channels");
801 : 0 : goto free;
802 : : }
803 [ # # ]: 0 : if (zxdh_init_queue(dev, lch) < 0) {
804 : 0 : PMD_DRV_LOG(ERR, "Failed to alloc virtio queue");
805 : 0 : goto free;
806 : : }
807 : : }
808 [ # # ]: 0 : for (i = 0 ; i < txq_num; i++) {
809 : 0 : lch = i * 2 + 1;
810 [ # # ]: 0 : if (zxdh_acquire_channel(dev, lch) < 0) {
811 : 0 : PMD_DRV_LOG(ERR, "Failed to acquire the channels");
812 : 0 : goto free;
813 : : }
814 [ # # ]: 0 : if (zxdh_init_queue(dev, lch) < 0) {
815 : 0 : PMD_DRV_LOG(ERR, "Failed to alloc virtio queue");
816 : 0 : goto free;
817 : : }
818 : : }
819 : : return 0;
820 : :
821 : 0 : free:
822 : 0 : zxdh_free_queues(dev);
823 : 0 : return -1;
824 : : }
825 : :
826 : : static int
827 : 0 : zxdh_vlan_offload_configure(struct rte_eth_dev *dev)
828 : : {
829 : : int ret;
830 : : int mask = RTE_ETH_VLAN_STRIP_MASK | RTE_ETH_VLAN_FILTER_MASK | RTE_ETH_QINQ_STRIP_MASK;
831 : :
832 : 0 : ret = zxdh_dev_vlan_offload_set(dev, mask);
833 [ # # ]: 0 : if (ret) {
834 : 0 : PMD_DRV_LOG(ERR, "vlan offload set error");
835 : 0 : return -1;
836 : : }
837 : :
838 : : return 0;
839 : : }
840 : :
841 : : static int
842 : 0 : zxdh_rx_csum_lro_offload_configure(struct rte_eth_dev *dev)
843 : : {
844 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
845 : : struct rte_eth_rxmode *rxmode = &dev->data->dev_conf.rxmode;
846 : 0 : uint32_t need_accelerator = rxmode->offloads & (RTE_ETH_RX_OFFLOAD_OUTER_IPV4_CKSUM |
847 : : RTE_ETH_RX_OFFLOAD_IPV4_CKSUM |
848 : : RTE_ETH_RX_OFFLOAD_UDP_CKSUM |
849 : : RTE_ETH_RX_OFFLOAD_TCP_CKSUM |
850 : : RTE_ETH_RX_OFFLOAD_TCP_LRO);
851 : : int ret;
852 : :
853 [ # # ]: 0 : if (hw->is_pf) {
854 : 0 : struct zxdh_port_attr_table port_attr = {0};
855 : 0 : zxdh_get_port_attr(hw, hw->vport.vport, &port_attr);
856 : 0 : port_attr.outer_ip_checksum_offload =
857 : 0 : (rxmode->offloads & RTE_ETH_RX_OFFLOAD_OUTER_IPV4_CKSUM) ? true : false;
858 : 0 : port_attr.ip_checksum_offload =
859 : 0 : (rxmode->offloads & RTE_ETH_RX_OFFLOAD_IPV4_CKSUM) ? true : false;
860 : 0 : port_attr.tcp_udp_checksum_offload =
861 : 0 : (rxmode->offloads & (RTE_ETH_RX_OFFLOAD_UDP_CKSUM | RTE_ETH_RX_OFFLOAD_TCP_CKSUM))
862 : 0 : ? true : false;
863 : 0 : port_attr.lro_offload =
864 : 0 : (rxmode->offloads & RTE_ETH_RX_OFFLOAD_TCP_LRO) ? true : false;
865 : 0 : port_attr.accelerator_offload_flag = need_accelerator ? true : false;
866 : 0 : ret = zxdh_set_port_attr(hw, hw->vport.vport, &port_attr);
867 [ # # ]: 0 : if (ret) {
868 : 0 : PMD_DRV_LOG(ERR, "%s set port attr failed", __func__);
869 : 0 : return -1;
870 : : }
871 : : } else {
872 : 0 : struct zxdh_msg_info msg_info = {0};
873 : : struct zxdh_port_attr_set_msg *attr_msg = &msg_info.data.port_attr_msg;
874 : :
875 : 0 : zxdh_msg_head_build(hw, ZXDH_PORT_ATTRS_SET, &msg_info);
876 : 0 : attr_msg->mode = ZXDH_PORT_IP_CHKSUM_FLAG;
877 : 0 : attr_msg->value =
878 : 0 : (rxmode->offloads & RTE_ETH_RX_OFFLOAD_OUTER_IPV4_CKSUM) ? true : false;
879 : 0 : ret = zxdh_vf_send_msg_to_pf(dev, &msg_info, sizeof(msg_info), NULL, 0);
880 [ # # ]: 0 : if (ret) {
881 : 0 : PMD_DRV_LOG(ERR, "%s outer ip cksum config failed", __func__);
882 : 0 : return -1;
883 : : }
884 : :
885 : 0 : zxdh_msg_head_build(hw, ZXDH_PORT_ATTRS_SET, &msg_info);
886 : 0 : attr_msg->mode = ZXDH_PORT_OUTER_IP_CHECKSUM_OFFLOAD_FLAG;
887 : 0 : attr_msg->value = (rxmode->offloads & RTE_ETH_RX_OFFLOAD_IPV4_CKSUM) ? true : false;
888 : 0 : ret = zxdh_vf_send_msg_to_pf(dev, &msg_info, sizeof(msg_info), NULL, 0);
889 [ # # ]: 0 : if (ret) {
890 : 0 : PMD_DRV_LOG(ERR, "%s ip_checksum config failed to send msg", __func__);
891 : 0 : return -1;
892 : : }
893 : :
894 : 0 : zxdh_msg_head_build(hw, ZXDH_PORT_ATTRS_SET, &msg_info);
895 : 0 : attr_msg->mode = ZXDH_PORT_TCP_UDP_CHKSUM_FLAG;
896 : 0 : attr_msg->value = (rxmode->offloads &
897 : : (RTE_ETH_RX_OFFLOAD_UDP_CKSUM | RTE_ETH_RX_OFFLOAD_TCP_CKSUM)) ?
898 : 0 : true : false;
899 : 0 : ret = zxdh_vf_send_msg_to_pf(dev, &msg_info, sizeof(msg_info), NULL, 0);
900 [ # # ]: 0 : if (ret) {
901 : 0 : PMD_DRV_LOG(ERR, "%s tcp_udp_checksum config failed to send msg", __func__);
902 : 0 : return -1;
903 : : }
904 : :
905 : 0 : zxdh_msg_head_build(hw, ZXDH_PORT_ATTRS_SET, &msg_info);
906 : 0 : attr_msg->mode = ZXDH_PORT_LRO_OFFLOAD_FLAG;
907 : 0 : attr_msg->value = (rxmode->offloads & RTE_ETH_RX_OFFLOAD_TCP_LRO) ? true : false;
908 : 0 : ret = zxdh_vf_send_msg_to_pf(dev, &msg_info, sizeof(msg_info), NULL, 0);
909 [ # # ]: 0 : if (ret) {
910 : 0 : PMD_DRV_LOG(ERR, "%s lro offload config failed to send msg", __func__);
911 : 0 : return -1;
912 : : }
913 : :
914 : 0 : zxdh_msg_head_build(hw, ZXDH_PORT_ATTRS_SET, &msg_info);
915 : 0 : attr_msg->mode = ZXDH_PORT_ACCELERATOR_OFFLOAD_FLAG_FLAG;
916 : 0 : attr_msg->value = need_accelerator ? true : false;
917 : 0 : ret = zxdh_vf_send_msg_to_pf(dev, &msg_info, sizeof(msg_info), NULL, 0);
918 [ # # ]: 0 : if (ret) {
919 : 0 : PMD_DRV_LOG(ERR,
920 : : "%s accelerator offload config failed to send msg", __func__);
921 : 0 : return -1;
922 : : }
923 : : }
924 : :
925 : : return 0;
926 : : }
927 : :
928 : : static int
929 : 0 : zxdh_dev_conf_offload(struct rte_eth_dev *dev)
930 : : {
931 : : int ret = 0;
932 : :
933 : 0 : ret = zxdh_vlan_offload_configure(dev);
934 [ # # ]: 0 : if (ret) {
935 : 0 : PMD_DRV_LOG(ERR, "zxdh_vlan_offload_configure failed");
936 : 0 : return ret;
937 : : }
938 : :
939 : 0 : ret = zxdh_rss_configure(dev);
940 [ # # ]: 0 : if (ret) {
941 : 0 : PMD_DRV_LOG(ERR, "rss configure failed");
942 : 0 : return ret;
943 : : }
944 : :
945 : 0 : ret = zxdh_rx_csum_lro_offload_configure(dev);
946 [ # # ]: 0 : if (ret) {
947 : 0 : PMD_DRV_LOG(ERR, "rx csum lro configure failed");
948 : 0 : return ret;
949 : : }
950 : :
951 : : return 0;
952 : : }
953 : :
954 : : static int
955 : 0 : zxdh_rss_qid_config(struct rte_eth_dev *dev)
956 : : {
957 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
958 : 0 : struct zxdh_port_attr_table port_attr = {0};
959 : 0 : struct zxdh_msg_info msg_info = {0};
960 : : int ret = 0;
961 : :
962 [ # # ]: 0 : if (hw->is_pf) {
963 : 0 : ret = zxdh_get_port_attr(hw, hw->vport.vport, &port_attr);
964 : 0 : port_attr.port_base_qid = hw->channel_context[0].ph_chno & 0xfff;
965 : :
966 : 0 : ret = zxdh_set_port_attr(hw, hw->vport.vport, &port_attr);
967 [ # # ]: 0 : if (ret) {
968 : 0 : PMD_DRV_LOG(ERR, "PF:%d port_base_qid insert failed", hw->vfid);
969 : 0 : return ret;
970 : : }
971 : : } else {
972 : : struct zxdh_port_attr_set_msg *attr_msg = &msg_info.data.port_attr_msg;
973 : :
974 : 0 : zxdh_msg_head_build(hw, ZXDH_PORT_ATTRS_SET, &msg_info);
975 : 0 : attr_msg->mode = ZXDH_PORT_BASE_QID_FLAG;
976 : 0 : attr_msg->value = hw->channel_context[0].ph_chno & 0xfff;
977 : 0 : ret = zxdh_vf_send_msg_to_pf(dev, &msg_info, sizeof(msg_info), NULL, 0);
978 [ # # ]: 0 : if (ret) {
979 : 0 : PMD_DRV_LOG(ERR, "Failed to send msg: port 0x%x msg type %d",
980 : : hw->vport.vport, ZXDH_PORT_BASE_QID_FLAG);
981 : 0 : return ret;
982 : : }
983 : : }
984 : : return ret;
985 : : }
986 : :
987 : : static int32_t
988 : 0 : zxdh_dev_configure(struct rte_eth_dev *dev)
989 : : {
990 : 0 : const struct rte_eth_rxmode *rxmode = &dev->data->dev_conf.rxmode;
991 : 0 : const struct rte_eth_txmode *txmode = &dev->data->dev_conf.txmode;
992 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
993 : 0 : uint64_t rx_offloads = rxmode->offloads;
994 : : int32_t ret = 0;
995 : :
996 [ # # ]: 0 : if (dev->data->nb_rx_queues > hw->max_queue_pairs ||
997 [ # # ]: 0 : dev->data->nb_tx_queues > hw->max_queue_pairs) {
998 : 0 : PMD_DRV_LOG(ERR, "nb_rx_queues=%d or nb_tx_queues=%d must < (%d)!",
999 : : dev->data->nb_rx_queues, dev->data->nb_tx_queues, hw->max_queue_pairs);
1000 : 0 : return -EINVAL;
1001 : : }
1002 : :
1003 [ # # ]: 0 : if (rxmode->mq_mode != RTE_ETH_MQ_RX_RSS && rxmode->mq_mode != RTE_ETH_MQ_RX_NONE) {
1004 : 0 : PMD_DRV_LOG(ERR, "Unsupported Rx multi queue mode %d", rxmode->mq_mode);
1005 : 0 : return -EINVAL;
1006 : : }
1007 : :
1008 [ # # ]: 0 : if (txmode->mq_mode != RTE_ETH_MQ_TX_NONE) {
1009 : 0 : PMD_DRV_LOG(ERR, "Unsupported Tx multi queue mode %d", txmode->mq_mode);
1010 : 0 : return -EINVAL;
1011 : : }
1012 : : if (rxmode->mq_mode != RTE_ETH_MQ_RX_RSS && rxmode->mq_mode != RTE_ETH_MQ_RX_NONE) {
1013 : : PMD_DRV_LOG(ERR, "Unsupported Rx multi queue mode %d", rxmode->mq_mode);
1014 : : return -EINVAL;
1015 : : }
1016 : :
1017 : : if (txmode->mq_mode != RTE_ETH_MQ_TX_NONE) {
1018 : : PMD_DRV_LOG(ERR, "Unsupported Tx multi queue mode %d", txmode->mq_mode);
1019 : : return -EINVAL;
1020 : : }
1021 : :
1022 : 0 : ret = zxdh_features_update(hw, rxmode, txmode);
1023 [ # # ]: 0 : if (ret < 0)
1024 : : return ret;
1025 : :
1026 : : /* check if lsc interrupt feature is enabled */
1027 [ # # ]: 0 : if (dev->data->dev_conf.intr_conf.lsc) {
1028 [ # # ]: 0 : if (!(dev->data->dev_flags & RTE_ETH_DEV_INTR_LSC)) {
1029 : 0 : PMD_DRV_LOG(ERR, "link status not supported by host");
1030 : 0 : return -ENOTSUP;
1031 : : }
1032 : : }
1033 : :
1034 [ # # ]: 0 : if (rx_offloads & RTE_ETH_RX_OFFLOAD_VLAN_STRIP)
1035 : 0 : hw->vlan_offload_cfg.vlan_strip = 1;
1036 : :
1037 : 0 : hw->has_tx_offload = zxdh_tx_offload_enabled(hw);
1038 : 0 : hw->has_rx_offload = zxdh_rx_offload_enabled(hw);
1039 : :
1040 [ # # ]: 0 : if (dev->data->nb_rx_queues == hw->rx_qnum &&
1041 : : dev->data->nb_tx_queues == hw->tx_qnum) {
1042 : 0 : PMD_DRV_LOG(DEBUG, "The queue not need to change. queue_rx %d queue_tx %d",
1043 : : hw->rx_qnum, hw->tx_qnum);
1044 : : /*no queue changed */
1045 : 0 : goto end;
1046 : : }
1047 : :
1048 : 0 : PMD_DRV_LOG(DEBUG, "queue changed need reset");
1049 : : /* Reset the device although not necessary at startup */
1050 : 0 : zxdh_pci_reset(hw);
1051 : :
1052 : : /* Tell the host we've noticed this device. */
1053 : 0 : zxdh_pci_set_status(hw, ZXDH_CONFIG_STATUS_ACK);
1054 : :
1055 : : /* Tell the host we've known how to drive the device. */
1056 : 0 : zxdh_pci_set_status(hw, ZXDH_CONFIG_STATUS_DRIVER);
1057 : : /* The queue needs to be released when reconfiguring*/
1058 [ # # ]: 0 : if (hw->vqs != NULL) {
1059 : 0 : zxdh_dev_free_mbufs(dev);
1060 : 0 : zxdh_free_queues(dev);
1061 : : }
1062 : :
1063 : 0 : hw->rx_qnum = dev->data->nb_rx_queues;
1064 : 0 : hw->tx_qnum = dev->data->nb_tx_queues;
1065 : 0 : ret = zxdh_alloc_queues(dev);
1066 [ # # ]: 0 : if (ret < 0)
1067 : : return ret;
1068 : :
1069 : 0 : zxdh_datach_set(dev);
1070 : :
1071 [ # # ]: 0 : if (zxdh_configure_intr(dev) < 0) {
1072 : 0 : PMD_DRV_LOG(ERR, "Failed to configure interrupt");
1073 : 0 : zxdh_free_queues(dev);
1074 : 0 : return -1;
1075 : : }
1076 : :
1077 : 0 : ret = zxdh_rss_qid_config(dev);
1078 [ # # ]: 0 : if (ret) {
1079 : 0 : PMD_DRV_LOG(ERR, "Failed to configure base qid!");
1080 : 0 : return -1;
1081 : : }
1082 : :
1083 : 0 : zxdh_pci_reinit_complete(hw);
1084 : :
1085 : 0 : end:
1086 : 0 : zxdh_dev_conf_offload(dev);
1087 : 0 : zxdh_update_net_hdr_dl(hw);
1088 : 0 : return ret;
1089 : : }
1090 : :
1091 : : static void
1092 : 0 : zxdh_np_dtb_data_res_free(struct zxdh_hw *hw)
1093 : : {
1094 : 0 : struct rte_eth_dev *dev = hw->eth_dev;
1095 : 0 : struct zxdh_dtb_shared_data *dtb_data = &hw->dev_sd->dtb_sd;
1096 : : int ret;
1097 : : int i;
1098 : :
1099 [ # # # # ]: 0 : if (dtb_data->init_done && dtb_data->bind_device == dev) {
1100 : 0 : ret = zxdh_np_online_uninit(hw->slot_id, dev->data->name, dtb_data->queueid);
1101 [ # # ]: 0 : if (ret)
1102 : 0 : PMD_DRV_LOG(ERR, "%s dpp_np_online_uninstall failed", dev->data->name);
1103 : :
1104 : 0 : rte_memzone_free(dtb_data->dtb_table_conf_mz);
1105 : 0 : dtb_data->dtb_table_conf_mz = NULL;
1106 : 0 : rte_memzone_free(dtb_data->dtb_table_dump_mz);
1107 : 0 : dtb_data->dtb_table_dump_mz = NULL;
1108 : :
1109 [ # # ]: 0 : for (i = 0; i < ZXDH_MAX_BASE_DTB_TABLE_COUNT; i++) {
1110 [ # # ]: 0 : if (dtb_data->dtb_table_bulk_dump_mz[i]) {
1111 : 0 : rte_memzone_free(dtb_data->dtb_table_bulk_dump_mz[i]);
1112 : 0 : dtb_data->dtb_table_bulk_dump_mz[i] = NULL;
1113 : : }
1114 : : }
1115 : 0 : dtb_data->init_done = 0;
1116 : 0 : dtb_data->bind_device = NULL;
1117 : : }
1118 [ # # ]: 0 : if (zxdh_shared_data != NULL)
1119 : 0 : zxdh_shared_data->np_init_done = 0;
1120 : 0 : }
1121 : :
1122 : : static int
1123 : 0 : zxdh_tbl_entry_online_destroy(struct rte_eth_dev *dev)
1124 : : {
1125 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
1126 : 0 : struct zxdh_dtb_shared_data *dtb_data = &hw->dev_sd->dtb_sd;
1127 : : uint32_t sdt_no;
1128 : : int ret = 0;
1129 [ # # ]: 0 : if (!dtb_data->init_done)
1130 : : return ret;
1131 [ # # ]: 0 : if (hw->is_pf) {
1132 : 0 : sdt_no = ZXDH_SDT_L2_ENTRY_TABLE0 + hw->hash_search_index;
1133 : 0 : ret = zxdh_np_dtb_hash_online_delete(hw->dev_id, dtb_data->queueid, sdt_no);
1134 [ # # ]: 0 : if (ret)
1135 : 0 : PMD_DRV_LOG(ERR, "%s sdt_no %d failed. code:%d ",
1136 : : dev->data->name, sdt_no, ret);
1137 : 0 : sdt_no = ZXDH_SDT_MC_TABLE0 + hw->hash_search_index;
1138 : 0 : ret = zxdh_np_dtb_hash_online_delete(hw->dev_id, dtb_data->queueid, sdt_no);
1139 [ # # ]: 0 : if (ret)
1140 : 0 : PMD_DRV_LOG(ERR, "%s sdt_no %d failed. code:%d",
1141 : : dev->data->name, sdt_no, ret);
1142 : : }
1143 : : return ret;
1144 : : }
1145 : :
1146 : : static void
1147 : 0 : zxdh_np_uninit(struct rte_eth_dev *dev)
1148 : : {
1149 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
1150 : 0 : struct zxdh_dtb_shared_data *dtb_data = &hw->dev_sd->dtb_sd;
1151 : :
1152 [ # # ]: 0 : if (!hw->is_pf)
1153 : : return;
1154 [ # # # # ]: 0 : if (!dtb_data->init_done && !dtb_data->dev_refcnt)
1155 : : return;
1156 : :
1157 : 0 : zxdh_tbl_entry_online_destroy(dev);
1158 : :
1159 [ # # ]: 0 : if (--dtb_data->dev_refcnt == 0)
1160 : 0 : zxdh_np_dtb_data_res_free(hw);
1161 : : }
1162 : :
1163 : : static int
1164 : 0 : zxdh_tables_uninit(struct rte_eth_dev *dev)
1165 : : {
1166 : : int ret;
1167 : :
1168 : 0 : ret = zxdh_port_attr_uninit(dev);
1169 [ # # ]: 0 : if (ret) {
1170 : 0 : PMD_DRV_LOG(ERR, "zxdh_port_attr_uninit failed");
1171 : 0 : return ret;
1172 : : }
1173 : :
1174 : 0 : ret = zxdh_promisc_table_uninit(dev);
1175 [ # # ]: 0 : if (ret) {
1176 : 0 : PMD_DRV_LOG(ERR, "uninit promisc_table failed");
1177 : 0 : return ret;
1178 : : }
1179 : :
1180 : : return ret;
1181 : : }
1182 : :
1183 : : static int
1184 : 0 : zxdh_dev_stop(struct rte_eth_dev *dev)
1185 : : {
1186 : : uint16_t i;
1187 : : int ret = 0;
1188 : :
1189 [ # # ]: 0 : if (dev->data->dev_started == 0)
1190 : : return 0;
1191 : :
1192 : 0 : ret = zxdh_intr_disable(dev);
1193 [ # # ]: 0 : if (ret) {
1194 : 0 : PMD_DRV_LOG(ERR, "intr disable failed");
1195 : 0 : goto end;
1196 : : }
1197 : :
1198 : 0 : ret = zxdh_dev_set_link_down(dev);
1199 [ # # ]: 0 : if (ret) {
1200 : 0 : PMD_DRV_LOG(ERR, "set port %s link down failed!", dev->device->name);
1201 : 0 : goto end;
1202 : : }
1203 : :
1204 : 0 : end:
1205 [ # # ]: 0 : for (i = 0; i < dev->data->nb_rx_queues; i++)
1206 : 0 : dev->data->rx_queue_state[i] = RTE_ETH_QUEUE_STATE_STOPPED;
1207 [ # # ]: 0 : for (i = 0; i < dev->data->nb_tx_queues; i++)
1208 : 0 : dev->data->tx_queue_state[i] = RTE_ETH_QUEUE_STATE_STOPPED;
1209 : :
1210 : : return ret;
1211 : : }
1212 : :
1213 : : static int
1214 : 0 : zxdh_dev_close(struct rte_eth_dev *dev)
1215 : : {
1216 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
1217 : : int ret = 0;
1218 : :
1219 : 0 : ret = zxdh_dev_stop(dev);
1220 [ # # ]: 0 : if (ret != 0) {
1221 : 0 : PMD_DRV_LOG(ERR, "stop port %s failed.", dev->device->name);
1222 : 0 : return -1;
1223 : : }
1224 : :
1225 : 0 : ret = zxdh_tables_uninit(dev);
1226 [ # # ]: 0 : if (ret != 0) {
1227 : 0 : PMD_DRV_LOG(ERR, "%s :tables uninit %s failed", __func__, dev->device->name);
1228 : 0 : return -1;
1229 : : }
1230 : :
1231 : 0 : zxdh_intr_release(dev);
1232 : 0 : zxdh_np_uninit(dev);
1233 : 0 : zxdh_pci_reset(hw);
1234 : :
1235 : 0 : zxdh_dev_free_mbufs(dev);
1236 : 0 : zxdh_free_queues(dev);
1237 : :
1238 : 0 : zxdh_bar_msg_chan_exit();
1239 : :
1240 [ # # ]: 0 : if (dev->data->mac_addrs != NULL) {
1241 : 0 : rte_free(dev->data->mac_addrs);
1242 : 0 : dev->data->mac_addrs = NULL;
1243 : : }
1244 : :
1245 : : return ret;
1246 : : }
1247 : :
1248 : : static int32_t
1249 : 0 : zxdh_set_rxtx_funcs(struct rte_eth_dev *eth_dev)
1250 : : {
1251 [ # # ]: 0 : struct zxdh_hw *hw = eth_dev->data->dev_private;
1252 : :
1253 [ # # ]: 0 : if (!zxdh_pci_with_feature(hw, ZXDH_NET_F_MRG_RXBUF)) {
1254 : 0 : PMD_DRV_LOG(ERR, "port %u not support rx mergeable", eth_dev->data->port_id);
1255 : 0 : return -1;
1256 : : }
1257 : 0 : eth_dev->tx_pkt_prepare = zxdh_xmit_pkts_prepare;
1258 : 0 : eth_dev->tx_pkt_burst = &zxdh_xmit_pkts_packed;
1259 : 0 : eth_dev->rx_pkt_burst = &zxdh_recv_pkts_packed;
1260 : :
1261 : 0 : return 0;
1262 : : }
1263 : :
1264 : : static int
1265 : 0 : zxdh_mac_config(struct rte_eth_dev *eth_dev)
1266 : : {
1267 : 0 : struct zxdh_hw *hw = eth_dev->data->dev_private;
1268 : : int ret = 0;
1269 : :
1270 [ # # ]: 0 : if (hw->is_pf) {
1271 : 0 : ret = zxdh_add_mac_table(hw, hw->vport.vport,
1272 : 0 : ð_dev->data->mac_addrs[0], hw->hash_search_index, 0, 0);
1273 [ # # ]: 0 : if (ret) {
1274 : 0 : PMD_DRV_LOG(ERR, "Failed to add mac: port 0x%x", hw->vport.vport);
1275 : 0 : return ret;
1276 : : }
1277 : : }
1278 : : return ret;
1279 : : }
1280 : :
1281 : : static int
1282 : 0 : zxdh_dev_start(struct rte_eth_dev *dev)
1283 : : {
1284 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
1285 : : struct zxdh_virtqueue *vq;
1286 : : int32_t ret;
1287 : : uint16_t logic_qidx;
1288 : : uint16_t i;
1289 : :
1290 [ # # ]: 0 : for (i = 0; i < dev->data->nb_rx_queues; i++) {
1291 : 0 : logic_qidx = 2 * i + ZXDH_RQ_QUEUE_IDX;
1292 : 0 : ret = zxdh_dev_rx_queue_setup_finish(dev, logic_qidx);
1293 [ # # ]: 0 : if (ret < 0)
1294 : 0 : return ret;
1295 : : }
1296 : :
1297 : 0 : zxdh_set_rxtx_funcs(dev);
1298 : 0 : ret = zxdh_intr_enable(dev);
1299 [ # # ]: 0 : if (ret) {
1300 : 0 : PMD_DRV_LOG(ERR, "interrupt enable failed");
1301 : 0 : return -EINVAL;
1302 : : }
1303 : :
1304 [ # # ]: 0 : for (i = 0; i < dev->data->nb_rx_queues; i++) {
1305 : 0 : logic_qidx = 2 * i + ZXDH_RQ_QUEUE_IDX;
1306 : 0 : vq = hw->vqs[logic_qidx];
1307 : : /* Flush the old packets */
1308 : 0 : zxdh_queue_rxvq_flush(vq);
1309 : : zxdh_queue_notify(vq);
1310 : : }
1311 [ # # ]: 0 : for (i = 0; i < dev->data->nb_tx_queues; i++) {
1312 : 0 : logic_qidx = 2 * i + ZXDH_TQ_QUEUE_IDX;
1313 : 0 : vq = hw->vqs[logic_qidx];
1314 : : zxdh_queue_notify(vq);
1315 : : }
1316 : :
1317 : 0 : zxdh_dev_set_link_up(dev);
1318 : :
1319 : 0 : ret = zxdh_mac_config(hw->eth_dev);
1320 [ # # ]: 0 : if (ret)
1321 : 0 : PMD_DRV_LOG(ERR, "mac config failed");
1322 : :
1323 [ # # ]: 0 : for (i = 0; i < dev->data->nb_rx_queues; i++)
1324 : 0 : dev->data->rx_queue_state[i] = RTE_ETH_QUEUE_STATE_STARTED;
1325 [ # # ]: 0 : for (i = 0; i < dev->data->nb_tx_queues; i++)
1326 : 0 : dev->data->tx_queue_state[i] = RTE_ETH_QUEUE_STATE_STARTED;
1327 : :
1328 : : return 0;
1329 : : }
1330 : :
1331 : : static void
1332 : 0 : zxdh_rxq_info_get(struct rte_eth_dev *dev, uint16_t rx_queue_id, struct rte_eth_rxq_info *qinfo)
1333 : : {
1334 : : struct zxdh_virtnet_rx *rxq = NULL;
1335 : :
1336 [ # # ]: 0 : if (rx_queue_id < dev->data->nb_rx_queues)
1337 : 0 : rxq = dev->data->rx_queues[rx_queue_id];
1338 [ # # ]: 0 : if (!rxq) {
1339 : 0 : PMD_RX_LOG(ERR, "rxq is null");
1340 : 0 : return;
1341 : : }
1342 : 0 : qinfo->nb_desc = rxq->vq->vq_nentries;
1343 : 0 : qinfo->conf.rx_free_thresh = rxq->vq->vq_free_thresh;
1344 : 0 : qinfo->conf.offloads = dev->data->dev_conf.rxmode.offloads;
1345 : 0 : qinfo->queue_state = dev->data->rx_queue_state[rx_queue_id];
1346 : : }
1347 : :
1348 : : static void
1349 : 0 : zxdh_txq_info_get(struct rte_eth_dev *dev, uint16_t tx_queue_id, struct rte_eth_txq_info *qinfo)
1350 : : {
1351 : : struct zxdh_virtnet_tx *txq = NULL;
1352 : :
1353 [ # # ]: 0 : if (tx_queue_id < dev->data->nb_tx_queues)
1354 : 0 : txq = dev->data->tx_queues[tx_queue_id];
1355 [ # # ]: 0 : if (!txq) {
1356 : 0 : PMD_TX_LOG(ERR, "txq is null");
1357 : 0 : return;
1358 : : }
1359 : 0 : qinfo->nb_desc = txq->vq->vq_nentries;
1360 : 0 : qinfo->conf.tx_free_thresh = txq->vq->vq_free_thresh;
1361 : 0 : qinfo->conf.offloads = dev->data->dev_conf.txmode.offloads;
1362 : 0 : qinfo->queue_state = dev->data->tx_queue_state[tx_queue_id];
1363 : : }
1364 : :
1365 : : static const uint32_t *
1366 : 0 : zxdh_dev_supported_ptypes_get(struct rte_eth_dev *dev, size_t *ptype_sz)
1367 : : {
1368 : : static const uint32_t ptypes[] = {
1369 : : RTE_PTYPE_L2_ETHER,
1370 : : RTE_PTYPE_L3_IPV4_EXT_UNKNOWN,
1371 : : RTE_PTYPE_L3_IPV6_EXT_UNKNOWN,
1372 : : RTE_PTYPE_L4_NONFRAG,
1373 : : RTE_PTYPE_L4_FRAG,
1374 : : RTE_PTYPE_L4_TCP,
1375 : : RTE_PTYPE_L4_UDP,
1376 : : RTE_PTYPE_INNER_L3_IPV4_EXT_UNKNOWN,
1377 : : RTE_PTYPE_INNER_L3_IPV6_EXT_UNKNOWN,
1378 : : RTE_PTYPE_INNER_L4_NONFRAG,
1379 : : RTE_PTYPE_INNER_L4_FRAG,
1380 : : RTE_PTYPE_INNER_L4_TCP,
1381 : : RTE_PTYPE_INNER_L4_UDP,
1382 : : RTE_PTYPE_UNKNOWN
1383 : : };
1384 : :
1385 [ # # ]: 0 : if (!dev->rx_pkt_burst)
1386 : : return NULL;
1387 : 0 : *ptype_sz = sizeof(ptypes);
1388 : 0 : return ptypes;
1389 : : }
1390 : :
1391 : : /* dev_ops for zxdh, bare necessities for basic operation */
1392 : : static const struct eth_dev_ops zxdh_eth_dev_ops = {
1393 : : .dev_configure = zxdh_dev_configure,
1394 : : .dev_start = zxdh_dev_start,
1395 : : .dev_stop = zxdh_dev_stop,
1396 : : .dev_close = zxdh_dev_close,
1397 : : .dev_infos_get = zxdh_dev_infos_get,
1398 : : .rx_queue_setup = zxdh_dev_rx_queue_setup,
1399 : : .tx_queue_setup = zxdh_dev_tx_queue_setup,
1400 : : .rx_queue_intr_enable = zxdh_dev_rx_queue_intr_enable,
1401 : : .rx_queue_intr_disable = zxdh_dev_rx_queue_intr_disable,
1402 : : .rxq_info_get = zxdh_rxq_info_get,
1403 : : .txq_info_get = zxdh_txq_info_get,
1404 : : .link_update = zxdh_dev_link_update,
1405 : : .dev_set_link_up = zxdh_dev_set_link_up,
1406 : : .dev_set_link_down = zxdh_dev_set_link_down,
1407 : : .mac_addr_add = zxdh_dev_mac_addr_add,
1408 : : .mac_addr_remove = zxdh_dev_mac_addr_remove,
1409 : : .mac_addr_set = zxdh_dev_mac_addr_set,
1410 : : .promiscuous_enable = zxdh_dev_promiscuous_enable,
1411 : : .promiscuous_disable = zxdh_dev_promiscuous_disable,
1412 : : .allmulticast_enable = zxdh_dev_allmulticast_enable,
1413 : : .allmulticast_disable = zxdh_dev_allmulticast_disable,
1414 : : .vlan_filter_set = zxdh_dev_vlan_filter_set,
1415 : : .vlan_offload_set = zxdh_dev_vlan_offload_set,
1416 : : .reta_update = zxdh_dev_rss_reta_update,
1417 : : .reta_query = zxdh_dev_rss_reta_query,
1418 : : .rss_hash_update = zxdh_rss_hash_update,
1419 : : .rss_hash_conf_get = zxdh_rss_hash_conf_get,
1420 : : .stats_get = zxdh_dev_stats_get,
1421 : : .stats_reset = zxdh_dev_stats_reset,
1422 : : .xstats_get = zxdh_dev_xstats_get,
1423 : : .xstats_get_names = zxdh_dev_xstats_get_names,
1424 : : .xstats_reset = zxdh_dev_stats_reset,
1425 : : .mtu_set = zxdh_dev_mtu_set,
1426 : : .fw_version_get = zxdh_dev_fw_version_get,
1427 : : .get_module_info = zxdh_dev_get_module_info,
1428 : : .get_module_eeprom = zxdh_dev_get_module_eeprom,
1429 : : .dev_supported_ptypes_get = zxdh_dev_supported_ptypes_get,
1430 : : .mtr_ops_get = zxdh_meter_ops_get,
1431 : : };
1432 : :
1433 : : static int32_t
1434 : 0 : zxdh_init_device(struct rte_eth_dev *eth_dev)
1435 : : {
1436 : 0 : struct zxdh_hw *hw = eth_dev->data->dev_private;
1437 : 0 : struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev);
1438 : : int ret = 0;
1439 : :
1440 : 0 : ret = zxdh_read_pci_caps(pci_dev, hw);
1441 [ # # ]: 0 : if (ret) {
1442 : 0 : PMD_DRV_LOG(ERR, "port 0x%x pci caps read failed", hw->port_id);
1443 : 0 : goto err;
1444 : : }
1445 : :
1446 : 0 : zxdh_hw_internal[hw->port_id].zxdh_vtpci_ops = &zxdh_dev_pci_ops;
1447 : 0 : zxdh_pci_reset(hw);
1448 : 0 : zxdh_get_pci_dev_config(hw);
1449 : :
1450 [ # # ]: 0 : rte_ether_addr_copy((struct rte_ether_addr *)hw->mac_addr, ð_dev->data->mac_addrs[0]);
1451 : :
1452 : : /* If host does not support both status and MSI-X then disable LSC */
1453 [ # # # # ]: 0 : if (zxdh_pci_with_feature(hw, ZXDH_NET_F_STATUS) && hw->use_msix != ZXDH_MSIX_NONE)
1454 : 0 : eth_dev->data->dev_flags |= RTE_ETH_DEV_INTR_LSC;
1455 : : else
1456 : 0 : eth_dev->data->dev_flags &= ~RTE_ETH_DEV_INTR_LSC;
1457 : :
1458 : : return 0;
1459 : :
1460 : : err:
1461 : 0 : PMD_DRV_LOG(ERR, "port %d init device failed", eth_dev->data->port_id);
1462 : 0 : return ret;
1463 : : }
1464 : :
1465 : : static int
1466 : 0 : zxdh_agent_comm(struct rte_eth_dev *eth_dev, struct zxdh_hw *hw)
1467 : : {
1468 [ # # ]: 0 : if (zxdh_phyport_get(eth_dev, &hw->phyport) != 0) {
1469 : 0 : PMD_DRV_LOG(ERR, "Failed to get phyport");
1470 : 0 : return -1;
1471 : : }
1472 : 0 : PMD_DRV_LOG(DEBUG, "Get phyport success: 0x%x", hw->phyport);
1473 : :
1474 : 0 : hw->vfid = zxdh_vport_to_vfid(hw->vport);
1475 : :
1476 [ # # ]: 0 : if (zxdh_hashidx_get(eth_dev, &hw->hash_search_index) != 0) {
1477 : 0 : PMD_DRV_LOG(ERR, "Failed to get hash idx");
1478 : 0 : return -1;
1479 : : }
1480 : :
1481 [ # # ]: 0 : if (zxdh_panelid_get(eth_dev, &hw->panel_id) != 0) {
1482 : 0 : PMD_DRV_LOG(ERR, "Failed to get panel_id");
1483 : 0 : return -1;
1484 : : }
1485 : 0 : PMD_DRV_LOG(DEBUG, "Get panel id success: 0x%x", hw->panel_id);
1486 : :
1487 : 0 : return 0;
1488 : : }
1489 : :
1490 : : static inline int
1491 : 0 : zxdh_dtb_dump_res_init(struct zxdh_hw *hw, ZXDH_DEV_INIT_CTRL_T *dpp_ctrl)
1492 : : {
1493 : : int ret = 0, i;
1494 : :
1495 : 0 : struct zxdh_dtb_bulk_dump_info dtb_dump_baseres[] = {
1496 : : {"sdt_vport_att_table", 4 * 1024 * 1024, ZXDH_SDT_VPORT_ATT_TABLE, NULL},
1497 : : {"sdt_vlan_att_table", 4 * 1024 * 1024, ZXDH_SDT_VLAN_ATT_TABLE, NULL},
1498 : : {"sdt_rss_table", 4 * 1024 * 1024, ZXDH_SDT_RSS_ATT_TABLE, NULL},
1499 : : {"sdt_l2_entry_table0", 5 * 1024 * 1024, ZXDH_SDT_L2_ENTRY_TABLE0, NULL},
1500 : : {"sdt_l2_entry_table1", 5 * 1024 * 1024, ZXDH_SDT_L2_ENTRY_TABLE1, NULL},
1501 : : {"sdt_l2_entry_table2", 5 * 1024 * 1024, ZXDH_SDT_L2_ENTRY_TABLE2, NULL},
1502 : : {"sdt_l2_entry_table3", 5 * 1024 * 1024, ZXDH_SDT_L2_ENTRY_TABLE3, NULL},
1503 : : {"sdt_mc_table0", 5 * 1024 * 1024, ZXDH_SDT_MC_TABLE0, NULL},
1504 : : {"sdt_mc_table1", 5 * 1024 * 1024, ZXDH_SDT_MC_TABLE1, NULL},
1505 : : {"sdt_mc_table2", 5 * 1024 * 1024, ZXDH_SDT_MC_TABLE2, NULL},
1506 : : {"sdt_mc_table3", 5 * 1024 * 1024, ZXDH_SDT_MC_TABLE3, NULL},
1507 : : };
1508 : :
1509 : 0 : struct zxdh_dev_shared_data *dev_sd = hw->dev_sd;
1510 : : struct zxdh_dtb_shared_data *dtb_data = &dev_sd->dtb_sd;
1511 : :
1512 [ # # ]: 0 : for (i = 0; i < (int)RTE_DIM(dtb_dump_baseres); i++) {
1513 : 0 : struct zxdh_dtb_bulk_dump_info *p = dtb_dump_baseres + i;
1514 : 0 : char buf[ZXDH_MAX_NAME_LEN] = {0};
1515 : 0 : snprintf(buf, sizeof(buf), "%s_%x", p->mz_name, hw->dev_id);
1516 : 0 : p->mz_name = buf;
1517 : :
1518 : : const struct rte_memzone *generic_dump_mz =
1519 : 0 : rte_memzone_reserve_aligned(p->mz_name, p->mz_size,
1520 : : SOCKET_ID_ANY, 0, RTE_CACHE_LINE_SIZE);
1521 [ # # ]: 0 : if (generic_dump_mz == NULL) {
1522 : 0 : PMD_DRV_LOG(ERR, "Cannot alloc mem for dtb table bulk dump, mz_name is %s, mz_size is %u",
1523 : : p->mz_name, p->mz_size);
1524 : : ret = -ENOMEM;
1525 : 0 : return ret;
1526 : : }
1527 : 0 : p->mz = generic_dump_mz;
1528 : 0 : dpp_ctrl->dump_addr_info[i].vir_addr = generic_dump_mz->addr_64;
1529 : 0 : dpp_ctrl->dump_addr_info[i].phy_addr = generic_dump_mz->iova;
1530 : 0 : dpp_ctrl->dump_addr_info[i].sdt_no = p->sdt_no;
1531 : 0 : dpp_ctrl->dump_addr_info[i].size = p->mz_size;
1532 : :
1533 : 0 : dtb_data->dtb_table_bulk_dump_mz[dpp_ctrl->dump_sdt_num] = generic_dump_mz;
1534 : 0 : dpp_ctrl->dump_sdt_num++;
1535 : : }
1536 : : return ret;
1537 : : }
1538 : :
1539 : : static int
1540 : 0 : zxdh_np_dtb_res_init(struct rte_eth_dev *dev)
1541 : : {
1542 : 0 : struct zxdh_hw *hw = dev->data->dev_private;
1543 : 0 : struct zxdh_bar_offset_params param = {0};
1544 : 0 : struct zxdh_bar_offset_res res = {0};
1545 : 0 : char buf[ZXDH_MAX_NAME_LEN] = {0};
1546 : 0 : struct zxdh_dtb_shared_data *dtb_data = &hw->dev_sd->dtb_sd;
1547 : : int ret = 0;
1548 : :
1549 [ # # ]: 0 : if (dtb_data->init_done) {
1550 : 0 : PMD_DRV_LOG(DEBUG, "DTB res already init done, dev %s no need init",
1551 : : dev->device->name);
1552 : 0 : return 0;
1553 : : }
1554 : :
1555 : 0 : dtb_data->queueid = ZXDH_INVALID_DTBQUE;
1556 : 0 : dtb_data->bind_device = dev;
1557 : 0 : dtb_data->dev_refcnt++;
1558 : 0 : dtb_data->init_done = 1;
1559 : :
1560 : 0 : ZXDH_DEV_INIT_CTRL_T *dpp_ctrl = rte_zmalloc(NULL, sizeof(*dpp_ctrl) +
1561 : : sizeof(ZXDH_DTB_ADDR_INFO_T) * 256, 0);
1562 [ # # ]: 0 : if (dpp_ctrl == NULL) {
1563 : 0 : PMD_DRV_LOG(ERR, "dev %s annot allocate memory for dpp_ctrl", dev->device->name);
1564 : : ret = -ENOMEM;
1565 : 0 : goto free_res;
1566 : : }
1567 : 0 : dpp_ctrl->queue_id = 0xff;
1568 : 0 : dpp_ctrl->vport = hw->vport.vport;
1569 : 0 : dpp_ctrl->vector = ZXDH_MSIX_INTR_DTB_VEC;
1570 : 0 : strlcpy(dpp_ctrl->port_name, dev->device->name, sizeof(dpp_ctrl->port_name));
1571 : 0 : dpp_ctrl->pcie_vir_addr = hw->bar_addr[0];
1572 : :
1573 : 0 : param.pcie_id = hw->pcie_id;
1574 : 0 : param.virt_addr = hw->bar_addr[0] + ZXDH_CTRLCH_OFFSET;
1575 : 0 : param.type = ZXDH_URI_NP;
1576 : :
1577 : 0 : ret = zxdh_get_bar_offset(¶m, &res);
1578 [ # # ]: 0 : if (ret) {
1579 : 0 : PMD_DRV_LOG(ERR, "dev %s get npbar offset failed", dev->device->name);
1580 : 0 : goto free_res;
1581 : : }
1582 : 0 : dpp_ctrl->np_bar_len = res.bar_length;
1583 : 0 : dpp_ctrl->np_bar_offset = res.bar_offset;
1584 : :
1585 [ # # ]: 0 : if (!dtb_data->dtb_table_conf_mz) {
1586 : 0 : snprintf(buf, sizeof(buf), "%s_%x", "zxdh_dtb_table_conf_mz", hw->dev_id);
1587 : 0 : const struct rte_memzone *conf_mz = rte_memzone_reserve_aligned(buf,
1588 : : ZXDH_DTB_TABLE_CONF_SIZE, SOCKET_ID_ANY, 0, RTE_CACHE_LINE_SIZE);
1589 : :
1590 [ # # ]: 0 : if (conf_mz == NULL) {
1591 : 0 : PMD_DRV_LOG(ERR,
1592 : : "dev %s annot allocate memory for dtb table conf",
1593 : : dev->device->name);
1594 : : ret = -ENOMEM;
1595 : 0 : goto free_res;
1596 : : }
1597 : 0 : dpp_ctrl->down_vir_addr = conf_mz->addr_64;
1598 : 0 : dpp_ctrl->down_phy_addr = conf_mz->iova;
1599 : 0 : dtb_data->dtb_table_conf_mz = conf_mz;
1600 : : }
1601 : :
1602 [ # # ]: 0 : if (!dtb_data->dtb_table_dump_mz) {
1603 : : memset(buf, '\0', sizeof(buf));
1604 : 0 : snprintf(buf, sizeof(buf), "%s_%x", "zxdh_dtb_table_dump_mz", hw->dev_id);
1605 : 0 : const struct rte_memzone *dump_mz = rte_memzone_reserve_aligned(buf,
1606 : : ZXDH_DTB_TABLE_DUMP_SIZE, SOCKET_ID_ANY, 0, RTE_CACHE_LINE_SIZE);
1607 : :
1608 [ # # ]: 0 : if (dump_mz == NULL) {
1609 : 0 : PMD_DRV_LOG(ERR,
1610 : : "dev %s Cannot allocate memory for dtb table dump",
1611 : : dev->device->name);
1612 : : ret = -ENOMEM;
1613 : 0 : goto free_res;
1614 : : }
1615 : 0 : dpp_ctrl->dump_vir_addr = dump_mz->addr_64;
1616 : 0 : dpp_ctrl->dump_phy_addr = dump_mz->iova;
1617 : 0 : dtb_data->dtb_table_dump_mz = dump_mz;
1618 : : }
1619 : :
1620 : 0 : ret = zxdh_dtb_dump_res_init(hw, dpp_ctrl);
1621 [ # # ]: 0 : if (ret) {
1622 : 0 : PMD_DRV_LOG(ERR, "dev %s zxdh_dtb_dump_res_init failed", dev->device->name);
1623 : 0 : goto free_res;
1624 : : }
1625 : :
1626 : 0 : ret = zxdh_np_host_init(hw->slot_id, dpp_ctrl);
1627 [ # # ]: 0 : if (ret) {
1628 : 0 : PMD_DRV_LOG(ERR, "dev %s dpp host np init failed", dev->device->name);
1629 : 0 : goto free_res;
1630 : : }
1631 : :
1632 : 0 : PMD_DRV_LOG(DEBUG, "dev %s dpp host np init ok.dtb queue %u",
1633 : : dev->device->name, dpp_ctrl->queue_id);
1634 : 0 : dtb_data->queueid = dpp_ctrl->queue_id;
1635 : 0 : rte_free(dpp_ctrl);
1636 : 0 : return 0;
1637 : :
1638 : 0 : free_res:
1639 : 0 : zxdh_np_dtb_data_res_free(hw);
1640 : 0 : rte_free(dpp_ctrl);
1641 : 0 : return ret;
1642 : : }
1643 : :
1644 : : static inline uint16_t
1645 : 0 : zxdh_get_dev_shared_data_idx(uint32_t dev_serial_id)
1646 : : {
1647 : : uint16_t idx = 0;
1648 [ # # ]: 0 : for (; idx < ZXDH_SLOT_MAX; idx++) {
1649 [ # # # # ]: 0 : if (g_dev_sd[idx].serial_id == dev_serial_id || g_dev_sd[idx].serial_id == 0)
1650 : 0 : return idx;
1651 : : }
1652 : :
1653 : 0 : PMD_DRV_LOG(ERR, "dev serial_id[%u] can not found in global dev_share_data arrays",
1654 : : dev_serial_id);
1655 : 0 : return ZXDH_INVALID_SLOT_IDX;
1656 : : }
1657 : :
1658 : 0 : static int zxdh_init_dev_share_data(struct rte_eth_dev *eth_dev)
1659 : : {
1660 : 0 : struct zxdh_hw *hw = eth_dev->data->dev_private;
1661 : 0 : struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev);
1662 : 0 : uint32_t serial_id = (pci_dev->addr.domain << 16) |
1663 : 0 : (pci_dev->addr.bus << 8) | pci_dev->addr.devid;
1664 : : uint16_t slot_id = 0;
1665 : :
1666 [ # # ]: 0 : if (serial_id <= 0) {
1667 : 0 : PMD_DRV_LOG(ERR, "failed to get pcie bus-info %s", pci_dev->name);
1668 : 0 : return -EINVAL;
1669 : : }
1670 : :
1671 : 0 : slot_id = zxdh_get_dev_shared_data_idx(serial_id);
1672 [ # # ]: 0 : if (slot_id == ZXDH_INVALID_SLOT_IDX)
1673 : : return -EINVAL;
1674 : :
1675 : 0 : hw->slot_id = slot_id;
1676 : 0 : hw->dev_id = (hw->pcie_id << 16) | (hw->slot_id & 0xffff);
1677 : 0 : g_dev_sd[slot_id].serial_id = serial_id;
1678 : 0 : hw->dev_sd = &g_dev_sd[slot_id];
1679 : :
1680 : 0 : return 0;
1681 : : }
1682 : :
1683 : : static int
1684 : 0 : zxdh_init_shared_data(void)
1685 : : {
1686 : : const struct rte_memzone *mz;
1687 : : int ret = 0;
1688 : :
1689 : : rte_spinlock_lock(&zxdh_shared_data_lock);
1690 [ # # ]: 0 : if (zxdh_shared_data == NULL) {
1691 [ # # ]: 0 : if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
1692 : : /* Allocate shared memory. */
1693 : 0 : mz = rte_memzone_reserve("zxdh_pmd_shared_data",
1694 : : sizeof(*zxdh_shared_data), SOCKET_ID_ANY, 0);
1695 [ # # ]: 0 : if (mz == NULL) {
1696 : 0 : PMD_DRV_LOG(ERR, "Cannot allocate zxdh shared data");
1697 : 0 : ret = -rte_errno;
1698 : 0 : goto error;
1699 : : }
1700 : 0 : zxdh_shared_data = mz->addr;
1701 : : memset(zxdh_shared_data, 0, sizeof(*zxdh_shared_data));
1702 : 0 : rte_spinlock_init(&zxdh_shared_data->lock);
1703 : : } else { /* Lookup allocated shared memory. */
1704 : 0 : mz = rte_memzone_lookup("zxdh_pmd_shared_data");
1705 [ # # ]: 0 : if (mz == NULL) {
1706 : 0 : PMD_DRV_LOG(ERR, "Cannot attach zxdh shared data");
1707 : 0 : ret = -rte_errno;
1708 : 0 : goto error;
1709 : : }
1710 : 0 : zxdh_shared_data = mz->addr;
1711 : : }
1712 : : }
1713 : :
1714 : 0 : error:
1715 : : rte_spinlock_unlock(&zxdh_shared_data_lock);
1716 : 0 : return ret;
1717 : : }
1718 : :
1719 : : static void
1720 : 0 : zxdh_free_sh_res(void)
1721 : : {
1722 [ # # ]: 0 : if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
1723 : : rte_spinlock_lock(&zxdh_shared_data_lock);
1724 [ # # # # ]: 0 : if (zxdh_shared_data != NULL && zxdh_shared_data->init_done &&
1725 [ # # ]: 0 : (--zxdh_shared_data->dev_refcnt == 0)) {
1726 : 0 : rte_mempool_free(zxdh_shared_data->mtr_mp);
1727 : 0 : rte_mempool_free(zxdh_shared_data->mtr_profile_mp);
1728 : 0 : rte_mempool_free(zxdh_shared_data->mtr_policy_mp);
1729 : : }
1730 : : rte_spinlock_unlock(&zxdh_shared_data_lock);
1731 : : }
1732 : 0 : }
1733 : :
1734 : : static int
1735 : 0 : zxdh_init_sh_res(struct zxdh_shared_data *sd)
1736 : : {
1737 : : const char *MZ_ZXDH_MTR_MP = "zxdh_mtr_mempool";
1738 : : const char *MZ_ZXDH_MTR_PROFILE_MP = "zxdh_mtr_profile_mempool";
1739 : : const char *MZ_ZXDH_MTR_POLICY_MP = "zxdh_mtr_policy_mempool";
1740 : : struct rte_mempool *flow_mp = NULL;
1741 : : struct rte_mempool *mtr_mp = NULL;
1742 : : struct rte_mempool *mtr_profile_mp = NULL;
1743 : : struct rte_mempool *mtr_policy_mp = NULL;
1744 : :
1745 [ # # ]: 0 : if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
1746 : 0 : mtr_mp = rte_mempool_create(MZ_ZXDH_MTR_MP, ZXDH_MAX_MTR_NUM,
1747 : : sizeof(struct zxdh_mtr_object), 64, 0,
1748 : : NULL, NULL, NULL, NULL, SOCKET_ID_ANY, 0);
1749 [ # # ]: 0 : if (mtr_mp == NULL) {
1750 : 0 : PMD_DRV_LOG(ERR, "Cannot allocate zxdh mtr mempool");
1751 : 0 : goto error;
1752 : : }
1753 : 0 : mtr_profile_mp = rte_mempool_create(MZ_ZXDH_MTR_PROFILE_MP,
1754 : : MAX_MTR_PROFILE_NUM, sizeof(struct zxdh_meter_profile),
1755 : : 64, 0, NULL, NULL, NULL,
1756 : : NULL, SOCKET_ID_ANY, 0);
1757 [ # # ]: 0 : if (mtr_profile_mp == NULL) {
1758 : 0 : PMD_DRV_LOG(ERR, "Cannot allocate zxdh mtr profile mempool");
1759 : 0 : goto error;
1760 : : }
1761 : 0 : mtr_policy_mp = rte_mempool_create(MZ_ZXDH_MTR_POLICY_MP,
1762 : : ZXDH_MAX_POLICY_NUM, sizeof(struct zxdh_meter_policy),
1763 : : 64, 0, NULL, NULL, NULL, NULL, SOCKET_ID_ANY, 0);
1764 [ # # ]: 0 : if (mtr_policy_mp == NULL) {
1765 : 0 : PMD_DRV_LOG(ERR, "Cannot allocate zxdh mtr profile mempool");
1766 : 0 : goto error;
1767 : : }
1768 : 0 : sd->mtr_mp = mtr_mp;
1769 : 0 : sd->mtr_profile_mp = mtr_profile_mp;
1770 : 0 : sd->mtr_policy_mp = mtr_policy_mp;
1771 : 0 : TAILQ_INIT(&zxdh_shared_data->meter_profile_list);
1772 : 0 : TAILQ_INIT(&zxdh_shared_data->mtr_list);
1773 : 0 : TAILQ_INIT(&zxdh_shared_data->mtr_policy_list);
1774 : : }
1775 : : return 0;
1776 : :
1777 : 0 : error:
1778 : 0 : rte_mempool_free(mtr_policy_mp);
1779 : 0 : rte_mempool_free(mtr_profile_mp);
1780 : 0 : rte_mempool_free(mtr_mp);
1781 : 0 : rte_mempool_free(flow_mp);
1782 : 0 : return -rte_errno;
1783 : : }
1784 : :
1785 : : static int
1786 : 0 : zxdh_init_once(struct rte_eth_dev *eth_dev)
1787 : : {
1788 : 0 : struct zxdh_hw *hw = eth_dev->data->dev_private;
1789 : : int ret = 0;
1790 : :
1791 [ # # ]: 0 : if (hw->is_pf) {
1792 : 0 : ret = zxdh_init_dev_share_data(eth_dev);
1793 [ # # ]: 0 : if (ret < 0) {
1794 : 0 : PMD_DRV_LOG(ERR, "init dev share date failed");
1795 : 0 : return ret;
1796 : : }
1797 : : }
1798 : :
1799 [ # # ]: 0 : if (zxdh_init_shared_data())
1800 : : return -1;
1801 : :
1802 : 0 : struct zxdh_shared_data *sd = zxdh_shared_data;
1803 : 0 : rte_spinlock_lock(&sd->lock);
1804 [ # # ]: 0 : if (rte_eal_process_type() == RTE_PROC_SECONDARY) {
1805 [ # # ]: 0 : if (!sd->init_done) {
1806 : 0 : ++sd->secondary_cnt;
1807 : 0 : sd->init_done = true;
1808 : : }
1809 : 0 : goto out;
1810 : : }
1811 : : /* RTE_PROC_PRIMARY */
1812 [ # # ]: 0 : if (!sd->init_done) {
1813 : : /*shared struct and res init */
1814 : 0 : ret = zxdh_init_sh_res(sd);
1815 [ # # ]: 0 : if (ret != 0)
1816 : 0 : goto out;
1817 : : rte_spinlock_init(&g_mtr_res.hw_plcr_res_lock);
1818 : : memset(&g_mtr_res, 0, sizeof(g_mtr_res));
1819 : 0 : sd->init_done = true;
1820 : : }
1821 : 0 : sd->dev_refcnt++;
1822 : 0 : out:
1823 : : rte_spinlock_unlock(&sd->lock);
1824 : 0 : return ret;
1825 : : }
1826 : :
1827 : : static int
1828 : 0 : zxdh_tbl_entry_offline_destroy(struct zxdh_hw *hw)
1829 : : {
1830 : 0 : struct zxdh_dtb_shared_data *dtb_data = &hw->dev_sd->dtb_sd;
1831 : : int ret = 0;
1832 [ # # ]: 0 : if (!dtb_data->init_done)
1833 : : return ret;
1834 [ # # ]: 0 : if (hw->is_pf) {
1835 : : uint32_t sdt_no;
1836 : 0 : sdt_no = ZXDH_SDT_L2_ENTRY_TABLE0 + hw->hash_search_index;
1837 : 0 : ret = zxdh_np_dtb_hash_offline_delete(hw->dev_id, dtb_data->queueid, sdt_no, 0);
1838 [ # # ]: 0 : if (ret)
1839 : 0 : PMD_DRV_LOG(ERR, "sdt_no %d delete failed. code:%d ", sdt_no, ret);
1840 : 0 : sdt_no = ZXDH_SDT_MC_TABLE0 + hw->hash_search_index;
1841 : 0 : ret = zxdh_np_dtb_hash_offline_delete(hw->dev_id, dtb_data->queueid, sdt_no, 0);
1842 [ # # ]: 0 : if (ret)
1843 : 0 : PMD_DRV_LOG(ERR, "sdt_no %d delete failed. code:%d ", sdt_no, ret);
1844 : : }
1845 : : return ret;
1846 : : }
1847 : :
1848 : : static int
1849 : 0 : zxdh_np_init(struct rte_eth_dev *eth_dev)
1850 : : {
1851 : 0 : struct zxdh_hw *hw = eth_dev->data->dev_private;
1852 : 0 : struct zxdh_dtb_shared_data *dtb_data = &hw->dev_sd->dtb_sd;
1853 : : int ret = 0;
1854 : :
1855 [ # # # # ]: 0 : if (hw->is_pf && dtb_data->init_done) {
1856 : 0 : dtb_data->dev_refcnt++;
1857 : 0 : zxdh_tbl_entry_offline_destroy(hw);
1858 : 0 : PMD_DRV_LOG(INFO, "no need to init dtb dtb chanenl %d devref %d",
1859 : : dtb_data->queueid, dtb_data->dev_refcnt);
1860 : 0 : return 0;
1861 : : }
1862 : :
1863 [ # # ]: 0 : if (hw->is_pf) {
1864 : 0 : ret = zxdh_np_dtb_res_init(eth_dev);
1865 [ # # ]: 0 : if (ret) {
1866 : 0 : PMD_DRV_LOG(ERR, "np dtb init failed, ret:%d", ret);
1867 : 0 : return ret;
1868 : : }
1869 : : }
1870 : :
1871 [ # # ]: 0 : if (hw->is_pf) {
1872 : 0 : ret = zxdh_np_se_res_get_and_init(hw->dev_id, ZXDH_SE_STD_NIC_RES_TYPE);
1873 [ # # ]: 0 : if (ret) {
1874 : 0 : PMD_DRV_LOG(ERR, "dpp apt init failed, code:%d ", ret);
1875 : 0 : return -ret;
1876 : : }
1877 [ # # ]: 0 : if (hw->hash_search_index >= ZXDH_HASHIDX_MAX) {
1878 : 0 : PMD_DRV_LOG(ERR, "invalid hash idx %d", hw->hash_search_index);
1879 : 0 : return -1;
1880 : : }
1881 : 0 : zxdh_tbl_entry_offline_destroy(hw);
1882 : : }
1883 : :
1884 [ # # ]: 0 : if (zxdh_shared_data != NULL)
1885 : 0 : zxdh_shared_data->np_init_done = 1;
1886 : :
1887 : 0 : PMD_DRV_LOG(DEBUG, "np init ok");
1888 : 0 : return 0;
1889 : : }
1890 : :
1891 : : static int
1892 : 0 : zxdh_tables_init(struct rte_eth_dev *dev)
1893 : : {
1894 : : int ret = 0;
1895 : :
1896 : 0 : ret = zxdh_port_attr_init(dev);
1897 [ # # ]: 0 : if (ret) {
1898 : 0 : PMD_DRV_LOG(ERR, "zxdh_port_attr_init failed");
1899 : 0 : return ret;
1900 : : }
1901 : :
1902 : 0 : ret = zxdh_panel_table_init(dev);
1903 [ # # ]: 0 : if (ret) {
1904 : 0 : PMD_DRV_LOG(ERR, "panel table init failed");
1905 : 0 : return ret;
1906 : : }
1907 : :
1908 : 0 : ret = zxdh_promisc_table_init(dev);
1909 [ # # ]: 0 : if (ret) {
1910 : 0 : PMD_DRV_LOG(ERR, "promisc_table_init failed");
1911 : 0 : return ret;
1912 : : }
1913 : :
1914 : 0 : ret = zxdh_vlan_filter_table_init(dev);
1915 [ # # ]: 0 : if (ret) {
1916 : 0 : PMD_DRV_LOG(ERR, "vlan filter table init failed");
1917 : 0 : return ret;
1918 : : }
1919 : :
1920 : : return ret;
1921 : : }
1922 : :
1923 : : static void
1924 : 0 : zxdh_queue_res_get(struct rte_eth_dev *eth_dev)
1925 : : {
1926 : 0 : struct zxdh_hw *hw = eth_dev->data->dev_private;
1927 : : uint32_t value = 0;
1928 : : uint16_t offset = 0;
1929 : :
1930 [ # # ]: 0 : if (hw->is_pf) {
1931 : 0 : hw->max_queue_pairs = *(volatile uint8_t *)(hw->bar_addr[0] +
1932 : : ZXDH_PF_QUEUE_PAIRS_ADDR);
1933 : 0 : PMD_DRV_LOG(DEBUG, "is_pf max_queue_pairs is %x", hw->max_queue_pairs);
1934 : : } else {
1935 : 0 : hw->max_queue_pairs = *(volatile uint8_t *)(hw->bar_addr[0] +
1936 : 0 : ZXDH_VF_QUEUE_PAIRS_ADDR + offset);
1937 : 0 : PMD_DRV_LOG(DEBUG, "is_vf max_queue_pairs is %x", hw->max_queue_pairs);
1938 : : }
1939 : :
1940 : : /* pf/vf read queue start id and queue_max cfg */
1941 : 0 : value = *(volatile uint32_t *)(hw->bar_addr[0] + ZXDH_QUEUE_POOL_ADDR + offset * 4);
1942 : 0 : hw->queue_pool_count = value & 0x0000ffff;
1943 : 0 : hw->queue_pool_start = value >> 16;
1944 [ # # ]: 0 : if (hw->max_queue_pairs > ZXDH_RX_QUEUES_MAX || hw->max_queue_pairs == 0)
1945 : 0 : hw->max_queue_pairs = ZXDH_RX_QUEUES_MAX;
1946 [ # # ]: 0 : if (hw->queue_pool_count > ZXDH_TOTAL_QUEUES_NUM / 2 || hw->queue_pool_count == 0)
1947 : 0 : hw->queue_pool_count = ZXDH_TOTAL_QUEUES_NUM / 2;
1948 [ # # ]: 0 : if (hw->queue_pool_start > ZXDH_TOTAL_QUEUES_NUM / 2)
1949 : 0 : hw->queue_pool_start = 0;
1950 : 0 : }
1951 : :
1952 : : static int
1953 : 0 : zxdh_priv_res_init(struct zxdh_hw *hw)
1954 : : {
1955 [ # # ]: 0 : if (hw->is_pf) {
1956 : 0 : hw->vfinfo = rte_zmalloc("vfinfo", ZXDH_MAX_VF * sizeof(struct vfinfo), 4);
1957 [ # # ]: 0 : if (hw->vfinfo == NULL) {
1958 : 0 : PMD_DRV_LOG(ERR, "vfinfo malloc failed");
1959 : 0 : return -ENOMEM;
1960 : : }
1961 : : } else {
1962 : 0 : hw->vfinfo = NULL;
1963 : : }
1964 : :
1965 : 0 : hw->channel_context = rte_zmalloc("zxdh_chnlctx",
1966 : : sizeof(struct zxdh_chnl_context) * ZXDH_QUEUES_NUM_MAX, 0);
1967 [ # # ]: 0 : if (hw->channel_context == NULL) {
1968 : 0 : PMD_DRV_LOG(ERR, "Failed to allocate channel_context");
1969 : 0 : return -ENOMEM;
1970 : : }
1971 : : return 0;
1972 : : }
1973 : :
1974 : : static void
1975 : 0 : zxdh_priv_res_free(struct zxdh_hw *priv)
1976 : : {
1977 : 0 : rte_free(priv->vfinfo);
1978 : 0 : priv->vfinfo = NULL;
1979 [ # # ]: 0 : if (priv->channel_context != NULL) {
1980 : 0 : rte_free(priv->channel_context);
1981 : 0 : priv->channel_context = NULL;
1982 : : }
1983 : 0 : }
1984 : :
1985 : : static uint8_t
1986 : : is_pf(uint16_t device_id)
1987 : : {
1988 : : return (device_id == ZXDH_E310_PF_DEVICEID ||
1989 : : device_id == ZXDH_E312_PF_DEVICEID ||
1990 : : device_id == ZXDH_E312S_PF_DEVICEID ||
1991 : : device_id == ZXDH_E316_PF_DEVICEID ||
1992 : 0 : device_id == ZXDH_E310_RDMA_PF_DEVICEID ||
1993 : : device_id == ZXDH_E312_RDMA_PF_DEVICEID);
1994 : : }
1995 : :
1996 : : static int
1997 : 0 : zxdh_eth_dev_init(struct rte_eth_dev *eth_dev)
1998 : : {
1999 : 0 : struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev);
2000 : 0 : struct zxdh_hw *hw = eth_dev->data->dev_private;
2001 : : int ret = 0;
2002 : :
2003 : 0 : eth_dev->dev_ops = &zxdh_eth_dev_ops;
2004 : :
2005 : : /* Allocate memory for storing MAC addresses */
2006 : 0 : eth_dev->data->mac_addrs = rte_zmalloc("zxdh_mac",
2007 : : ZXDH_MAX_MAC_ADDRS * RTE_ETHER_ADDR_LEN, 0);
2008 [ # # ]: 0 : if (eth_dev->data->mac_addrs == NULL) {
2009 : 0 : PMD_DRV_LOG(ERR, "Failed to allocate %d bytes store MAC addresses",
2010 : : ZXDH_MAX_MAC_ADDRS * RTE_ETHER_ADDR_LEN);
2011 : 0 : return -ENOMEM;
2012 : : }
2013 : :
2014 : : memset(hw, 0, sizeof(*hw));
2015 : 0 : hw->bar_addr[0] = (uint64_t)pci_dev->mem_resource[0].addr;
2016 [ # # ]: 0 : if (hw->bar_addr[0] == 0) {
2017 : 0 : PMD_DRV_LOG(ERR, "Bad mem resource");
2018 : 0 : return -EIO;
2019 : : }
2020 : :
2021 : 0 : hw->device_id = pci_dev->id.device_id;
2022 : 0 : hw->port_id = eth_dev->data->port_id;
2023 : 0 : hw->eth_dev = eth_dev;
2024 : 0 : hw->speed = RTE_ETH_SPEED_NUM_UNKNOWN;
2025 : 0 : hw->duplex = RTE_ETH_LINK_FULL_DUPLEX;
2026 [ # # # # ]: 0 : hw->slot_id = ZXDH_INVALID_SLOT_IDX;
2027 : : hw->is_pf = 0;
2028 : :
2029 [ # # ]: 0 : if (is_pf(pci_dev->id.device_id))
2030 : 0 : hw->is_pf = 1;
2031 : :
2032 : 0 : ret = zxdh_init_once(eth_dev);
2033 [ # # ]: 0 : if (ret != 0)
2034 : 0 : goto err_zxdh_init;
2035 : :
2036 : 0 : ret = zxdh_init_device(eth_dev);
2037 [ # # ]: 0 : if (ret < 0)
2038 : 0 : goto err_zxdh_init;
2039 : :
2040 : 0 : ret = zxdh_msg_chan_init();
2041 [ # # ]: 0 : if (ret != 0) {
2042 : 0 : PMD_DRV_LOG(ERR, "Failed to init bar msg chan");
2043 : 0 : goto err_zxdh_init;
2044 : : }
2045 : 0 : hw->msg_chan_init = 1;
2046 : :
2047 : 0 : ret = zxdh_msg_chan_hwlock_init(eth_dev);
2048 [ # # ]: 0 : if (ret != 0) {
2049 : 0 : PMD_DRV_LOG(ERR, "zxdh_msg_chan_hwlock_init failed ret %d", ret);
2050 : 0 : goto err_zxdh_init;
2051 : : }
2052 : :
2053 : 0 : ret = zxdh_msg_chan_enable(eth_dev);
2054 [ # # ]: 0 : if (ret != 0) {
2055 : 0 : PMD_DRV_LOG(ERR, "zxdh_msg_bar_chan_enable failed ret %d", ret);
2056 : 0 : goto err_zxdh_init;
2057 : : }
2058 : :
2059 : 0 : ret = zxdh_agent_comm(eth_dev, hw);
2060 [ # # ]: 0 : if (ret != 0)
2061 : 0 : goto err_zxdh_init;
2062 : :
2063 : 0 : ret = zxdh_np_init(eth_dev);
2064 [ # # ]: 0 : if (ret)
2065 : 0 : goto err_zxdh_init;
2066 : :
2067 : 0 : zxdh_queue_res_get(eth_dev);
2068 : 0 : zxdh_msg_cb_reg(hw);
2069 [ # # ]: 0 : if (zxdh_priv_res_init(hw) != 0)
2070 : 0 : goto err_zxdh_init;
2071 : 0 : ret = zxdh_configure_intr(eth_dev);
2072 [ # # ]: 0 : if (ret != 0)
2073 : 0 : goto err_zxdh_init;
2074 : :
2075 : 0 : ret = zxdh_tables_init(eth_dev);
2076 [ # # ]: 0 : if (ret != 0)
2077 : 0 : goto err_zxdh_init;
2078 : :
2079 : : return ret;
2080 : :
2081 : 0 : err_zxdh_init:
2082 : 0 : zxdh_intr_release(eth_dev);
2083 : 0 : zxdh_np_uninit(eth_dev);
2084 : 0 : zxdh_bar_msg_chan_exit();
2085 : 0 : zxdh_priv_res_free(hw);
2086 : 0 : zxdh_free_sh_res();
2087 : 0 : rte_free(hw->dev_sd);
2088 : 0 : hw->dev_sd = NULL;
2089 : 0 : rte_free(eth_dev->data->mac_addrs);
2090 : 0 : eth_dev->data->mac_addrs = NULL;
2091 : 0 : return ret;
2092 : : }
2093 : :
2094 : : static int
2095 : 0 : zxdh_eth_pci_probe(struct rte_pci_driver *pci_drv __rte_unused,
2096 : : struct rte_pci_device *pci_dev)
2097 : : {
2098 : 0 : return rte_eth_dev_pci_generic_probe(pci_dev,
2099 : : sizeof(struct zxdh_hw),
2100 : : zxdh_eth_dev_init);
2101 : : }
2102 : :
2103 : : static int
2104 : 0 : zxdh_eth_dev_uninit(struct rte_eth_dev *eth_dev)
2105 : : {
2106 : : int ret = 0;
2107 : :
2108 : 0 : ret = zxdh_dev_close(eth_dev);
2109 : :
2110 : 0 : return ret;
2111 : : }
2112 : :
2113 : : static int
2114 : 0 : zxdh_eth_pci_remove(struct rte_pci_device *pci_dev)
2115 : : {
2116 : 0 : int ret = rte_eth_dev_pci_generic_remove(pci_dev, zxdh_eth_dev_uninit);
2117 : :
2118 : 0 : return ret;
2119 : : }
2120 : :
2121 : : static const struct rte_pci_id pci_id_zxdh_map[] = {
2122 : : {RTE_PCI_DEVICE(ZXDH_PCI_VENDOR_ID, ZXDH_E310_PF_DEVICEID)},
2123 : : {RTE_PCI_DEVICE(ZXDH_PCI_VENDOR_ID, ZXDH_E310_VF_DEVICEID)},
2124 : : {RTE_PCI_DEVICE(ZXDH_PCI_VENDOR_ID, ZXDH_E312_PF_DEVICEID)},
2125 : : {RTE_PCI_DEVICE(ZXDH_PCI_VENDOR_ID, ZXDH_E312_VF_DEVICEID)},
2126 : : {RTE_PCI_DEVICE(ZXDH_PCI_VENDOR_ID, ZXDH_E312S_PF_DEVICEID)},
2127 : : {RTE_PCI_DEVICE(ZXDH_PCI_VENDOR_ID, ZXDH_E312S_VF_DEVICEID)},
2128 : : {RTE_PCI_DEVICE(ZXDH_PCI_VENDOR_ID, ZXDH_E316_PF_DEVICEID)},
2129 : : {RTE_PCI_DEVICE(ZXDH_PCI_VENDOR_ID, ZXDH_E316_VF_DEVICEID)},
2130 : : {RTE_PCI_DEVICE(ZXDH_PCI_VENDOR_ID, ZXDH_E310_RDMA_PF_DEVICEID)},
2131 : : {RTE_PCI_DEVICE(ZXDH_PCI_VENDOR_ID, ZXDH_E310_RDMA_VF_DEVICEID)},
2132 : : {RTE_PCI_DEVICE(ZXDH_PCI_VENDOR_ID, ZXDH_E312_RDMA_PF_DEVICEID)},
2133 : : {RTE_PCI_DEVICE(ZXDH_PCI_VENDOR_ID, ZXDH_E312_RDMA_VF_DEVICEID)},
2134 : : {.vendor_id = 0, /* sentinel */ },
2135 : : };
2136 : : static struct rte_pci_driver zxdh_pmd = {
2137 : : .id_table = pci_id_zxdh_map,
2138 : : .drv_flags = RTE_PCI_DRV_NEED_MAPPING | RTE_PCI_DRV_INTR_LSC,
2139 : : .probe = zxdh_eth_pci_probe,
2140 : : .remove = zxdh_eth_pci_remove,
2141 : : };
2142 : :
2143 : 253 : RTE_PMD_REGISTER_PCI(net_zxdh, zxdh_pmd);
2144 : : RTE_PMD_REGISTER_PCI_TABLE(net_zxdh, pci_id_zxdh_map);
2145 : : RTE_PMD_REGISTER_KMOD_DEP(net_zxdh, "* vfio-pci");
2146 [ - + ]: 253 : RTE_LOG_REGISTER_SUFFIX(zxdh_logtype_driver, driver, NOTICE);
2147 [ - + ]: 253 : RTE_LOG_REGISTER_SUFFIX(zxdh_logtype_rx, rx, NOTICE);
2148 [ - + ]: 253 : RTE_LOG_REGISTER_SUFFIX(zxdh_logtype_tx, tx, NOTICE);
2149 [ - + ]: 253 : RTE_LOG_REGISTER_SUFFIX(zxdh_logtype_msg, msg, NOTICE);
|
