Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright (C), 2025, Wuxi Stars Micro System Technologies Co., Ltd.
3 : : */
4 : :
5 : : #include <rte_string_fns.h>
6 : : #include <ethdev_pci.h>
7 : : #include <ctype.h>
8 : : #include <sys/types.h>
9 : : #include <sys/stat.h>
10 : : #include <unistd.h>
11 : : #include <rte_tailq.h>
12 : : #include <rte_version.h>
13 : : #include <bus_pci_driver.h>
14 : : #include <dev_driver.h>
15 : : #include <ethdev_driver.h>
16 : : #include <rte_ethdev.h>
17 : : #include <rte_alarm.h>
18 : : #include <rte_dev_info.h>
19 : : #include <rte_pci.h>
20 : : #include <rte_mbuf_dyn.h>
21 : : #include <rte_cycles.h>
22 : : #include <rte_eal_paging.h>
23 : :
24 : : #include "sxe2_ethdev.h"
25 : : #include "sxe2_irq.h"
26 : : #include "sxe2_drv_cmd.h"
27 : : #include "sxe2_cmd_chnl.h"
28 : : #include "sxe2_tx.h"
29 : : #include "sxe2_rx.h"
30 : : #include "sxe2_txrx.h"
31 : : #include "sxe2_mac.h"
32 : : #include "sxe2_common.h"
33 : : #include "sxe2_common_log.h"
34 : : #include "sxe2_mp.h"
35 : : #include "sxe2_flow.h"
36 : : #include "sxe2_stats.h"
37 : : #include "sxe2_host_regs.h"
38 : : #include "sxe2_switchdev.h"
39 : : #include "sxe2_ioctl_chnl_func.h"
40 : : #include "sxe2_dump.h"
41 : : #include "sxe2_ethdev_repr.h"
42 : : #include "sxe2vf_regs.h"
43 : : #include "sxe2_msg.h"
44 : :
45 : : #define SXE2_PCI_VENDOR_ID_1 0x1ff2
46 : : #define SXE2_PCI_DEVICE_ID_PF_1 0x10b1
47 : : #define SXE2_PCI_DEVICE_ID_VF_1 0x10b2
48 : :
49 : : #define SXE2_PCI_VENDOR_ID_2 0x1d94
50 : : #define SXE2_PCI_DEVICE_ID_PF_2 0x1260
51 : : #define SXE2_PCI_DEVICE_ID_VF_2 0x126f
52 : :
53 : : #define SXE2_PCI_DEVICE_ID_PF_3 0x10b3
54 : : #define SXE2_PCI_DEVICE_ID_VF_3 0x10b4
55 : :
56 : : #define SXE2_PCI_VENDOR_ID_206F 0x206f
57 : :
58 : : static const struct rte_pci_id pci_id_sxe2_tbl[] = {
59 : : { RTE_PCI_DEVICE(SXE2_PCI_VENDOR_ID_1, SXE2_PCI_DEVICE_ID_PF_1)},
60 : : { RTE_PCI_DEVICE(SXE2_PCI_VENDOR_ID_1, SXE2_PCI_DEVICE_ID_VF_1)},
61 : : { RTE_PCI_DEVICE(SXE2_PCI_VENDOR_ID_2, SXE2_PCI_DEVICE_ID_PF_2)},
62 : : { RTE_PCI_DEVICE(SXE2_PCI_VENDOR_ID_2, SXE2_PCI_DEVICE_ID_VF_2)},
63 : : { RTE_PCI_DEVICE(SXE2_PCI_VENDOR_ID_1, SXE2_PCI_DEVICE_ID_PF_3)},
64 : : { RTE_PCI_DEVICE(SXE2_PCI_VENDOR_ID_1, SXE2_PCI_DEVICE_ID_VF_3)},
65 : : { RTE_PCI_DEVICE(SXE2_PCI_VENDOR_ID_206F, SXE2_PCI_DEVICE_ID_PF_1)},
66 : : { RTE_PCI_DEVICE(SXE2_PCI_VENDOR_ID_206F, SXE2_PCI_DEVICE_ID_VF_1)},
67 : : { .vendor_id = 0, },
68 : : };
69 : :
70 : : #define SXE2_TXSCH_NODE_ADJ_LVL_MAX 3
71 : :
72 : : #define SXE2_DEVARG_FLOW_DUP_PATTERN_MODE "flow-duplicate-pattern"
73 : : #define SXE2_DEVARG_FUNC_FLOW_DIRCT "function-flow-direct"
74 : : #define SXE2_DEVARG_FNAV_STAT_TYPE "fnav-stat-type"
75 : : #define SXE2_DEVARG_ACL_STAT_TYPE "acl-stat-type"
76 : : #define SXE2_DEVARG_NO_SCHED_MODE "no-sched-mode"
77 : : #define SXE2_DEVARG_SCHED_LAYER_MODE "sched-layer-mode"
78 : : #define SXE2_DEVARG_RX_LOW_LATENCY "rx-low-latency"
79 : :
80 : : static struct sxe2_pci_map_addr_info sxe2_net_map_addr_info_pf[SXE2_PCI_MAP_RES_MAX_COUNT] = {
81 : : [SXE2_PCI_MAP_RES_INVALID] = {.addr_base = 0,
82 : : .bar_idx = 0,
83 : : .reg_width = 0},
84 : : [SXE2_PCI_MAP_RES_DOORBELL_TX] = {.addr_base = SXE2_TXQ_LEGACY_DBLL(0),
85 : : .bar_idx = 0,
86 : : .reg_width = 4},
87 : : [SXE2_PCI_MAP_RES_DOORBELL_RX_TAIL] = {.addr_base = SXE2_RXQ_TAIL(0),
88 : : .bar_idx = 0,
89 : : .reg_width = 4},
90 : : [SXE2_PCI_MAP_RES_IRQ_DYN] = {.addr_base = SXE2_VF_DYN_CTL(0),
91 : : .bar_idx = 0,
92 : : .reg_width = 4},
93 : : [SXE2_PCI_MAP_RES_IRQ_ITR] = {.addr_base = SXE2_VF_INT_ITR(0, 0),
94 : : .bar_idx = 0,
95 : : .reg_width = 4},
96 : : [SXE2_PCI_MAP_RES_IRQ_MSIX] = {.addr_base = SXE2_BAR4_MSIX_CTL(0),
97 : : .bar_idx = 4,
98 : : .reg_width = 0x10},
99 : : };
100 : :
101 : : static struct sxe2_pci_map_addr_info sxe2_net_map_addr_info_vf[SXE2_PCI_MAP_RES_MAX_COUNT] = {
102 : : [SXE2_PCI_MAP_RES_INVALID] = {.addr_base = 0,
103 : : .bar_idx = 0,
104 : : .reg_width = 0},
105 : : [SXE2_PCI_MAP_RES_DOORBELL_TX] = {.addr_base = SXE2VF_TXQ_TAIL(0),
106 : : .bar_idx = 0,
107 : : .reg_width = 4},
108 : : [SXE2_PCI_MAP_RES_DOORBELL_RX_TAIL] = {.addr_base = SXE2VF_RXQ_TAIL(0),
109 : : .bar_idx = 0,
110 : : .reg_width = 4},
111 : : [SXE2_PCI_MAP_RES_IRQ_DYN] = {.addr_base = SXE2VF_VF_DYN_CTL(0),
112 : : .bar_idx = 0,
113 : : .reg_width = 4},
114 : : [SXE2_PCI_MAP_RES_IRQ_ITR] = {.addr_base = SXE2VF_VF_INT_ITR(0, 0),
115 : : .bar_idx = 0,
116 : : .reg_width = 4},
117 : : [SXE2_PCI_MAP_RES_IRQ_MSIX] = {.addr_base = SXE2VF_BAR4_MSIX_CTL(0),
118 : : .bar_idx = 4,
119 : : .reg_width = 0x10},
120 : : };
121 : :
122 : : static int32_t sxe2_dev_configure(struct rte_eth_dev *dev);
123 : : static int32_t sxe2_dev_start(struct rte_eth_dev *dev);
124 : : static int32_t sxe2_dev_stop(struct rte_eth_dev *dev);
125 : : static int32_t sxe2_dev_close(struct rte_eth_dev *dev);
126 : : static int32_t sxe2_dev_infos_get(struct rte_eth_dev *dev, struct rte_eth_dev_info *dev_info);
127 : : static const uint32_t *sxe2_buffer_split_supported_hdr_ptypes_get(struct rte_eth_dev *dev
128 : : __rte_unused, size_t *no_of_elements __rte_unused);
129 : : static int32_t sxe2_udp_tunnel_port_add(struct rte_eth_dev *dev,
130 : : struct rte_eth_udp_tunnel *tunnel_udp);
131 : : static int32_t sxe2_udp_tunnel_port_del(struct rte_eth_dev *dev,
132 : : struct rte_eth_udp_tunnel *tunnel_udp);
133 : : static int32_t sxe2_fw_version_string_get(struct rte_eth_dev *dev,
134 : : char *fw_version, size_t fw_size);
135 : : static int32_t sxe2_get_module_info(struct rte_eth_dev *dev,
136 : : struct rte_eth_dev_module_info *info);
137 : : static int32_t sxe2_get_module_eeprom(struct rte_eth_dev *dev,
138 : : struct rte_dev_eeprom_info *info);
139 : :
140 : : static const struct eth_dev_ops sxe2_eth_dev_ops = {
141 : : .dev_configure = sxe2_dev_configure,
142 : : .dev_start = sxe2_dev_start,
143 : : .dev_stop = sxe2_dev_stop,
144 : : .dev_close = sxe2_dev_close,
145 : : .dev_infos_get = sxe2_dev_infos_get,
146 : : .dev_supported_ptypes_get = sxe2_dev_supported_ptypes_get,
147 : : .link_update = sxe2_link_update,
148 : :
149 : : .rx_queue_start = sxe2_rx_queue_start,
150 : : .rx_queue_stop = sxe2_rx_queue_stop,
151 : : .tx_queue_start = sxe2_tx_queue_start,
152 : : .tx_queue_stop = sxe2_tx_queue_stop,
153 : : .rx_queue_setup = sxe2_rx_queue_setup,
154 : : .rx_queue_release = sxe2_rx_queue_release,
155 : : .tx_queue_setup = sxe2_tx_queue_setup,
156 : : .tx_queue_release = sxe2_tx_queue_release,
157 : : .rx_queue_intr_enable = sxe2_rx_queue_intr_enable,
158 : : .rx_queue_intr_disable = sxe2_rx_queue_intr_disable,
159 : :
160 : : .rxq_info_get = sxe2_rx_queue_info_get,
161 : : .txq_info_get = sxe2_tx_queue_info_get,
162 : : .rx_burst_mode_get = sxe2_rx_burst_mode_get,
163 : : .tx_burst_mode_get = sxe2_tx_burst_mode_get,
164 : : .tx_done_cleanup = sxe2_tx_done_cleanup,
165 : :
166 : : .promiscuous_enable = sxe2_promisc_enable,
167 : : .promiscuous_disable = sxe2_promisc_disable,
168 : : .allmulticast_enable = sxe2_allmulti_enable,
169 : : .allmulticast_disable = sxe2_allmulti_disable,
170 : :
171 : : .mac_addr_add = sxe2_mac_addr_add,
172 : : .mac_addr_remove = sxe2_mac_addr_del,
173 : : .mac_addr_set = sxe2_mac_addr_set,
174 : : .set_mc_addr_list = sxe2_set_mc_addr_list,
175 : : .mtu_set = sxe2_mtu_set,
176 : : .buffer_split_supported_hdr_ptypes_get = sxe2_buffer_split_supported_hdr_ptypes_get,
177 : :
178 : : .vlan_filter_set = sxe2_dev_vlan_filter_set,
179 : : .vlan_offload_set = sxe2_dev_vlan_offload_set,
180 : :
181 : : .reta_update = sxe2_dev_rss_reta_update,
182 : : .reta_query = sxe2_dev_rss_reta_query,
183 : : .rss_hash_update = sxe2_dev_rss_hash_update,
184 : : .rss_hash_conf_get = sxe2_dev_rss_hash_conf_get,
185 : :
186 : : .udp_tunnel_port_add = sxe2_udp_tunnel_port_add,
187 : : .udp_tunnel_port_del = sxe2_udp_tunnel_port_del,
188 : :
189 : : .flow_ops_get = sxe2_flow_ops_get,
190 : : .tm_ops_get = sxe2_tm_ops_get,
191 : :
192 : : .stats_get = sxe2_stats_info_get,
193 : : .stats_reset = sxe2_stats_info_reset,
194 : : .xstats_get = sxe2_xstats_info_get,
195 : : .xstats_get_names = sxe2_xstats_names_get,
196 : : .xstats_reset = sxe2_stats_info_reset,
197 : :
198 : : .fw_version_get = sxe2_fw_version_string_get,
199 : :
200 : : .get_monitor_addr = sxe2_get_monitor_addr,
201 : :
202 : : .get_module_info = sxe2_get_module_info,
203 : : .get_module_eeprom = sxe2_get_module_eeprom,
204 : :
205 : : .eth_dev_priv_dump = sxe2_eth_dev_priv_dump,
206 : : };
207 : :
208 : 0 : static int32_t sxe2_dev_configure(struct rte_eth_dev *dev)
209 : : {
210 : 0 : int32_t ret = 0;
211 : 0 : PMD_INIT_FUNC_TRACE();
212 : :
213 [ # # ]: 0 : if (dev->data->dev_conf.rxmode.mq_mode & RTE_ETH_MQ_RX_RSS_FLAG)
214 : 0 : dev->data->dev_conf.rxmode.offloads |= RTE_ETH_RX_OFFLOAD_RSS_HASH;
215 : :
216 : 0 : ret = sxe2_vlan_default_cfg(dev);
217 [ # # ]: 0 : if (ret) {
218 : 0 : PMD_LOG_ERR(INIT, "Failed to init vlan, ret=%d", ret);
219 : 0 : goto end;
220 : : }
221 : :
222 : 0 : ret = sxe2_rss_init(dev);
223 [ # # ]: 0 : if (ret) {
224 : 0 : PMD_LOG_ERR(INIT, "Failed to init rss, ret=%d", ret);
225 : 0 : goto end;
226 : : }
227 : :
228 : 0 : end:
229 : 0 : return ret;
230 : : }
231 : :
232 : 0 : static int32_t sxe2_dev_stop(struct rte_eth_dev *dev)
233 : : {
234 : 0 : int32_t ret = 0;
235 : 0 : struct sxe2_adapter *adapter = SXE2_DEV_PRIVATE_TO_ADAPTER(dev);
236 : 0 : PMD_INIT_FUNC_TRACE();
237 : :
238 [ # # ]: 0 : if (adapter->started == 0)
239 : 0 : goto l_end;
240 : :
241 : 0 : sxe2_rxq_intr_disable(dev);
242 : :
243 : 0 : sxe2_txqs_all_stop(dev);
244 : 0 : sxe2_rxqs_all_stop(dev);
245 : :
246 : 0 : (void)sxe2_filter_rule_stop(dev);
247 : :
248 : 0 : dev->data->dev_started = 0;
249 : 0 : adapter->started = 0;
250 : 0 : l_end:
251 : 0 : return ret;
252 : : }
253 : :
254 : 0 : static int32_t sxe2_dev_start(struct rte_eth_dev *dev)
255 : : {
256 : 0 : int32_t ret = 0;
257 : 0 : struct sxe2_adapter *adapter = SXE2_DEV_PRIVATE_TO_ADAPTER(dev);
258 : 0 : PMD_INIT_FUNC_TRACE();
259 : :
260 : 0 : ret = sxe2_flow_init_udp_tunnel_port(dev);
261 [ # # ]: 0 : if (ret) {
262 : 0 : PMD_LOG_ERR(DRV, "Failed to init udp tunnel port, ret: %d.", ret);
263 : 0 : goto l_end;
264 : : }
265 : :
266 : 0 : ret = sxe2_queues_init(dev);
267 [ # # ]: 0 : if (ret) {
268 : 0 : PMD_LOG_ERR(INIT, "Failed to init queues.");
269 : 0 : goto l_end;
270 : : }
271 : :
272 : 0 : sxe2_rx_mode_func_set(dev);
273 : 0 : sxe2_tx_mode_func_set(dev);
274 : :
275 : 0 : ret = sxe2_link_update_init(dev);
276 [ # # ]: 0 : if (ret) {
277 : 0 : PMD_LOG_ERR(INIT, "Failed to initialize link update, ret:%d", ret);
278 : 0 : goto l_end;
279 : : }
280 : :
281 : 0 : ret = sxe2_filter_rule_start(dev);
282 [ # # ]: 0 : if (ret) {
283 : 0 : PMD_LOG_ERR(INIT, "Failed to add all mc addr to fw.");
284 : 0 : goto l_end;
285 : : }
286 : :
287 : 0 : ret = sxe2_rxq_intr_enable(dev);
288 [ # # ]: 0 : if (ret) {
289 : 0 : PMD_LOG_ERR(INIT, "Failed to enable rx queue intr");
290 : 0 : goto l_rxq_intr_err;
291 : : }
292 : :
293 : 0 : ret = sxe2_queues_start(dev);
294 [ # # ]: 0 : if (ret) {
295 : 0 : PMD_LOG_ERR(INIT, "enable queues failed");
296 : 0 : goto l_start_queues_err;
297 : : }
298 : :
299 : 0 : dev->data->dev_started = 1;
300 : 0 : adapter->started = 1;
301 : 0 : goto l_end;
302 : :
303 : 0 : l_start_queues_err:
304 : 0 : (void)sxe2_rxq_intr_disable(dev);
305 : 0 : l_rxq_intr_err:
306 : 0 : (void)sxe2_filter_rule_stop(dev);
307 : 0 : l_end:
308 : 0 : return ret;
309 : : }
310 : :
311 : 0 : static int32_t sxe2_sfp_type_get(struct sxe2_adapter *adapter, uint8_t *type)
312 : : {
313 : 0 : int32_t ret = -1;
314 : 0 : struct sxe2_sfp_read_info sfp_info;
315 : :
316 : 0 : memset(&sfp_info, 0, sizeof(sfp_info));
317 : 0 : sfp_info.bus_addr = SXE2_SFP_E2P_I2C_7BIT_ADDR0;
318 : 0 : sfp_info.len = 1;
319 : 0 : sfp_info.data = type;
320 : 0 : sfp_info.offset = 0;
321 : 0 : sfp_info.page_cnt = 0;
322 : 0 : sfp_info.is_qsfp = false;
323 : :
324 : 0 : ret = sxe2_drv_sfp_eeprom_read(adapter, &sfp_info);
325 [ # # ]: 0 : if (ret)
326 : 0 : goto l_end;
327 : :
328 : 0 : ret = 0;
329 : 0 : PMD_LOG_INFO(DRV, "Get sfp type success, type=%u", *type);
330 : :
331 : 0 : l_end:
332 : 0 : return ret;
333 : : }
334 : :
335 : 0 : static int32_t sxe2_sfp_module_info_get(struct sxe2_adapter *adapter,
336 : : struct rte_eth_dev_module_info *info)
337 : : {
338 : 0 : int32_t ret = -1;
339 : 0 : bool page_swap = false;
340 : 0 : uint8_t sff8472_rev = 0;
341 : 0 : uint8_t addr_mode = 0;
342 : 0 : struct sxe2_sfp_read_info sfp_info;
343 : :
344 : 0 : memset(&sfp_info, 0, sizeof(sfp_info));
345 : 0 : sfp_info.bus_addr = SXE2_SFP_E2P_I2C_7BIT_ADDR0;
346 : 0 : sfp_info.is_qsfp = false;
347 : 0 : sfp_info.len = 1;
348 : 0 : sfp_info.data = &sff8472_rev;
349 : 0 : sfp_info.offset = SXE2_MODULE_SFF_8472_COMP;
350 : 0 : sfp_info.page_cnt = 0;
351 : :
352 : 0 : ret = sxe2_drv_sfp_eeprom_read(adapter, &sfp_info);
353 [ # # ]: 0 : if (ret) {
354 : 0 : ret = -EIO;
355 : 0 : PMD_LOG_ERR(DRV, "Failed to read 8472 protocol, ret=%d", ret);
356 : 0 : goto l_end;
357 : : }
358 : :
359 : 0 : sfp_info.data = &addr_mode;
360 : 0 : sfp_info.offset = SXE2_MODULE_SFF_8472_SWAP;
361 : :
362 : 0 : ret = sxe2_drv_sfp_eeprom_read(adapter, &sfp_info);
363 [ # # ]: 0 : if (ret) {
364 : 0 : ret = -EIO;
365 : 0 : PMD_LOG_ERR(DRV, "Failed to read A2 page, ret=%d", ret);
366 : 0 : goto l_end;
367 : : }
368 : :
369 [ # # ]: 0 : if (addr_mode & SXE2_MODULE_SFF_ADDR_MODE) {
370 : 0 : PMD_LOG_ERR(DRV, "address change required to access page 0xA2, "
371 : : "but not supported. please report the module "
372 : : "type to the driver maintainers.");
373 : 0 : page_swap = true;
374 : : }
375 : :
376 : 0 : PMD_LOG_INFO(DRV, "Read sfp module info, sff_8472=%u, a2_page=%u, swap_page=%d",
377 : : sff8472_rev, addr_mode, page_swap);
378 : :
379 [ # # # # ]: 0 : if (sff8472_rev == SXE2_MODULE_SFF_8472_UNSUP ||
380 : 0 : page_swap ||
381 [ # # ]: 0 : !(addr_mode & SXE2_MODULE_SFF_DDM_IMPLEMENTED)) {
382 : 0 : info->type = SXE2_MODULE_SFF_8079;
383 : 0 : info->eeprom_len = SXE2_MODULE_SFF_8079_LEN;
384 : : } else {
385 : 0 : info->type = SXE2_MODULE_SFF_8472;
386 : 0 : info->eeprom_len = SXE2_MODULE_SFF_8472_LEN;
387 : : }
388 : :
389 : : ret = 0;
390 : :
391 : 0 : l_end:
392 : 0 : return ret;
393 : : }
394 : :
395 : : static int32_t
396 : 0 : sxe2_qsfp_module_info_get(struct sxe2_adapter *adapter, struct rte_eth_dev_module_info *info)
397 : : {
398 : 0 : int32_t ret = -1;
399 : 0 : uint8_t sff8636_rev = 0;
400 : 0 : struct sxe2_sfp_read_info sfp_info;
401 : :
402 : 0 : memset(&sfp_info, 0, sizeof(sfp_info));
403 : 0 : sfp_info.bus_addr = SXE2_SFP_E2P_I2C_7BIT_ADDR0;
404 : 0 : sfp_info.is_qsfp = true;
405 : 0 : sfp_info.len = 1;
406 : 0 : sfp_info.data = &sff8636_rev;
407 : 0 : sfp_info.offset = SXE2_MODULE_REVISION_ADDR;
408 : 0 : sfp_info.page_cnt = 0;
409 : :
410 : 0 : ret = sxe2_drv_sfp_eeprom_read(adapter, &sfp_info);
411 [ # # ]: 0 : if (ret) {
412 : 0 : ret = -EIO;
413 : 0 : PMD_LOG_ERR(DRV, "Failed to read 8636 protocol, ret=%d", ret);
414 : 0 : goto l_end;
415 : : }
416 : :
417 [ # # ]: 0 : if (sff8636_rev > 0x02) {
418 : 0 : info->type = SXE2_MODULE_SFF_8636;
419 : 0 : info->eeprom_len = SXE2_MODULE_SFF_8636_MAX_LEN;
420 : : } else {
421 : 0 : info->type = SXE2_MODULE_SFF_8436;
422 : 0 : info->eeprom_len = SXE2_MODULE_SFF_8436_MAX_LEN;
423 : : }
424 : :
425 : 0 : l_end:
426 : 0 : return ret;
427 : : }
428 : :
429 : : static int32_t
430 : 0 : sxe2_get_module_info(struct rte_eth_dev *dev, struct rte_eth_dev_module_info *info)
431 : : {
432 : 0 : int32_t ret = -1;
433 : 0 : uint8_t type = 0;
434 : 0 : struct sxe2_adapter *adapter = dev->data->dev_private;
435 : :
436 : 0 : ret = sxe2_sfp_type_get(adapter, &type);
437 [ # # ]: 0 : if (ret) {
438 : 0 : ret = -EIO;
439 : 0 : PMD_LOG_ERR(DRV, "Failed to read sfp type, ret=%d", ret);
440 : 0 : goto l_end;
441 : : }
442 : :
443 [ # # # ]: 0 : switch (type) {
444 : 0 : case SXE2_MODULE_SFF_SFP_TYPE:
445 : 0 : ret = sxe2_sfp_module_info_get(adapter, info);
446 [ # # ]: 0 : if (ret)
447 : 0 : goto l_end;
448 : : break;
449 : 0 : case SXE2_MODULE_TYPE_QSFP_PLUS:
450 : : case SXE2_MODULE_TYPE_QSFP28:
451 : 0 : ret = sxe2_qsfp_module_info_get(adapter, info);
452 [ # # ]: 0 : if (ret)
453 : 0 : goto l_end;
454 : : break;
455 : 0 : default:
456 : 0 : ret = -ENXIO;
457 : 0 : PMD_LOG_ERR(DRV, "Invalid sfp type, type=%d.", type);
458 : 0 : goto l_end;
459 : : }
460 : :
461 : 0 : PMD_LOG_INFO(DRV, "sfp eeprom type=%x, eeprom len=%d.", info->type, info->eeprom_len);
462 : :
463 : 0 : l_end:
464 : 0 : return ret;
465 : : }
466 : :
467 : : static int32_t
468 : 0 : sxe2_get_sfp_eeprom(struct sxe2_adapter *adapter, struct sxe2_sfp_read_info *sfp_info)
469 : : {
470 : 0 : int32_t ret = -1;
471 : 0 : uint16_t ori_len = sfp_info->len;
472 : 0 : uint16_t ori_offset = sfp_info->offset;
473 : :
474 [ # # ]: 0 : if ((ori_len + ori_offset) > SXE2_SFP_EEP_LEN_MAX) {
475 : 0 : sfp_info->len = (uint16_t)(SXE2_SFP_EEP_LEN_MAX - ori_offset);
476 : 0 : ret = sxe2_drv_sfp_eeprom_read(adapter, sfp_info);
477 [ # # ]: 0 : if (ret)
478 : 0 : goto l_end;
479 : 0 : sfp_info->bus_addr = SXE2_SFP_E2P_I2C_7BIT_ADDR1;
480 : 0 : sfp_info->len = (uint16_t)(ori_len - (SXE2_SFP_EEP_LEN_MAX - ori_offset));
481 : 0 : sfp_info->data = (uint8_t *)(sfp_info->data) + (SXE2_SFP_EEP_LEN_MAX - ori_offset);
482 : 0 : sfp_info->offset = 0;
483 : 0 : sfp_info->page_cnt = 0;
484 : 0 : ret = sxe2_drv_sfp_eeprom_read(adapter, sfp_info);
485 : : } else {
486 : 0 : ret = sxe2_drv_sfp_eeprom_read(adapter, sfp_info);
487 : : }
488 : :
489 : 0 : l_end:
490 [ # # ]: 0 : if (ret)
491 : 0 : PMD_LOG_ERR(DRV, "Failed to read sfp.");
492 : 0 : return ret;
493 : : }
494 : :
495 : : static int32_t
496 : 0 : sxe2_get_qsfp_eeprom(struct sxe2_adapter *adapter,
497 : : struct sxe2_sfp_read_info *sfp_info)
498 : : {
499 : 0 : int32_t ret = -1;
500 : 0 : uint16_t ori_len = sfp_info->len;
501 : 0 : uint16_t ori_offset = sfp_info->offset;
502 : 0 : uint16_t read_len = 0;
503 : 0 : uint16_t remain_len = 0;
504 : :
505 [ # # ]: 0 : if ((ori_len + ori_offset) > SXE2_SFP_EEP_LEN_MAX) {
506 : 0 : sfp_info->len = (uint16_t)(SXE2_SFP_EEP_LEN_MAX - ori_offset);
507 : 0 : ret = sxe2_drv_sfp_eeprom_read(adapter, sfp_info);
508 [ # # ]: 0 : if (ret)
509 : 0 : goto l_end;
510 : :
511 : 0 : do {
512 : 0 : read_len = read_len + sfp_info->len;
513 : 0 : sfp_info->data = (uint8_t *)(sfp_info->data) + sfp_info->len;
514 : 0 : sfp_info->offset = SXE2_QSFP_PAGE_OFST_START;
515 : 0 : sfp_info->page_cnt++;
516 : 0 : remain_len = (uint16_t)(ori_len - read_len);
517 : 0 : sfp_info->len = (remain_len > SXE2_QSFP_PAGE_OFST_START) ?
518 : 0 : SXE2_QSFP_PAGE_OFST_START : remain_len;
519 : 0 : ret = sxe2_drv_sfp_eeprom_read(adapter, sfp_info);
520 [ # # ]: 0 : if (ret)
521 : 0 : goto l_end;
522 [ # # ]: 0 : } while (remain_len > SXE2_QSFP_PAGE_OFST_START);
523 : : } else {
524 : 0 : ret = sxe2_drv_sfp_eeprom_read(adapter, sfp_info);
525 : : }
526 : :
527 : 0 : l_end:
528 [ # # ]: 0 : if (ret)
529 : 0 : PMD_LOG_ERR(DRV, "Failed to read sfp.");
530 : 0 : return ret;
531 : : }
532 : :
533 : : static int32_t
534 : 0 : sxe2_get_module_eeprom(struct rte_eth_dev *dev, struct rte_dev_eeprom_info *info)
535 : : {
536 : 0 : int32_t ret = -1;
537 : 0 : uint8_t type = 0;
538 : 0 : struct sxe2_adapter *adapter = dev->data->dev_private;
539 : 0 : struct sxe2_sfp_read_info sfp_info;
540 : :
541 [ # # ]: 0 : memset(&sfp_info, 0, sizeof(sfp_info));
542 : :
543 [ # # # # : 0 : if (!info || !info->length || !info->data ||
# # ]
544 [ # # ]: 0 : info->offset >= SXE2_SFP_EEP_LEN_MAX) {
545 : 0 : ret = -EINVAL;
546 : 0 : goto l_end;
547 : : }
548 : :
549 : 0 : PMD_LOG_INFO(DRV, "Dump sfp eeprom info offset=0x%x, len=0x%x.",
550 : : info->offset, info->length);
551 : :
552 : 0 : ret = sxe2_sfp_type_get(adapter, &type);
553 [ # # ]: 0 : if (ret) {
554 : 0 : ret = -EIO;
555 : 0 : PMD_LOG_ERR(DRV, "Failed to read sfp type, ret=%d", ret);
556 : 0 : goto l_end;
557 : : }
558 : :
559 : 0 : sfp_info.bus_addr = SXE2_SFP_E2P_I2C_7BIT_ADDR0;
560 : 0 : sfp_info.len = info->length;
561 : 0 : sfp_info.data = info->data;
562 : 0 : sfp_info.offset = info->offset;
563 : 0 : sfp_info.page_cnt = 0;
564 : :
565 [ # # # ]: 0 : switch (type) {
566 : 0 : case SXE2_MODULE_SFF_SFP_TYPE:
567 [ # # ]: 0 : if (info->length > SXE2_SFP_EEP_LEN_MAX * 2) {
568 : 0 : ret = -EINVAL;
569 : 0 : PMD_LOG_ERR(DRV, "sfp read size[%u] > eeprom max size[%d], ret=%d",
570 : : info->length, SXE2_SFP_EEP_LEN_MAX * 2, ret);
571 : 0 : goto l_end;
572 : : }
573 : 0 : sfp_info.is_qsfp = false;
574 : 0 : ret = sxe2_get_sfp_eeprom(adapter, &sfp_info);
575 [ # # ]: 0 : if (ret)
576 : 0 : goto l_end;
577 : : break;
578 : 0 : case SXE2_MODULE_TYPE_QSFP_PLUS:
579 : : case SXE2_MODULE_TYPE_QSFP28:
580 [ # # ]: 0 : if (info->length > SXE2_MODULE_SFF_8636_MAX_LEN) {
581 : 0 : ret = -EINVAL;
582 : 0 : PMD_LOG_ERR(DRV, "sfp read size[%u] > eeprom max size[%d], ret=%d",
583 : : info->length, SXE2_SFP_EEP_LEN_MAX * 2, ret);
584 : 0 : goto l_end;
585 : : }
586 : 0 : sfp_info.is_qsfp = true;
587 : 0 : ret = sxe2_get_qsfp_eeprom(adapter, &sfp_info);
588 [ # # ]: 0 : if (ret)
589 : 0 : goto l_end;
590 : : break;
591 : 0 : default:
592 : 0 : ret = -ENXIO;
593 : 0 : PMD_LOG_ERR(DRV, "Invalid sfp type, type=%d.", type);
594 : 0 : goto l_end;
595 : : }
596 : :
597 : 0 : l_end:
598 : 0 : return ret;
599 : : }
600 : :
601 : : static enum sxe2_udp_tunnel_protocol
602 : 0 : sxe2_udp_tunnel_type_rte_to_sxe2(enum rte_eth_tunnel_type rte_type)
603 : : {
604 : 0 : static enum sxe2_udp_tunnel_protocol sxe2_udp_proto_map[RTE_ETH_TUNNEL_TYPE_MAX] = {
605 : : [RTE_ETH_TUNNEL_TYPE_NONE] = SXE2_UDP_TUNNEL_MAX,
606 : : [RTE_ETH_TUNNEL_TYPE_VXLAN] = SXE2_UDP_TUNNEL_PROTOCOL_VXLAN,
607 : : [RTE_ETH_TUNNEL_TYPE_GENEVE] = SXE2_UDP_TUNNEL_PROTOCOL_GENEVE,
608 : : [RTE_ETH_TUNNEL_TYPE_TEREDO] = SXE2_UDP_TUNNEL_PROTOCOL_TEREDO,
609 : : [RTE_ETH_TUNNEL_TYPE_NVGRE] = SXE2_UDP_TUNNEL_PROTOCOL_NVGRE,
610 : : [RTE_ETH_TUNNEL_TYPE_IP_IN_GRE] = SXE2_UDP_TUNNEL_MAX,
611 : : [RTE_ETH_L2_TUNNEL_TYPE_E_TAG] = SXE2_UDP_TUNNEL_MAX,
612 : : [RTE_ETH_TUNNEL_TYPE_VXLAN_GPE] = SXE2_UDP_TUNNEL_PROTOCOL_VXLAN_GPE,
613 : : [RTE_ETH_TUNNEL_TYPE_ECPRI] = SXE2_UDP_TUNNEL_PROTOCOL_ECPRI
614 : : };
615 : :
616 [ # # ]: 0 : if (rte_type >= RTE_ETH_TUNNEL_TYPE_MAX) {
617 : 0 : PMD_LOG_ERR(DRV, "Invalid rte_eth_tunnel_type %d!", rte_type);
618 : 0 : rte_type = RTE_ETH_TUNNEL_TYPE_NONE;
619 : : }
620 : :
621 : 0 : return sxe2_udp_proto_map[rte_type];
622 : : }
623 : :
624 : 0 : int32_t sxe2_udp_tunnel_port_add_common(struct sxe2_adapter *ad,
625 : : enum sxe2_udp_tunnel_protocol tunnel_proto,
626 : : uint16_t udp_port)
627 : : {
628 : 0 : struct sxe2_udp_tunnel_cfg *tunnel_config;
629 : 0 : int32_t ret = -1;
630 : :
631 [ # # # # ]: 0 : if (ad->dev_type != SXE2_DEV_T_PF || ad->is_dev_repr) {
632 : 0 : ret = -ENOTSUP;
633 : 0 : goto l_end;
634 : : }
635 : 0 : rte_spinlock_lock(&ad->udp_tunnel_ctx.lock);
636 : :
637 : 0 : tunnel_config = &ad->udp_tunnel_ctx.tunnel_conf[tunnel_proto];
638 : :
639 [ # # ]: 0 : if (tunnel_config->dev_status == SXE2_UDP_TUNNEL_ENABLE) {
640 [ # # ]: 0 : if (udp_port == tunnel_config->dev_port &&
641 [ # # ]: 0 : tunnel_config->dev_ref_cnt < 0xFFFFU) {
642 : 0 : tunnel_config->dev_ref_cnt++;
643 : 0 : ret = 0;
644 : 0 : goto l_unlock_end;
645 : : } else {
646 : 0 : PMD_LOG_ERR(DRV, "Adding multiple ports to the same protocol "
647 : : "is not supported!");
648 : 0 : ret = -EINVAL;
649 : 0 : goto l_unlock_end;
650 : : }
651 : : } else {
652 : 0 : ret = sxe2_drv_udp_tunnel_add(ad, tunnel_proto, udp_port);
653 [ # # ]: 0 : if (ret != 0)
654 : 0 : goto l_unlock_end;
655 : :
656 : 0 : tunnel_config->protocol = tunnel_proto;
657 : 0 : tunnel_config->dev_port = udp_port;
658 : 0 : tunnel_config->dev_status = SXE2_UDP_TUNNEL_ENABLE;
659 : 0 : tunnel_config->dev_ref_cnt++;
660 : : }
661 : :
662 : 0 : l_unlock_end:
663 : 0 : rte_spinlock_unlock(&ad->udp_tunnel_ctx.lock);
664 : 0 : l_end:
665 : 0 : return ret;
666 : : }
667 : :
668 : 0 : int32_t sxe2_udp_tunnel_port_del_common(struct sxe2_adapter *ad,
669 : : enum sxe2_udp_tunnel_protocol tunnel_proto,
670 : : uint16_t udp_port)
671 : : {
672 : 0 : struct sxe2_udp_tunnel_cfg *tunnel_config;
673 : 0 : int32_t ret = -1;
674 : :
675 [ # # # # ]: 0 : if (ad->dev_type != SXE2_DEV_T_PF || ad->is_dev_repr)
676 : : return -ENOTSUP;
677 : :
678 : 0 : rte_spinlock_lock(&ad->udp_tunnel_ctx.lock);
679 : 0 : tunnel_config = &ad->udp_tunnel_ctx.tunnel_conf[tunnel_proto];
680 : :
681 [ # # ]: 0 : if (tunnel_config->dev_status == SXE2_UDP_TUNNEL_ENABLE &&
682 [ # # ]: 0 : udp_port == tunnel_config->dev_port) {
683 [ # # ]: 0 : if (tunnel_config->dev_ref_cnt > 1) {
684 : 0 : tunnel_config->dev_ref_cnt--;
685 : 0 : ret = 0;
686 : 0 : goto l_unlock_end;
687 : : } else {
688 : 0 : ret = sxe2_drv_udp_tunnel_del(ad, tunnel_proto, udp_port);
689 [ # # ]: 0 : if (ret != 0)
690 : 0 : goto l_unlock_end;
691 : :
692 : 0 : tunnel_config->dev_status = SXE2_UDP_TUNNEL_DISABLE;
693 : 0 : tunnel_config->dev_ref_cnt = 0;
694 : : }
695 : 0 : goto l_unlock_end;
696 : : }
697 : :
698 : : ret = -EINVAL;
699 : :
700 : 0 : l_unlock_end:
701 : 0 : rte_spinlock_unlock(&ad->udp_tunnel_ctx.lock);
702 : 0 : return ret;
703 : : }
704 : :
705 : 0 : static int32_t sxe2_udp_tunnel_port_clear(struct rte_eth_dev *dev)
706 : : {
707 : 0 : struct sxe2_adapter *ad = SXE2_DEV_PRIVATE_TO_ADAPTER(dev);
708 : 0 : struct sxe2_udp_tunnel_cfg *tunnel_config;
709 : 0 : int32_t ret = 0;
710 : 0 : uint16_t tunnel_proto = 0;
711 : :
712 [ # # # # ]: 0 : if (ad->dev_type != SXE2_DEV_T_PF || ad->is_dev_repr)
713 : : return -ENOTSUP;
714 : :
715 : 0 : rte_spinlock_lock(&ad->udp_tunnel_ctx.lock);
716 : :
717 [ # # ]: 0 : for (tunnel_proto = 0; tunnel_proto < SXE2_UDP_TUNNEL_MAX; tunnel_proto++) {
718 : 0 : tunnel_config = &ad->udp_tunnel_ctx.tunnel_conf[tunnel_proto];
719 [ # # ]: 0 : if (tunnel_config->dev_status == SXE2_UDP_TUNNEL_ENABLE) {
720 : 0 : ret = sxe2_drv_udp_tunnel_del(ad, tunnel_config->protocol,
721 : 0 : tunnel_config->dev_port);
722 [ # # ]: 0 : if (ret) {
723 : 0 : PMD_LOG_ERR(DRV, "Failed to delete udp tunnel port %d, proto %d",
724 : : tunnel_config->dev_port, tunnel_config->protocol);
725 : 0 : goto l_unlock_end;
726 : : }
727 : :
728 : 0 : tunnel_config->dev_status = SXE2_UDP_TUNNEL_DISABLE;
729 : 0 : tunnel_config->dev_ref_cnt = 0;
730 : : }
731 : : }
732 : 0 : l_unlock_end:
733 : 0 : rte_spinlock_unlock(&ad->udp_tunnel_ctx.lock);
734 : 0 : return ret;
735 : : }
736 : :
737 : 0 : static int32_t sxe2_udp_tunnel_port_add(struct rte_eth_dev *dev,
738 : : struct rte_eth_udp_tunnel *tunnel_udp)
739 : : {
740 : 0 : int32_t ret = 0;
741 : 0 : enum sxe2_udp_tunnel_protocol tunnel_proto;
742 : 0 : struct sxe2_adapter *ad = SXE2_DEV_PRIVATE_TO_ADAPTER(dev);
743 : :
744 [ # # ]: 0 : if (tunnel_udp->udp_port == 0) {
745 : 0 : ret = -EINVAL;
746 : 0 : goto l_end;
747 : : }
748 : :
749 : 0 : tunnel_proto = sxe2_udp_tunnel_type_rte_to_sxe2(tunnel_udp->prot_type);
750 [ # # ]: 0 : if (tunnel_proto >= SXE2_UDP_TUNNEL_MAX) {
751 : 0 : ret = -EINVAL;
752 : 0 : goto l_end;
753 : : }
754 : :
755 : 0 : ret = sxe2_udp_tunnel_port_add_common(ad, tunnel_proto, tunnel_udp->udp_port);
756 [ # # ]: 0 : if (ret) {
757 : 0 : PMD_LOG_ERR(DRV, "Add tunnel port failed, ret = %d", ret);
758 : 0 : goto l_end;
759 : : }
760 : :
761 : 0 : l_end:
762 : 0 : return ret;
763 : : }
764 : :
765 : 0 : static int32_t sxe2_udp_tunnel_port_del(struct rte_eth_dev *dev,
766 : : struct rte_eth_udp_tunnel *tunnel_udp)
767 : : {
768 : 0 : int32_t ret = 0;
769 : 0 : enum sxe2_udp_tunnel_protocol tunnel_proto;
770 : 0 : struct sxe2_adapter *ad = SXE2_DEV_PRIVATE_TO_ADAPTER(dev);
771 : :
772 : 0 : tunnel_proto = sxe2_udp_tunnel_type_rte_to_sxe2(tunnel_udp->prot_type);
773 [ # # ]: 0 : if (tunnel_proto >= SXE2_UDP_TUNNEL_MAX) {
774 : 0 : ret = -EINVAL;
775 : 0 : goto l_end;
776 : : }
777 : :
778 : 0 : ret = sxe2_udp_tunnel_port_del_common(ad, tunnel_proto, tunnel_udp->udp_port);
779 [ # # ]: 0 : if (ret) {
780 : 0 : PMD_LOG_ERR(DRV, "Delete tunnel port failed, ret = %d", ret);
781 : 0 : goto l_end;
782 : : }
783 : :
784 : 0 : l_end:
785 : 0 : return ret;
786 : : }
787 : :
788 : 0 : static int32_t sxe2_dev_infos_get(struct rte_eth_dev *dev,
789 : : struct rte_eth_dev_info *dev_info)
790 : : {
791 : 0 : struct sxe2_adapter *adapter = SXE2_DEV_PRIVATE_TO_ADAPTER(dev);
792 : 0 : struct sxe2_vsi *vsi = adapter->vsi_ctxt.main_vsi;
793 : :
794 [ # # ]: 0 : if (unlikely(vsi == NULL)) {
795 : 0 : PMD_LOG_ERR(INIT, "main vsi is NULL");
796 : 0 : return -EINVAL;
797 : : }
798 : 0 : dev_info->max_rx_queues = vsi->rxqs.q_cnt;
799 : 0 : dev_info->max_tx_queues = vsi->txqs.q_cnt;
800 : 0 : dev_info->min_rx_bufsize = SXE2_MIN_BUF_SIZE;
801 : 0 : dev_info->max_rx_pktlen = SXE2_FRAME_SIZE_MAX;
802 : 0 : dev_info->max_lro_pkt_size = SXE2_FRAME_SIZE_MAX * SXE2_RX_LRO_DESC_MAX_NUM;
803 : 0 : dev_info->max_mtu = dev_info->max_rx_pktlen - SXE2_ETH_OVERHEAD;
804 : 0 : dev_info->min_mtu = RTE_ETHER_MIN_MTU;
805 : 0 : dev_info->max_mac_addrs = SXE2_NUM_MACADDR_MAX;
806 : :
807 : 0 : dev_info->rx_offload_capa =
808 : : RTE_ETH_RX_OFFLOAD_VLAN_STRIP |
809 : : RTE_ETH_RX_OFFLOAD_KEEP_CRC |
810 : : RTE_ETH_RX_OFFLOAD_SCATTER |
811 : : RTE_ETH_RX_OFFLOAD_IPV4_CKSUM |
812 : : RTE_ETH_RX_OFFLOAD_UDP_CKSUM |
813 : : RTE_ETH_RX_OFFLOAD_TCP_CKSUM |
814 : : RTE_ETH_RX_OFFLOAD_SCTP_CKSUM |
815 : : RTE_ETH_RX_OFFLOAD_OUTER_IPV4_CKSUM |
816 : : RTE_ETH_RX_OFFLOAD_BUFFER_SPLIT |
817 : : RTE_ETH_RX_OFFLOAD_VLAN_EXTEND |
818 : : RTE_ETH_RX_OFFLOAD_TCP_LRO;
819 : :
820 : 0 : dev_info->tx_offload_capa =
821 : : RTE_ETH_TX_OFFLOAD_VLAN_INSERT |
822 : : RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
823 : : RTE_ETH_TX_OFFLOAD_MBUF_FAST_FREE |
824 : : RTE_ETH_TX_OFFLOAD_IPV4_CKSUM |
825 : : RTE_ETH_TX_OFFLOAD_UDP_CKSUM |
826 : : RTE_ETH_TX_OFFLOAD_TCP_CKSUM |
827 : : RTE_ETH_TX_OFFLOAD_SCTP_CKSUM |
828 : : RTE_ETH_TX_OFFLOAD_OUTER_IPV4_CKSUM |
829 : : RTE_ETH_TX_OFFLOAD_OUTER_UDP_CKSUM |
830 : : RTE_ETH_TX_OFFLOAD_TCP_TSO |
831 : : RTE_ETH_TX_OFFLOAD_UDP_TSO |
832 : : RTE_ETH_TX_OFFLOAD_VXLAN_TNL_TSO |
833 : : RTE_ETH_TX_OFFLOAD_GRE_TNL_TSO |
834 : : RTE_ETH_TX_OFFLOAD_IPIP_TNL_TSO |
835 : : RTE_ETH_TX_OFFLOAD_GENEVE_TNL_TSO;
836 : :
837 : 0 : dev_info->rx_queue_offload_capa =
838 : : RTE_ETH_RX_OFFLOAD_BUFFER_SPLIT |
839 : : RTE_ETH_RX_OFFLOAD_KEEP_CRC |
840 : : RTE_ETH_RX_OFFLOAD_SCATTER |
841 : : RTE_ETH_RX_OFFLOAD_IPV4_CKSUM |
842 : : RTE_ETH_RX_OFFLOAD_UDP_CKSUM |
843 : : RTE_ETH_RX_OFFLOAD_TCP_CKSUM |
844 : : RTE_ETH_RX_OFFLOAD_SCTP_CKSUM |
845 : : RTE_ETH_RX_OFFLOAD_OUTER_IPV4_CKSUM |
846 : : RTE_ETH_RX_OFFLOAD_TCP_LRO;
847 : 0 : dev_info->tx_queue_offload_capa =
848 : : RTE_ETH_TX_OFFLOAD_MBUF_FAST_FREE |
849 : : RTE_ETH_TX_OFFLOAD_TCP_TSO |
850 : : RTE_ETH_TX_OFFLOAD_UDP_TSO |
851 : : RTE_ETH_TX_OFFLOAD_MULTI_SEGS |
852 : : RTE_ETH_TX_OFFLOAD_IPV4_CKSUM |
853 : : RTE_ETH_TX_OFFLOAD_UDP_CKSUM |
854 : : RTE_ETH_TX_OFFLOAD_TCP_CKSUM |
855 : : RTE_ETH_TX_OFFLOAD_SCTP_CKSUM |
856 : : RTE_ETH_TX_OFFLOAD_OUTER_IPV4_CKSUM |
857 : : RTE_ETH_TX_OFFLOAD_OUTER_UDP_CKSUM |
858 : : RTE_ETH_TX_OFFLOAD_VXLAN_TNL_TSO |
859 : : RTE_ETH_TX_OFFLOAD_GRE_TNL_TSO |
860 : : RTE_ETH_TX_OFFLOAD_IPIP_TNL_TSO |
861 : : RTE_ETH_TX_OFFLOAD_GENEVE_TNL_TSO;
862 : :
863 : :
864 [ # # ]: 0 : if (sxe2_ipsec_supported(adapter)) {
865 : 0 : dev_info->rx_offload_capa |= RTE_ETH_RX_OFFLOAD_SECURITY;
866 : 0 : dev_info->tx_offload_capa |= RTE_ETH_TX_OFFLOAD_SECURITY;
867 : : }
868 : :
869 [ # # ]: 0 : if (adapter->cap_flags & SXE2_DEV_CAPS_OFFLOAD_PTP)
870 : 0 : dev_info->rx_offload_capa |= RTE_ETH_RX_OFFLOAD_TIMESTAMP;
871 : :
872 [ # # ]: 0 : if (!sxe2_dev_port_vlan_check(dev)) {
873 : 0 : dev_info->tx_offload_capa |= RTE_ETH_TX_OFFLOAD_QINQ_INSERT;
874 : : #ifndef RTE_LIBRTE_SXE2_16BYTE_RX_DESC
875 : 0 : dev_info->rx_offload_capa |= RTE_ETH_RX_OFFLOAD_QINQ_STRIP;
876 : : #endif
877 : 0 : dev_info->rx_offload_capa |= RTE_ETH_RX_OFFLOAD_VLAN_FILTER;
878 : : }
879 : :
880 [ # # ]: 0 : if (adapter->cap_flags & SXE2_DEV_CAPS_OFFLOAD_RSS) {
881 : 0 : dev_info->rx_offload_capa |= RTE_ETH_RX_OFFLOAD_RSS_HASH;
882 : 0 : dev_info->flow_type_rss_offloads |= SXE2_RSS_HF_SUPPORT_ALL;
883 : 0 : dev_info->reta_size = adapter->rss_ctxt.rss_lut_size;
884 : 0 : dev_info->hash_key_size = adapter->rss_ctxt.rss_key_size;
885 : 0 : dev_info->rss_algo_capa =
886 : : RTE_ETH_HASH_ALGO_TO_CAPA(RTE_ETH_HASH_FUNCTION_DEFAULT) |
887 : : RTE_ETH_HASH_ALGO_TO_CAPA(RTE_ETH_HASH_FUNCTION_TOEPLITZ) |
888 : : RTE_ETH_HASH_ALGO_TO_CAPA(RTE_ETH_HASH_FUNCTION_SYMMETRIC_TOEPLITZ) |
889 : : RTE_ETH_HASH_ALGO_TO_CAPA(RTE_ETH_HASH_FUNCTION_SIMPLE_XOR);
890 : : }
891 : :
892 : 0 : dev_info->default_rxconf = (struct rte_eth_rxconf) {
893 : : .rx_thresh = {
894 : : .pthresh = SXE2_DEFAULT_RX_PTHRESH,
895 : : .hthresh = SXE2_DEFAULT_RX_HTHRESH,
896 : : .wthresh = SXE2_DEFAULT_RX_WTHRESH,
897 : : },
898 : : .rx_free_thresh = SXE2_DEFAULT_RX_FREE_THRESH,
899 : : .rx_drop_en = 0,
900 : : .offloads = 0,
901 : : };
902 : :
903 : 0 : dev_info->default_txconf = (struct rte_eth_txconf) {
904 : : .tx_thresh = {
905 : : .pthresh = SXE2_DEFAULT_TX_PTHRESH,
906 : : .hthresh = SXE2_DEFAULT_TX_HTHRESH,
907 : : .wthresh = SXE2_DEFAULT_TX_WTHRESH,
908 : : },
909 : : .tx_free_thresh = SXE2_DEFAULT_TX_FREE_THRESH,
910 : : .tx_rs_thresh = SXE2_DEFAULT_TX_RSBIT_THRESH,
911 : : .offloads = 0,
912 : : };
913 : :
914 : 0 : dev_info->rx_desc_lim = (struct rte_eth_desc_lim) {
915 : : .nb_max = SXE2_MAX_RING_DESC,
916 : : .nb_min = SXE2_MIN_RING_DESC,
917 : : .nb_align = SXE2_ALIGN,
918 : : };
919 : :
920 : 0 : dev_info->tx_desc_lim = (struct rte_eth_desc_lim) {
921 : : .nb_max = SXE2_MAX_RING_DESC,
922 : : .nb_min = SXE2_MIN_RING_DESC,
923 : : .nb_align = SXE2_ALIGN,
924 : : .nb_mtu_seg_max = SXE2_TX_MTU_SEG_MAX,
925 : : .nb_seg_max = SXE2_MAX_RING_DESC,
926 : : };
927 : :
928 : 0 : dev_info->speed_capa = RTE_ETH_LINK_SPEED_10G | RTE_ETH_LINK_SPEED_25G |
929 : : RTE_ETH_LINK_SPEED_50G | RTE_ETH_LINK_SPEED_100G;
930 : :
931 : 0 : dev_info->default_rxportconf.burst_size = SXE2_RX_MAX_BURST;
932 : 0 : dev_info->default_txportconf.burst_size = SXE2_TX_MAX_BURST;
933 : 0 : dev_info->default_rxportconf.nb_queues = 1;
934 : 0 : dev_info->default_txportconf.nb_queues = 1;
935 : 0 : dev_info->default_rxportconf.ring_size = SXE2_RING_SIZE_MIN;
936 : 0 : dev_info->default_txportconf.ring_size = SXE2_RING_SIZE_MIN;
937 : :
938 : 0 : dev_info->rx_seg_capa.max_nseg = SXE2_RX_MAX_NSEG;
939 : :
940 : 0 : dev_info->rx_seg_capa.multi_pools = true;
941 : :
942 : 0 : dev_info->rx_seg_capa.offset_allowed = false;
943 : :
944 : 0 : dev_info->rx_seg_capa.offset_align_log2 = false;
945 : :
946 : 0 : return 0;
947 : : }
948 : :
949 : : static const uint32_t *
950 : 0 : sxe2_buffer_split_supported_hdr_ptypes_get(struct rte_eth_dev *dev __rte_unused,
951 : : size_t *no_of_elements)
952 : : {
953 : 0 : static const uint32_t ptypes[] = {
954 : : RTE_PTYPE_L2_ETHER,
955 : : RTE_PTYPE_L2_ETHER | RTE_PTYPE_L3_IPV4_EXT_UNKNOWN,
956 : : RTE_PTYPE_L2_ETHER | RTE_PTYPE_L3_IPV4_EXT_UNKNOWN | RTE_PTYPE_L4_UDP,
957 : : RTE_PTYPE_L2_ETHER | RTE_PTYPE_L3_IPV4_EXT_UNKNOWN | RTE_PTYPE_L4_TCP,
958 : : RTE_PTYPE_L2_ETHER | RTE_PTYPE_L3_IPV4_EXT_UNKNOWN | RTE_PTYPE_L4_SCTP,
959 : : RTE_PTYPE_L2_ETHER | RTE_PTYPE_L3_IPV6_EXT_UNKNOWN,
960 : : RTE_PTYPE_L2_ETHER | RTE_PTYPE_L3_IPV6_EXT_UNKNOWN | RTE_PTYPE_L4_UDP,
961 : : RTE_PTYPE_L2_ETHER | RTE_PTYPE_L3_IPV6_EXT_UNKNOWN | RTE_PTYPE_L4_TCP,
962 : : RTE_PTYPE_L2_ETHER | RTE_PTYPE_L3_IPV6_EXT_UNKNOWN | RTE_PTYPE_L4_SCTP,
963 : :
964 : : RTE_PTYPE_TUNNEL_GRENAT,
965 : :
966 : : RTE_PTYPE_TUNNEL_GRENAT | RTE_PTYPE_INNER_L2_ETHER,
967 : :
968 : : RTE_PTYPE_TUNNEL_GRENAT | RTE_PTYPE_INNER_L2_ETHER |
969 : : RTE_PTYPE_INNER_L3_IPV4_EXT_UNKNOWN,
970 : : RTE_PTYPE_TUNNEL_GRENAT | RTE_PTYPE_INNER_L2_ETHER |
971 : : RTE_PTYPE_INNER_L3_IPV6_EXT_UNKNOWN,
972 : :
973 : : RTE_PTYPE_TUNNEL_GRENAT | RTE_PTYPE_INNER_L2_ETHER |
974 : : RTE_PTYPE_INNER_L3_IPV4_EXT_UNKNOWN | RTE_PTYPE_INNER_L4_UDP,
975 : : RTE_PTYPE_TUNNEL_GRENAT | RTE_PTYPE_INNER_L2_ETHER |
976 : : RTE_PTYPE_INNER_L3_IPV4_EXT_UNKNOWN | RTE_PTYPE_INNER_L4_TCP,
977 : : RTE_PTYPE_TUNNEL_GRENAT | RTE_PTYPE_INNER_L2_ETHER |
978 : : RTE_PTYPE_INNER_L3_IPV4_EXT_UNKNOWN | RTE_PTYPE_INNER_L4_SCTP,
979 : :
980 : : RTE_PTYPE_TUNNEL_GRENAT | RTE_PTYPE_INNER_L2_ETHER |
981 : : RTE_PTYPE_INNER_L3_IPV6_EXT_UNKNOWN | RTE_PTYPE_INNER_L4_UDP,
982 : : RTE_PTYPE_TUNNEL_GRENAT | RTE_PTYPE_INNER_L2_ETHER |
983 : : RTE_PTYPE_INNER_L3_IPV6_EXT_UNKNOWN | RTE_PTYPE_INNER_L4_TCP,
984 : : RTE_PTYPE_TUNNEL_GRENAT | RTE_PTYPE_INNER_L2_ETHER |
985 : : RTE_PTYPE_INNER_L3_IPV6_EXT_UNKNOWN | RTE_PTYPE_INNER_L4_SCTP,
986 : :
987 : : RTE_PTYPE_UNKNOWN
988 : : };
989 : 0 : *no_of_elements = RTE_DIM(ptypes) - 1;
990 : :
991 : 0 : return ptypes;
992 : : }
993 : :
994 : 0 : static int32_t sxe2_parse_stat_type(const char *key, const char *value, void *args)
995 : : {
996 : 0 : int32_t ret = -EINVAL;
997 : 0 : uint8_t *num = (uint8_t *)args;
998 : 0 : unsigned long stat_type;
999 : 0 : char *endptr = NULL;
1000 : :
1001 [ # # ]: 0 : if (value == NULL || args == NULL) {
1002 : 0 : ret = 0;
1003 : 0 : goto l_end;
1004 : : }
1005 : 0 : errno = 0;
1006 : 0 : stat_type = strtoul(value, &endptr, 10);
1007 [ # # # # : 0 : if (errno != 0 || endptr == value || *endptr != '\0') {
# # ]
1008 : 0 : PMD_LOG_WARN(INIT, "%s: \"%s\" is not a valid int value.",
1009 : : key, value);
1010 : 0 : goto l_end;
1011 : : }
1012 [ # # ]: 0 : if (stat_type > SXE2_FNAV_STAT_ENA_ALL ||
1013 : : stat_type == SXE2_FNAV_STAT_ENA_NONE) {
1014 : 0 : PMD_LOG_ERR(INIT, "%s: \"%s\" out of range [1-3].",
1015 : : key, value);
1016 : 0 : goto l_end;
1017 : : }
1018 : 0 : *num = (uint8_t)stat_type;
1019 : 0 : ret = 0;
1020 : 0 : l_end:
1021 : 0 : return ret;
1022 : : }
1023 : :
1024 : 0 : static int32_t sxe2_parse_sched_layer_mode(const char *key, const char *value, void *args)
1025 : : {
1026 : 0 : int32_t ret = -EINVAL;
1027 : 0 : uint8_t *num = (uint8_t *)args;
1028 : 0 : unsigned long sched_layer_mode;
1029 : 0 : char *endptr = NULL;
1030 : :
1031 [ # # ]: 0 : if (value == NULL || args == NULL) {
1032 : 0 : ret = 0;
1033 : 0 : goto l_end;
1034 : : }
1035 : 0 : errno = 0;
1036 : 0 : sched_layer_mode = strtoul(value, &endptr, 10);
1037 [ # # # # : 0 : if (errno != 0 || endptr == value || *endptr != '\0') {
# # ]
1038 : 0 : PMD_LOG_WARN(INIT, "%s: \"%s\" is not a valid int value.",
1039 : : key, value);
1040 : 0 : goto l_end;
1041 : : }
1042 [ # # ]: 0 : if (sched_layer_mode > SXE2_TXSCH_NODE_ADJ_LVL_MAX) {
1043 : 0 : PMD_LOG_ERR(INIT, "%s: \"%s\" > 3.",
1044 : : key, value);
1045 : 0 : goto l_end;
1046 : : }
1047 : 0 : *num = (uint8_t)sched_layer_mode;
1048 : 0 : ret = 0;
1049 : 0 : l_end:
1050 : 0 : return ret;
1051 : : }
1052 : :
1053 : 0 : static int32_t sxe2_parse_flow_dup_pattern_mode(const char *key, const char *value, void *args)
1054 : : {
1055 : 0 : uint8_t *num = (uint8_t *)args;
1056 : 0 : char *end;
1057 : 0 : unsigned long val;
1058 : 0 : int32_t ret = -EINVAL;
1059 : :
1060 [ # # ]: 0 : if (value == NULL || args == NULL) {
1061 : 0 : ret = 0;
1062 : 0 : goto l_end;
1063 : : }
1064 : 0 : errno = 0;
1065 : 0 : val = strtoul(value, &end, 10);
1066 [ # # # # : 0 : if (errno != 0 || end == value || *end != '\0') {
# # ]
1067 : 0 : PMD_LOG_ERR(INIT, "Invalid 8-bit integer value for key %s: %s", key, value);
1068 : 0 : goto l_end;
1069 : : }
1070 : :
1071 [ # # ]: 0 : if (val >= SXE2_FLOW_SW_PATTERN_MAX) {
1072 : 0 : PMD_LOG_ERR(INIT, "%s: \"%s\" out of range [0-%u].",
1073 : : key, value, SXE2_FLOW_SW_PATTERN_MAX - 1);
1074 : 0 : goto l_end;
1075 : : }
1076 : :
1077 : : /* Convert user values to internal enum:
1078 : : * user 0 (reject) -> SXE2_FLOW_SW_PATTERN_ONLY (0)
1079 : : * user 1 (FIFO) -> SXE2_FLOW_SW_PATTERN_FIRST (2)
1080 : : * user 2 (LIFO) -> SXE2_FLOW_SW_PATTERN_LAST (1)
1081 : : */
1082 : 0 : static const uint8_t udc_tbl[] = {
1083 : : SXE2_FLOW_SW_PATTERN_ONLY,
1084 : : SXE2_FLOW_SW_PATTERN_FIRST,
1085 : : SXE2_FLOW_SW_PATTERN_LAST,
1086 : : };
1087 : 0 : *num = udc_tbl[val];
1088 : 0 : ret = 0;
1089 : 0 : l_end:
1090 : 0 : return ret;
1091 : : }
1092 : :
1093 : 0 : static int32_t sxe2_parse_bool(const char *key, const char *value, void *args)
1094 : : {
1095 : 0 : int32_t ret = -EINVAL;
1096 : 0 : uint8_t *num = (uint8_t *)args;
1097 : 0 : unsigned long bool_val;
1098 : 0 : char *endptr = NULL;
1099 : :
1100 [ # # ]: 0 : if (value == NULL || args == NULL) {
1101 : 0 : ret = 0;
1102 : 0 : goto l_end;
1103 : : }
1104 : 0 : errno = 0;
1105 : 0 : bool_val = strtoul(value, &endptr, 10);
1106 [ # # # # : 0 : if (errno != 0 || endptr == value || *endptr != '\0') {
# # ]
1107 : 0 : PMD_LOG_WARN(INIT, "%s: \"%s\" is not a valid int value.",
1108 : : key, value);
1109 : 0 : goto l_end;
1110 : : }
1111 [ # # ]: 0 : if (bool_val != 0 && bool_val != 1) {
1112 : 0 : PMD_LOG_ERR(INIT, "%s: \"%s\" out of range [0|1].",
1113 : : key, value);
1114 : 0 : goto l_end;
1115 : : }
1116 : 0 : *num = (uint8_t)bool_val;
1117 : 0 : ret = 0;
1118 : 0 : l_end:
1119 : 0 : return ret;
1120 : : }
1121 : :
1122 : 0 : struct sxe2_pci_map_bar_info *sxe2_dev_get_bar_info(struct sxe2_adapter *adapter,
1123 : : enum sxe2_pci_map_resource res_type)
1124 : : {
1125 : 0 : struct sxe2_pci_map_context *map_ctxt = &adapter->map_ctxt;
1126 : 0 : struct sxe2_pci_map_bar_info *bar_info = NULL;
1127 : 0 : uint8_t bar_idx = SXE2_PCI_MAP_BAR_INVALID;
1128 : 0 : uint8_t i;
1129 : :
1130 : 0 : bar_idx = map_ctxt->addr_info[res_type].bar_idx;
1131 [ # # ]: 0 : if (bar_idx == SXE2_PCI_MAP_BAR_INVALID) {
1132 : 0 : PMD_DEV_LOG_ERR(adapter, INIT, "Invalid bar index with resource type %d", res_type);
1133 : 0 : goto l_end;
1134 : : }
1135 : :
1136 [ # # ]: 0 : for (i = 0; i < map_ctxt->bar_cnt; i++) {
1137 [ # # ]: 0 : if (bar_idx == map_ctxt->bar_info[i].bar_idx) {
1138 : : bar_info = &map_ctxt->bar_info[i];
1139 : : break;
1140 : : }
1141 : : }
1142 : :
1143 : 0 : l_end:
1144 : 0 : return bar_info;
1145 : : }
1146 : :
1147 : 0 : void *sxe2_pci_map_addr_get(struct sxe2_adapter *adapter,
1148 : : enum sxe2_pci_map_resource res_type,
1149 : : uint16_t idx_in_func)
1150 : : {
1151 : 0 : struct sxe2_pci_map_context *map_ctxt = &adapter->map_ctxt;
1152 : 0 : struct sxe2_pci_map_segment_info *seg_info = NULL;
1153 : 0 : struct sxe2_pci_map_bar_info *bar_info = NULL;
1154 : 0 : void *addr = NULL;
1155 : 0 : uintptr_t calc_addr = 0;
1156 : 0 : uint8_t reg_width = 0;
1157 : 0 : uint8_t i = 0;
1158 : :
1159 : 0 : bar_info = sxe2_dev_get_bar_info(adapter, res_type);
1160 [ # # ]: 0 : if (bar_info == NULL) {
1161 : 0 : PMD_DEV_LOG_WARN(adapter, INIT, "Failed to get bar info, res_type=[%d]",
1162 : : res_type);
1163 : 0 : goto l_end;
1164 : : }
1165 : 0 : seg_info = bar_info->seg_info;
1166 : :
1167 : 0 : reg_width = map_ctxt->addr_info[res_type].reg_width;
1168 [ # # ]: 0 : if (reg_width == 0) {
1169 : 0 : PMD_DEV_LOG_WARN(adapter, INIT, "Invalid reg width with resource type %d",
1170 : : res_type);
1171 : 0 : goto l_end;
1172 : : }
1173 : :
1174 [ # # ]: 0 : for (i = 0; i < bar_info->map_cnt; i++) {
1175 : 0 : seg_info = &bar_info->seg_info[i];
1176 [ # # ]: 0 : if (res_type == seg_info->type) {
1177 : 0 : calc_addr = (uintptr_t)seg_info->addr;
1178 : 0 : calc_addr += (uintptr_t)seg_info->page_inner_offset;
1179 : 0 : calc_addr += (uintptr_t)reg_width * (uintptr_t)idx_in_func;
1180 : 0 : addr = (void *)calc_addr;
1181 : 0 : goto l_end;
1182 : : }
1183 : : }
1184 : :
1185 : 0 : l_end:
1186 : 0 : return addr;
1187 : : }
1188 : :
1189 : 0 : static int32_t sxe2_args_parse(struct rte_eth_dev *dev, struct sxe2_dev_kvargs_info *kvargs)
1190 : : {
1191 : 0 : struct sxe2_adapter *adapter = SXE2_DEV_PRIVATE_TO_ADAPTER(dev);
1192 : 0 : int32_t ret = 0;
1193 : 0 : PMD_INIT_FUNC_TRACE();
1194 : :
1195 : 0 : adapter->devargs.flow_dup_pattern_mode = SXE2_FLOW_SW_PATTERN_FIRST;
1196 : :
1197 [ # # ]: 0 : if (kvargs == NULL)
1198 : 0 : goto l_end;
1199 : 0 : ret = sxe2_kvargs_process(kvargs, SXE2_DEVARG_FNAV_STAT_TYPE,
1200 : : &sxe2_parse_stat_type,
1201 : 0 : &adapter->devargs.fnav_stat_type);
1202 [ # # ]: 0 : if (ret) {
1203 : 0 : PMD_DEV_LOG_ERR(adapter, INIT, "Failed to parse fnav stat type, ret:%d", ret);
1204 : 0 : goto l_end;
1205 : : }
1206 : :
1207 : 0 : ret = sxe2_kvargs_process(kvargs, SXE2_DEVARG_ACL_STAT_TYPE,
1208 : 0 : &sxe2_parse_stat_type, &adapter->devargs.acl_stat_type);
1209 [ # # ]: 0 : if (ret) {
1210 : 0 : PMD_DEV_LOG_ERR(adapter, INIT, "Failed to parse acl stat type, ret:%d", ret);
1211 : 0 : goto l_end;
1212 : : }
1213 : :
1214 : 0 : ret = sxe2_kvargs_process(kvargs, SXE2_DEVARG_NO_SCHED_MODE,
1215 : : &sxe2_parse_bool,
1216 : 0 : &adapter->devargs.no_sched_mode);
1217 [ # # ]: 0 : if (ret) {
1218 : 0 : PMD_DEV_LOG_ERR(adapter, INIT, "Failed to parse no sched mode, ret:%d", ret);
1219 : 0 : goto l_end;
1220 : : }
1221 : 0 : ret = sxe2_kvargs_process(kvargs, SXE2_DEVARG_SCHED_LAYER_MODE,
1222 : : &sxe2_parse_sched_layer_mode,
1223 : 0 : &adapter->devargs.sched_layer_mode);
1224 [ # # ]: 0 : if (ret) {
1225 : 0 : PMD_DEV_LOG_ERR(adapter, INIT, "Failed to parse sched layer mode, ret:%d", ret);
1226 : 0 : goto l_end;
1227 : : }
1228 : :
1229 : 0 : ret = sxe2_kvargs_process(kvargs, SXE2_DEVARG_FLOW_DUP_PATTERN_MODE,
1230 : : &sxe2_parse_flow_dup_pattern_mode,
1231 : 0 : &adapter->devargs.flow_dup_pattern_mode);
1232 [ # # ]: 0 : if (ret) {
1233 : 0 : PMD_DEV_LOG_ERR(adapter, INIT, "Failed to parse flow dup pattern mode, ret:%d",
1234 : : ret);
1235 : 0 : goto l_end;
1236 : : }
1237 : :
1238 : 0 : ret = sxe2_kvargs_process(kvargs, SXE2_DEVARG_FUNC_FLOW_DIRCT,
1239 : : &sxe2_parse_bool,
1240 : 0 : &adapter->devargs.func_flow_direct_en);
1241 [ # # ]: 0 : if (ret) {
1242 : 0 : PMD_DEV_LOG_ERR(adapter, INIT, "Failed to parse function flow rule enable,"
1243 : : "ret:%d", ret);
1244 : 0 : goto l_end;
1245 : : }
1246 : 0 : ret = sxe2_kvargs_process(kvargs, SXE2_DEVARG_RX_LOW_LATENCY,
1247 : : &sxe2_parse_bool,
1248 : 0 : &adapter->devargs.rx_low_latency);
1249 [ # # ]: 0 : if (ret) {
1250 : 0 : PMD_DEV_LOG_ERR(adapter, INIT, "Failed to parse rx low latency, ret:%d", ret);
1251 : 0 : goto l_end;
1252 : : }
1253 : 0 : l_end:
1254 : 0 : return ret;
1255 : : }
1256 : :
1257 : 0 : static int32_t sxe2_eth_init(struct rte_eth_dev *dev)
1258 : : {
1259 : 0 : int32_t ret = 0;
1260 : :
1261 : 0 : ret = sxe2_filter_init(dev);
1262 [ # # ]: 0 : if (ret) {
1263 : 0 : PMD_LOG_ERR(INIT, "Failed to initialize l2 filter, ret:%d", ret);
1264 : 0 : goto l_end;
1265 : : }
1266 : :
1267 : 0 : ret = sxe2_link_update_init(dev);
1268 [ # # ]: 0 : if (ret) {
1269 : 0 : PMD_LOG_ERR(INIT, "Failed to initialize link update, ret:%d", ret);
1270 : 0 : goto l_end;
1271 : : }
1272 : :
1273 : 0 : ret = sxe2_mtu_set(dev, dev->data->mtu);
1274 [ # # ]: 0 : if (ret) {
1275 : 0 : PMD_LOG_ERR(INIT, "Failed to set mtu, ret=%d", ret);
1276 : 0 : goto l_end;
1277 : : }
1278 : :
1279 : 0 : ret = sxe2_mac_addr_init(dev);
1280 [ # # ]: 0 : if (ret != 0) {
1281 : 0 : PMD_LOG_ERR(INIT, "Failed to initialize mac address, ret:%d", ret);
1282 : 0 : goto l_end;
1283 : : }
1284 : :
1285 : 0 : ret = sxe2_mac_default_cfg(dev);
1286 [ # # ]: 0 : if (ret != 0) {
1287 : 0 : PMD_LOG_ERR(INIT, "Failed to configure default mac address, ret:%d", ret);
1288 : 0 : goto l_err;
1289 : : }
1290 : :
1291 : 0 : ret = sxe2_vlan_cfg_init(dev);
1292 [ # # ]: 0 : if (ret) {
1293 : 0 : PMD_LOG_ERR(INIT, "Failed to initialize vlan config, ret:%d", ret);
1294 : 0 : goto l_err;
1295 : : }
1296 : 0 : goto l_end;
1297 : :
1298 : 0 : l_err:
1299 : 0 : sxe2_mac_addr_uinit(dev);
1300 : 0 : (void)sxe2_filter_uinit(dev);
1301 : 0 : l_end:
1302 : 0 : return ret;
1303 : : }
1304 : :
1305 : 0 : void sxe2_eth_uinit(struct rte_eth_dev *dev __rte_unused)
1306 : : {
1307 : 0 : sxe2_mac_addr_uinit(dev);
1308 : 0 : (void)sxe2_filter_uinit(dev);
1309 : 0 : }
1310 : :
1311 : 0 : static void sxe2_drv_dev_caps_set(struct sxe2_adapter *adapter,
1312 : : struct sxe2_drv_dev_caps_resp *dev_caps)
1313 : : {
1314 : 0 : adapter->cap_flags = 0;
1315 : :
1316 [ # # ]: 0 : if (dev_caps->cap_flags & SXE2_DEV_CAPS_OFFLOAD_L2)
1317 : 0 : adapter->cap_flags |= SXE2_DEV_CAPS_OFFLOAD_L2;
1318 : :
1319 [ # # ]: 0 : if (dev_caps->cap_flags & SXE2_DEV_CAPS_OFFLOAD_VLAN)
1320 : 0 : adapter->cap_flags |= SXE2_DEV_CAPS_OFFLOAD_VLAN;
1321 : :
1322 [ # # ]: 0 : if (dev_caps->cap_flags & SXE2_DEV_CAPS_OFFLOAD_RSS)
1323 : 0 : adapter->cap_flags |= SXE2_DEV_CAPS_OFFLOAD_RSS;
1324 : :
1325 [ # # ]: 0 : if (dev_caps->cap_flags & SXE2_DEV_CAPS_OFFLOAD_IPSEC)
1326 : 0 : adapter->cap_flags |= SXE2_DEV_CAPS_OFFLOAD_IPSEC;
1327 : :
1328 [ # # ]: 0 : if (dev_caps->cap_flags & SXE2_DEV_CAPS_OFFLOAD_FNAV)
1329 : 0 : adapter->cap_flags |= SXE2_DEV_CAPS_OFFLOAD_FNAV;
1330 : :
1331 [ # # ]: 0 : if (dev_caps->cap_flags & SXE2_DEV_CAPS_OFFLOAD_TM)
1332 : 0 : adapter->cap_flags |= SXE2_DEV_CAPS_OFFLOAD_TM;
1333 : :
1334 [ # # ]: 0 : if (dev_caps->cap_flags & SXE2_DEV_CAPS_OFFLOAD_PTP)
1335 : 0 : adapter->cap_flags |= SXE2_DEV_CAPS_OFFLOAD_PTP;
1336 : :
1337 [ # # ]: 0 : if (dev_caps->cap_flags & SXE2_DEV_CAPS_OFFLOAD_FC_STATE)
1338 : 0 : adapter->cap_flags |= SXE2_DEV_CAPS_OFFLOAD_FC_STATE;
1339 : 0 : }
1340 : :
1341 : 0 : static void sxe2_sw_representor_ctx_hw_cap_set(struct sxe2_adapter *adapter,
1342 : : struct sxe2_drv_representor_caps *repr_caps)
1343 : : {
1344 : 0 : adapter->repr_ctxt.nb_vf = repr_caps->cnt_repr_vf;
1345 : 0 : if (adapter->repr_ctxt.nb_vf > 0) {
1346 : 0 : memcpy(adapter->repr_ctxt.repr_vf_id, repr_caps->repr_vf_id,
1347 : 0 : adapter->repr_ctxt.nb_vf * sizeof(struct sxe2_drv_vsi_caps));
1348 : : }
1349 : : }
1350 : :
1351 : 0 : static void sxe2_sw_sched_hw_cap_set(struct sxe2_adapter *adapter,
1352 : : struct sxe2_txsch_caps *txsch_caps)
1353 : : {
1354 : 0 : adapter->sched_ctxt.tm_layers = txsch_caps->layer_cap;
1355 : 0 : adapter->sched_ctxt.root_max_children = txsch_caps->tm_mid_node_num;
1356 : 0 : adapter->sched_ctxt.prio_max = txsch_caps->prio_num;
1357 : 0 : }
1358 : :
1359 : 0 : static int32_t sxe2_func_caps_get(struct sxe2_adapter *adapter)
1360 : : {
1361 : 0 : int32_t ret = -1;
1362 : 0 : struct sxe2_drv_dev_caps_resp dev_caps = {0};
1363 : :
1364 : 0 : ret = sxe2_drv_dev_caps_get(adapter, &dev_caps);
1365 [ # # ]: 0 : if (ret)
1366 : 0 : goto l_end;
1367 : :
1368 : 0 : adapter->dev_type = dev_caps.dev_type;
1369 : 0 : adapter->port_idx = dev_caps.port_idx;
1370 : 0 : adapter->pf_idx = dev_caps.pf_idx;
1371 : :
1372 : 0 : sxe2_drv_dev_caps_set(adapter, &dev_caps);
1373 : :
1374 : 0 : sxe2_sw_queue_ctx_hw_cap_set(adapter, &dev_caps.queue_caps);
1375 : :
1376 : 0 : sxe2_sw_irq_ctx_hw_cap_set(adapter, &dev_caps.msix_caps);
1377 : :
1378 : 0 : sxe2_sw_rss_ctx_hw_cap_set(adapter, &dev_caps.rss_hash_caps);
1379 : :
1380 : 0 : sxe2_sw_vsi_ctx_hw_cap_set(adapter, &dev_caps.vsi_caps);
1381 : :
1382 [ # # ]: 0 : sxe2_sw_representor_ctx_hw_cap_set(adapter, &dev_caps.repr_caps);
1383 : :
1384 : 0 : sxe2_sw_sched_hw_cap_set(adapter, &dev_caps.txsch_caps);
1385 : :
1386 : 0 : l_end:
1387 : 0 : return ret;
1388 : : }
1389 : :
1390 : 0 : static int32_t sxe2_switchdev_info_get(struct sxe2_adapter *adapter)
1391 : : {
1392 : 0 : int32_t ret = 0;
1393 : 0 : struct sxe2_switchdev_info switchdev_info = {0};
1394 : :
1395 : 0 : ret = sxe2_drv_switchdev_info_get(adapter, &switchdev_info);
1396 [ # # ]: 0 : if (ret)
1397 : 0 : goto l_end;
1398 [ # # # # ]: 0 : if (switchdev_info.primary && switchdev_info.representor) {
1399 : 0 : PMD_LOG_ERR(INIT, "device could not be both primary and representor");
1400 : 0 : ret = -ENODEV;
1401 : 0 : goto l_end;
1402 : : }
1403 : 0 : adapter->switchdev_info = switchdev_info;
1404 : 0 : l_end:
1405 : 0 : return ret;
1406 : : }
1407 : :
1408 : 0 : static int32_t sxe2_dev_caps_get(struct sxe2_adapter *adapter)
1409 : : {
1410 : 0 : int32_t ret = -1;
1411 : :
1412 : 0 : ret = sxe2_func_caps_get(adapter);
1413 [ # # ]: 0 : if (ret) {
1414 : 0 : PMD_LOG_ERR(INIT, "get function caps failed, ret=%d", ret);
1415 : 0 : goto l_end;
1416 : : }
1417 : :
1418 : 0 : ret = sxe2_switchdev_info_get(adapter);
1419 [ # # ]: 0 : if (ret)
1420 : 0 : PMD_LOG_ERR(INIT, "get switchdev info failed, ret=%d", ret);
1421 : :
1422 : 0 : l_end:
1423 : 0 : return ret;
1424 : : }
1425 : :
1426 : 0 : uint32_t sxe2_pci_map_read_reg(struct sxe2_adapter *adapter,
1427 : : enum sxe2_pci_map_resource res_type, uint16_t idx_in_func)
1428 : : {
1429 : 0 : void *reg_addr;
1430 : 0 : uint32_t value;
1431 : :
1432 : 0 : reg_addr = sxe2_pci_map_addr_get(adapter, res_type, idx_in_func);
1433 [ # # ]: 0 : if (unlikely(reg_addr == NULL)) {
1434 : 0 : PMD_DEV_LOG_ERR(adapter, DRV, "reg addr:0x%p is error.", reg_addr);
1435 : 0 : value = SXE2_PCI_MAP_INVALID_VAL;
1436 : 0 : goto l_ret;
1437 : : }
1438 : :
1439 : 0 : value = SXE2_PCI_REG_READ(reg_addr);
1440 : :
1441 : 0 : l_ret:
1442 : 0 : return value;
1443 : : }
1444 : :
1445 : 0 : void sxe2_pci_map_write_reg(struct sxe2_adapter *adapter,
1446 : : enum sxe2_pci_map_resource res_type, uint16_t idx_in_func, uint32_t value)
1447 : : {
1448 : 0 : void *reg_addr;
1449 : :
1450 : 0 : reg_addr = sxe2_pci_map_addr_get(adapter, res_type, idx_in_func);
1451 [ # # ]: 0 : if (unlikely(reg_addr == NULL)) {
1452 : 0 : PMD_DEV_LOG_ERR(adapter, DRV, "reg addr:0x%p is error.", reg_addr);
1453 : 0 : goto l_ret;
1454 : : }
1455 : :
1456 : 0 : SXE2_PCI_REG_WRITE(reg_addr, value);
1457 : 0 : l_ret:
1458 : 0 : return;
1459 : : }
1460 : :
1461 : 0 : int32_t sxe2_dev_pci_seg_map(struct sxe2_adapter *adapter,
1462 : : enum sxe2_pci_map_resource res_type,
1463 : : uint64_t org_len,
1464 : : uint64_t org_offset)
1465 : : {
1466 : 0 : struct sxe2_pci_map_bar_info *bar_info = NULL;
1467 : 0 : struct sxe2_pci_map_segment_info *seg_info = NULL;
1468 : 0 : void *map_addr = NULL;
1469 : 0 : int32_t ret = 0;
1470 : 0 : size_t page_size = 0;
1471 : 0 : size_t aligned_len = 0;
1472 : 0 : size_t page_inner_offset = 0;
1473 : 0 : off_t aligned_offset = 0;
1474 : 0 : uint8_t i = 0;
1475 : :
1476 [ # # ]: 0 : if (org_len == 0) {
1477 : 0 : PMD_DEV_LOG_ERR(adapter, INIT, "Invalid length, ori_len = 0");
1478 : 0 : ret = -EFAULT;
1479 : 0 : goto l_end;
1480 : : }
1481 : :
1482 : 0 : bar_info = sxe2_dev_get_bar_info(adapter, res_type);
1483 [ # # ]: 0 : if (!bar_info) {
1484 : 0 : PMD_LOG_ERR(INIT, "Failed to get bar info, res_type=[%d]", res_type);
1485 : 0 : ret = -EFAULT;
1486 : 0 : goto l_end;
1487 : : }
1488 : 0 : seg_info = bar_info->seg_info;
1489 : :
1490 : 0 : page_size = rte_mem_page_size();
1491 : :
1492 : 0 : aligned_offset = RTE_ALIGN_FLOOR(org_offset, page_size);
1493 : 0 : page_inner_offset = org_offset - aligned_offset;
1494 : 0 : aligned_len = RTE_ALIGN(page_inner_offset + org_len, page_size);
1495 : :
1496 : 0 : map_addr = sxe2_drv_dev_mmap(adapter->cdev, bar_info->bar_idx,
1497 : : aligned_len, aligned_offset);
1498 [ # # ]: 0 : if (!map_addr) {
1499 : 0 : PMD_LOG_ERR(INIT, "Failed to mmap BAR space, type=%d, len=%" PRIu64
1500 : : ", offset=%" PRIu64 ", page_size=%zu",
1501 : : res_type, org_len, org_offset, page_size);
1502 : 0 : ret = -EFAULT;
1503 : 0 : goto l_end;
1504 : : }
1505 : :
1506 [ # # ]: 0 : for (i = 0; i < bar_info->map_cnt; i++) {
1507 [ # # ]: 0 : if (seg_info[i].type != SXE2_PCI_MAP_RES_INVALID)
1508 : 0 : continue;
1509 : 0 : seg_info[i].type = res_type;
1510 : 0 : seg_info[i].addr = map_addr;
1511 : 0 : seg_info[i].page_inner_offset = page_inner_offset;
1512 : 0 : seg_info[i].len = aligned_len;
1513 : 0 : break;
1514 : : }
1515 [ # # ]: 0 : if (i == bar_info->map_cnt) {
1516 : 0 : PMD_LOG_ERR(INIT, "No memory to save resource, res_type=%d", res_type);
1517 : 0 : ret = -ENOMEM;
1518 : 0 : sxe2_drv_dev_munmap(adapter->cdev, map_addr, aligned_len);
1519 : 0 : goto l_end;
1520 : : }
1521 : :
1522 : 0 : l_end:
1523 : 0 : return ret;
1524 : : }
1525 : :
1526 : 0 : static int32_t sxe2_hw_init(struct rte_eth_dev *dev)
1527 : : {
1528 : 0 : struct sxe2_adapter *adapter = SXE2_DEV_PRIVATE_TO_ADAPTER(dev);
1529 : 0 : int32_t ret = -1;
1530 : :
1531 : 0 : PMD_INIT_FUNC_TRACE();
1532 : :
1533 : 0 : ret = sxe2_dev_caps_get(adapter);
1534 [ # # ]: 0 : if (ret)
1535 : 0 : PMD_LOG_ERR(INIT, "Failed to get device caps, ret=[%d]", ret);
1536 : :
1537 : 0 : return ret;
1538 : : }
1539 : :
1540 : 0 : static int32_t sxe2_sw_init(struct rte_eth_dev *dev)
1541 : : {
1542 : 0 : int32_t ret = -1;
1543 : :
1544 : 0 : PMD_INIT_FUNC_TRACE();
1545 : :
1546 : 0 : ret = sxe2_sw_irq_ctxt_init(dev);
1547 [ # # ]: 0 : if (ret) {
1548 : 0 : PMD_LOG_ERR(INIT, "Failed to sw irq ctxt init, ret=[%d]", ret);
1549 : 0 : goto l_end;
1550 : : }
1551 : :
1552 : 0 : l_end:
1553 : 0 : return ret;
1554 : : }
1555 : :
1556 : 0 : static void sxe2_sw_uninit(struct rte_eth_dev *dev)
1557 : : {
1558 : 0 : sxe2_sw_irq_ctxt_uninit(dev);
1559 : 0 : }
1560 : :
1561 : 0 : int32_t sxe2_dev_pci_res_seg_map(struct sxe2_adapter *adapter,
1562 : : uint32_t res_type,
1563 : : uint32_t item_cnt,
1564 : : uint32_t item_base)
1565 : : {
1566 : 0 : struct sxe2_pci_map_addr_info *addr_info = NULL;
1567 : 0 : int32_t ret = 0;
1568 : :
1569 [ # # ]: 0 : if (unlikely(res_type >= SXE2_PCI_MAP_RES_MAX_COUNT)) {
1570 : 0 : PMD_DEV_LOG_ERR(adapter, INIT, "Invalid resource type %u", res_type);
1571 : 0 : ret = -EINVAL;
1572 : 0 : goto l_end;
1573 : : }
1574 : :
1575 : 0 : addr_info = &adapter->map_ctxt.addr_info[res_type];
1576 [ # # # # ]: 0 : if (!addr_info || addr_info->bar_idx == SXE2_PCI_MAP_BAR_INVALID) {
1577 : 0 : PMD_DEV_LOG_ERR(adapter, INIT, "Invalid bar index with resource type %d", res_type);
1578 : 0 : ret = -EFAULT;
1579 : 0 : goto l_end;
1580 : : }
1581 : :
1582 : 0 : ret = sxe2_dev_pci_seg_map(adapter, res_type, item_cnt * addr_info->reg_width,
1583 : 0 : addr_info->addr_base + item_base * addr_info->reg_width);
1584 [ # # ]: 0 : if (ret != 0) {
1585 : 0 : PMD_DEV_LOG_ERR(adapter, INIT, "Failed to map resource, res_type=%d", res_type);
1586 : 0 : goto l_end;
1587 : : }
1588 : 0 : l_end:
1589 : 0 : return ret;
1590 : : }
1591 : :
1592 : 0 : void sxe2_dev_pci_seg_unmap(struct sxe2_adapter *adapter, uint32_t res_type)
1593 : : {
1594 : 0 : struct sxe2_pci_map_bar_info *bar_info = NULL;
1595 : 0 : struct sxe2_pci_map_segment_info *seg_info = NULL;
1596 : 0 : uint32_t i = 0;
1597 : :
1598 : 0 : bar_info = sxe2_dev_get_bar_info(adapter, res_type);
1599 [ # # ]: 0 : if (bar_info == NULL) {
1600 : 0 : PMD_DEV_LOG_WARN(adapter, INIT, "Failed to get bar info, res_type=[%d]", res_type);
1601 : 0 : goto l_end;
1602 : : }
1603 : 0 : seg_info = bar_info->seg_info;
1604 : :
1605 [ # # ]: 0 : for (i = 0; i < bar_info->map_cnt; i++) {
1606 [ # # ]: 0 : if (res_type == seg_info[i].type) {
1607 : 0 : (void)sxe2_drv_dev_munmap(adapter->cdev, seg_info[i].addr,
1608 : : seg_info[i].len);
1609 : 0 : memset(&seg_info[i], 0, sizeof(struct sxe2_pci_map_segment_info));
1610 : : break;
1611 : : }
1612 : : }
1613 : :
1614 : 0 : l_end:
1615 : 0 : return;
1616 : : }
1617 : :
1618 : 0 : static int32_t sxe2_dev_info_init(struct rte_eth_dev *dev)
1619 : : {
1620 : 0 : struct sxe2_adapter *adapter =
1621 : 0 : SXE2_DEV_PRIVATE_TO_ADAPTER(dev);
1622 : 0 : struct rte_pci_device *pci_dev = RTE_CLASS_TO_BUS_DEVICE(dev, *pci_dev);
1623 : 0 : struct sxe2_dev_info *dev_info = &adapter->dev_info;
1624 : 0 : struct sxe2_drv_dev_info_resp dev_info_resp = {0};
1625 : 0 : struct sxe2_drv_dev_fw_info_resp dev_fw_info_resp = {0};
1626 : 0 : int32_t ret = 0;
1627 : :
1628 : 0 : dev_info->pci.bus_devid = pci_dev->addr.devid;
1629 : 0 : dev_info->pci.bus_function = pci_dev->addr.function;
1630 : :
1631 : 0 : ret = sxe2_drv_dev_info_get(adapter, &dev_info_resp);
1632 [ # # ]: 0 : if (ret) {
1633 : 0 : PMD_LOG_ERR(INIT, "Failed to get device info, ret=[%d]", ret);
1634 : 0 : goto l_end;
1635 : : }
1636 : 0 : dev_info->pci.serial_number = dev_info_resp.dsn;
1637 : :
1638 : 0 : ret = sxe2_drv_dev_fw_info_get(adapter, &dev_fw_info_resp);
1639 [ # # ]: 0 : if (ret) {
1640 : 0 : PMD_LOG_ERR(INIT, "Failed to get device fw info, ret=[%d]", ret);
1641 : 0 : goto l_end;
1642 : : }
1643 : 0 : dev_info->fw.build_id = dev_fw_info_resp.build_id;
1644 : 0 : dev_info->fw.fix_version_id = dev_fw_info_resp.fix_version_id;
1645 : 0 : dev_info->fw.sub_version_id = dev_fw_info_resp.sub_version_id;
1646 : 0 : dev_info->fw.main_version_id = dev_fw_info_resp.main_version_id;
1647 : :
1648 [ # # ]: 0 : if (rte_is_valid_assigned_ether_addr((struct rte_ether_addr *)dev_info_resp.mac_addr))
1649 : 0 : rte_ether_addr_copy((struct rte_ether_addr *)dev_info_resp.mac_addr,
1650 : 0 : (struct rte_ether_addr *)dev_info->mac.perm_addr);
1651 : : else
1652 : 0 : rte_eth_random_addr(dev_info->mac.perm_addr);
1653 : :
1654 : 0 : l_end:
1655 : 0 : return ret;
1656 : : }
1657 : :
1658 : 0 : int32_t sxe2_dev_pci_map_init(struct rte_eth_dev *dev)
1659 : : {
1660 : 0 : struct sxe2_adapter *adapter = SXE2_DEV_PRIVATE_TO_ADAPTER(dev);
1661 : 0 : struct rte_pci_device *pci_dev = RTE_CLASS_TO_BUS_DEVICE(dev, *pci_dev);
1662 : 0 : struct sxe2_pci_map_context *map_ctxt = &adapter->map_ctxt;
1663 : 0 : struct sxe2_pci_map_bar_info *bar_info = NULL;
1664 : 0 : struct sxe2_pci_map_segment_info *seg_info = NULL;
1665 : 0 : uint16_t txq_cnt = adapter->q_ctxt.qp_cnt_assign;
1666 : 0 : uint16_t txq_base = adapter->q_ctxt.base_idx_in_pf;
1667 : 0 : uint16_t rxq_cnt = adapter->q_ctxt.qp_cnt_assign;
1668 : 0 : uint16_t irq_cnt = adapter->irq_ctxt.max_cnt_hw;
1669 : 0 : uint16_t irq_base = adapter->irq_ctxt.base_idx_in_func;
1670 : 0 : uint16_t rxq_base = adapter->q_ctxt.base_idx_in_pf;
1671 : 0 : int32_t ret = 0;
1672 : :
1673 : 0 : PMD_INIT_FUNC_TRACE();
1674 : :
1675 : 0 : adapter->dev_info.dev_data = dev->data;
1676 : :
1677 [ # # ]: 0 : if (!pci_dev->mem_resource[0].phys_addr) {
1678 : 0 : PMD_LOG_ERR(INIT, "Physical address not scanned");
1679 : 0 : ret = -ENXIO;
1680 : 0 : goto l_end;
1681 : : }
1682 : :
1683 : 0 : map_ctxt->bar_cnt = 2;
1684 : :
1685 : 0 : bar_info = rte_zmalloc(NULL, sizeof(*bar_info) * map_ctxt->bar_cnt, 0);
1686 [ # # ]: 0 : if (!bar_info) {
1687 : 0 : PMD_LOG_ERR(INIT, "Failed to alloc bar_info");
1688 : 0 : ret = -ENOMEM;
1689 : 0 : goto l_end;
1690 : : }
1691 : 0 : bar_info[0].bar_idx = 0;
1692 : 0 : bar_info[0].map_cnt = SXE2_PCI_MAP_RES_MAX_COUNT;
1693 : 0 : seg_info = rte_zmalloc(NULL, sizeof(*seg_info) * bar_info[0].map_cnt, 0);
1694 [ # # ]: 0 : if (!seg_info) {
1695 : 0 : PMD_LOG_ERR(INIT, "Failed to alloc seg_info");
1696 : 0 : ret = -ENOMEM;
1697 : 0 : goto l_free_bar;
1698 : : }
1699 : :
1700 : 0 : bar_info[0].seg_info = seg_info;
1701 : :
1702 : 0 : bar_info[1].bar_idx = 4;
1703 : 0 : bar_info[1].map_cnt = SXE2_PCI_MAP_RES_MAX_COUNT;
1704 : 0 : seg_info = rte_zmalloc(NULL, sizeof(*seg_info) * bar_info[1].map_cnt, 0);
1705 [ # # ]: 0 : if (!seg_info) {
1706 : 0 : PMD_LOG_ERR(INIT, "Failed to alloc seg_info");
1707 : 0 : ret = -ENOMEM;
1708 : 0 : goto l_free_seg0;
1709 : : }
1710 : :
1711 : 0 : bar_info[1].seg_info = seg_info;
1712 : 0 : map_ctxt->bar_info = bar_info;
1713 : :
1714 [ # # ]: 0 : if (adapter->dev_type == SXE2_DEV_T_VF)
1715 : 0 : map_ctxt->addr_info = sxe2_net_map_addr_info_vf;
1716 : : else
1717 : 0 : map_ctxt->addr_info = sxe2_net_map_addr_info_pf;
1718 : :
1719 : 0 : ret = sxe2_dev_pci_res_seg_map(adapter, SXE2_PCI_MAP_RES_DOORBELL_TX,
1720 : : txq_cnt, txq_base);
1721 [ # # ]: 0 : if (ret) {
1722 : 0 : PMD_LOG_ERR(INIT, "Failed to map txq doorbell addr, ret=%d", ret);
1723 : 0 : goto l_free_seg1;
1724 : : }
1725 : :
1726 : 0 : ret = sxe2_dev_pci_res_seg_map(adapter, SXE2_PCI_MAP_RES_DOORBELL_RX_TAIL,
1727 : : rxq_cnt, rxq_base);
1728 [ # # ]: 0 : if (ret) {
1729 : 0 : PMD_LOG_ERR(INIT, "Failed to map rxq tail doorbell addr, ret=%d", ret);
1730 : 0 : goto l_free_txq;
1731 : : }
1732 : :
1733 : 0 : ret = sxe2_dev_pci_res_seg_map(adapter, SXE2_PCI_MAP_RES_IRQ_DYN,
1734 : : irq_cnt, irq_base);
1735 [ # # ]: 0 : if (ret) {
1736 : 0 : PMD_LOG_ERR(INIT, "Failed to map irq dyn addr, ret=%d", ret);
1737 : 0 : goto l_free_rxq_tail;
1738 : : }
1739 : :
1740 : 0 : ret = sxe2_dev_pci_res_seg_map(adapter, SXE2_PCI_MAP_RES_IRQ_ITR,
1741 : : irq_cnt, irq_base);
1742 [ # # ]: 0 : if (ret) {
1743 : 0 : PMD_LOG_ERR(INIT, "Failed to map irq itr addr, ret=%d", ret);
1744 : 0 : goto l_free_irq_dyn;
1745 : : }
1746 : :
1747 : 0 : ret = sxe2_dev_pci_res_seg_map(adapter, SXE2_PCI_MAP_RES_IRQ_MSIX,
1748 : : irq_cnt, irq_base);
1749 [ # # ]: 0 : if (ret) {
1750 : 0 : PMD_LOG_ERR(INIT, "Failed to map irq msix addr, ret=%d", ret);
1751 : 0 : goto l_free_irq_itr;
1752 : : }
1753 : 0 : goto l_end;
1754 : :
1755 : 0 : l_free_irq_itr:
1756 : 0 : (void)sxe2_dev_pci_seg_unmap(adapter, SXE2_PCI_MAP_RES_IRQ_ITR);
1757 : 0 : l_free_irq_dyn:
1758 : 0 : (void)sxe2_dev_pci_seg_unmap(adapter, SXE2_PCI_MAP_RES_IRQ_DYN);
1759 : 0 : l_free_rxq_tail:
1760 : 0 : (void)sxe2_dev_pci_seg_unmap(adapter, SXE2_PCI_MAP_RES_DOORBELL_RX_TAIL);
1761 : 0 : l_free_txq:
1762 : 0 : (void)sxe2_dev_pci_seg_unmap(adapter, SXE2_PCI_MAP_RES_DOORBELL_TX);
1763 : 0 : l_free_seg1:
1764 [ # # ]: 0 : if (bar_info[1].seg_info) {
1765 : 0 : rte_free(bar_info[1].seg_info);
1766 : 0 : bar_info[1].seg_info = NULL;
1767 : : }
1768 : 0 : l_free_seg0:
1769 [ # # ]: 0 : if (bar_info[0].seg_info) {
1770 : 0 : rte_free(bar_info[0].seg_info);
1771 : 0 : bar_info[0].seg_info = NULL;
1772 : : }
1773 : 0 : l_free_bar:
1774 : 0 : if (bar_info) {
1775 : 0 : rte_free(bar_info);
1776 : 0 : bar_info = NULL;
1777 : : }
1778 : 0 : l_end:
1779 : 0 : return ret;
1780 : : }
1781 : :
1782 : 0 : void sxe2_dev_pci_map_uinit(struct rte_eth_dev *dev)
1783 : : {
1784 : 0 : struct sxe2_adapter *adapter = SXE2_DEV_PRIVATE_TO_ADAPTER(dev);
1785 : 0 : struct sxe2_pci_map_context *map_ctxt = &adapter->map_ctxt;
1786 : 0 : struct sxe2_pci_map_bar_info *bar_info = NULL;
1787 : 0 : uint8_t i = 0;
1788 : :
1789 : 0 : PMD_INIT_FUNC_TRACE();
1790 [ # # ]: 0 : if (map_ctxt->bar_info != NULL) {
1791 : 0 : (void)sxe2_dev_pci_seg_unmap(adapter, SXE2_PCI_MAP_RES_DOORBELL_RX_TAIL);
1792 : 0 : (void)sxe2_dev_pci_seg_unmap(adapter, SXE2_PCI_MAP_RES_DOORBELL_TX);
1793 : 0 : (void)sxe2_dev_pci_seg_unmap(adapter, SXE2_PCI_MAP_RES_IRQ_DYN);
1794 : 0 : (void)sxe2_dev_pci_seg_unmap(adapter, SXE2_PCI_MAP_RES_IRQ_ITR);
1795 : 0 : (void)sxe2_dev_pci_seg_unmap(adapter, SXE2_PCI_MAP_RES_IRQ_MSIX);
1796 : :
1797 [ # # ]: 0 : for (i = 0; i < map_ctxt->bar_cnt; i++) {
1798 : 0 : bar_info = &map_ctxt->bar_info[i];
1799 [ # # # # ]: 0 : if (bar_info != NULL && bar_info->seg_info != NULL) {
1800 : 0 : rte_free(bar_info->seg_info);
1801 : 0 : bar_info->seg_info = NULL;
1802 : : }
1803 : : }
1804 : 0 : rte_free(map_ctxt->bar_info);
1805 : 0 : map_ctxt->bar_info = NULL;
1806 : : }
1807 : 0 : adapter->dev_info.dev_data = NULL;
1808 : 0 : }
1809 : :
1810 : 0 : static int32_t sxe2_fc_state_init(struct rte_eth_dev *dev)
1811 : : {
1812 : 0 : struct sxe2_adapter *adapter =
1813 : 0 : SXE2_DEV_PRIVATE_TO_ADAPTER(dev);
1814 : 0 : struct sxe2_drv_vsi_fc_get_resp fc_resp = {0};
1815 : 0 : int32_t ret;
1816 : :
1817 [ # # ]: 0 : if (!(adapter->cap_flags & SXE2_DEV_CAPS_OFFLOAD_FC_STATE)) {
1818 : 0 : adapter->fc_state_ctx.cfg_state = 0;
1819 : 0 : adapter->fc_state_ctx.curr_state = 0;
1820 : 0 : ret = 0;
1821 : 0 : goto l_end;
1822 : : }
1823 : 0 : ret = sxe2_drv_fc_state_get(adapter, &fc_resp);
1824 [ # # ]: 0 : if (ret) {
1825 : 0 : PMD_LOG_ERR(INIT, "Failed to get fc state, ret=[%d]", ret);
1826 : 0 : goto l_end;
1827 : : }
1828 : 0 : adapter->fc_state_ctx.cfg_state = fc_resp.fc_enable;
1829 : 0 : adapter->fc_state_ctx.curr_state = 0;
1830 : 0 : l_end:
1831 : 0 : return ret;
1832 : : }
1833 : 0 : static void sxe2_fc_state_uinit(struct rte_eth_dev *dev)
1834 : : {
1835 : 0 : struct sxe2_adapter *adapter =
1836 : 0 : SXE2_DEV_PRIVATE_TO_ADAPTER(dev);
1837 : 0 : adapter->fc_state_ctx.cfg_state = 0;
1838 : 0 : adapter->fc_state_ctx.curr_state = 0;
1839 : 0 : }
1840 : :
1841 : 0 : uint32_t sxe2_sched_mode_get(struct sxe2_adapter *adapter)
1842 : : {
1843 : 0 : uint32_t ret_mode = SXE2_SCHED_MODE_INVALID;
1844 : 0 : struct sxe2_tm_context *tm_ctxt = &adapter->tm_ctxt;
1845 : :
1846 [ # # ]: 0 : if (adapter->devargs.no_sched_mode)
1847 : : ret_mode = SXE2_SCHED_MODE_NO_SCHED;
1848 [ # # ]: 0 : else if (tm_ctxt->committed)
1849 : : ret_mode = SXE2_SCHED_MODE_TM;
1850 : : else
1851 : 0 : ret_mode = SXE2_SCHED_MODE_DEFAULT;
1852 : :
1853 : 0 : return ret_mode;
1854 : : }
1855 : :
1856 : 0 : static int32_t sxe2_sched_init(struct rte_eth_dev *dev)
1857 : : {
1858 : 0 : struct sxe2_adapter *adapter = SXE2_DEV_PRIVATE_TO_ADAPTER(dev);
1859 : 0 : int32_t ret = 0;
1860 : :
1861 : 0 : adapter->sched_ctxt.adj_lvl = adapter->devargs.sched_layer_mode;
1862 : :
1863 [ # # ]: 0 : if (adapter->devargs.no_sched_mode) {
1864 : 0 : PMD_LOG_DEBUG(DRV, "TM feature will be disabled in high-performance mode.");
1865 : 0 : adapter->cap_flags &= ~(SXE2_DEV_CAPS_OFFLOAD_TM);
1866 : : } else {
1867 : 0 : ret = sxe2_tm_init(dev);
1868 [ # # ]: 0 : if (ret)
1869 : 0 : goto l_end;
1870 : :
1871 : 0 : ret = sxe2_drv_root_tree_alloc(dev);
1872 [ # # ]: 0 : if (ret)
1873 : 0 : goto l_end;
1874 : : }
1875 : :
1876 : 0 : l_end:
1877 : 0 : return ret;
1878 : : }
1879 : :
1880 : 0 : static int32_t sxe2_sched_uinit(struct rte_eth_dev *dev)
1881 : : {
1882 : 0 : struct sxe2_adapter *adapter = SXE2_DEV_PRIVATE_TO_ADAPTER(dev);
1883 : 0 : int32_t ret = 0;
1884 : :
1885 [ # # ]: 0 : if (!adapter->devargs.no_sched_mode) {
1886 : 0 : ret = sxe2_tm_uninit(dev);
1887 [ # # ]: 0 : if (ret) {
1888 : 0 : PMD_LOG_ERR(INIT, "Failed to uninit tm, ret=%d", ret);
1889 : 0 : goto l_end;
1890 : : }
1891 : :
1892 : 0 : ret = sxe2_drv_root_tree_release(dev);
1893 [ # # ]: 0 : if (ret) {
1894 : 0 : PMD_LOG_ERR(INIT, "Failed to release root tree, ret=%d", ret);
1895 : 0 : goto l_end;
1896 : : }
1897 : : }
1898 : :
1899 : 0 : l_end:
1900 : 0 : return ret;
1901 : : }
1902 : :
1903 : 0 : static int32_t sxe2_dev_init(struct rte_eth_dev *dev,
1904 : : __rte_unused struct sxe2_dev_kvargs_info *kvargs)
1905 : : {
1906 : 0 : int32_t ret = 0;
1907 : :
1908 : 0 : PMD_INIT_FUNC_TRACE();
1909 : :
1910 : 0 : sxe2_set_common_function(dev);
1911 : :
1912 : 0 : dev->dev_ops = &sxe2_eth_dev_ops;
1913 : :
1914 [ # # ]: 0 : if (rte_eal_process_type() != RTE_PROC_PRIMARY) {
1915 : 0 : sxe2_rx_mode_func_set(dev);
1916 : 0 : sxe2_tx_mode_func_set(dev);
1917 : 0 : ret = sxe2_mp_init(dev);
1918 [ # # ]: 0 : if (ret != 0)
1919 : 0 : PMD_LOG_ERR(INIT, "Failed to mp init (secondary), ret=%d", ret);
1920 : 0 : goto l_end;
1921 : : }
1922 : :
1923 : 0 : ret = sxe2_args_parse(dev, kvargs);
1924 [ # # ]: 0 : if (ret) {
1925 : 0 : PMD_LOG_ERR(INIT, "Failed to parse devargs, ret=%d", ret);
1926 : 0 : goto l_end;
1927 : : }
1928 : :
1929 : 0 : ret = sxe2_hw_init(dev);
1930 [ # # ]: 0 : if (ret) {
1931 : 0 : PMD_LOG_ERR(INIT, "Failed to initialize hw, ret=[%d]", ret);
1932 : 0 : goto l_end;
1933 : : }
1934 : :
1935 : 0 : ret = sxe2_dev_pci_map_init(dev);
1936 [ # # ]: 0 : if (ret) {
1937 : 0 : PMD_LOG_ERR(INIT, "Failed to pci addr map, ret=[%d]", ret);
1938 : 0 : goto l_end;
1939 : : }
1940 : :
1941 : 0 : ret = sxe2_vsi_init(dev);
1942 [ # # ]: 0 : if (ret) {
1943 : 0 : PMD_LOG_ERR(INIT, "create main vsi failed, ret=%d", ret);
1944 : 0 : goto init_vsi_err;
1945 : : }
1946 : :
1947 : 0 : ret = sxe2_dev_info_init(dev);
1948 [ # # ]: 0 : if (ret) {
1949 : 0 : PMD_LOG_ERR(INIT, "Failed to get device info, ret=[%d]", ret);
1950 : 0 : goto init_dev_info_err;
1951 : : }
1952 : :
1953 : 0 : ret = sxe2_switchdev_init(dev);
1954 [ # # ]: 0 : if (ret) {
1955 : 0 : PMD_LOG_ERR(INIT, "Failed to initialize switchdev mode, ret=[%d]", ret);
1956 : 0 : goto init_switchdev_err;
1957 : : }
1958 : :
1959 : 0 : ret = sxe2_eth_init(dev);
1960 [ # # ]: 0 : if (ret) {
1961 : 0 : PMD_LOG_ERR(INIT, "Failed to initialize eth parameters, ret=%d", ret);
1962 : 0 : goto init_eth_err;
1963 : : }
1964 : :
1965 : 0 : ret = sxe2_sw_init(dev);
1966 [ # # ]: 0 : if (ret) {
1967 : 0 : PMD_LOG_ERR(INIT, "Failed to initialize sw parameters, ret=[%d]", ret);
1968 : 0 : goto init_sw_err;
1969 : : }
1970 : :
1971 : 0 : ret = sxe2_intr_init(dev);
1972 [ # # ]: 0 : if (ret != 0) {
1973 : 0 : PMD_LOG_ERR(INIT, "Failed to initialize interrupt, ret:%d", ret);
1974 : 0 : goto init_irq_err;
1975 : : }
1976 : :
1977 : 0 : ret = sxe2_security_init(dev);
1978 [ # # ]: 0 : if (ret) {
1979 : 0 : PMD_LOG_ERR(INIT, "Failed to initialize security, ret=%d", ret);
1980 : 0 : goto init_security_err;
1981 : : }
1982 : :
1983 : 0 : ret = sxe2_rss_disable(dev);
1984 [ # # ]: 0 : if (ret) {
1985 : 0 : PMD_LOG_ERR(INIT, "Failed to disable rss, ret=%d", ret);
1986 : 0 : goto init_rss_err;
1987 : : }
1988 : :
1989 : 0 : ret = sxe2_flow_init(dev);
1990 [ # # ]: 0 : if (ret) {
1991 : 0 : PMD_LOG_ERR(INIT, "Failed to init flow, ret=%d", ret);
1992 : 0 : goto init_flow_err;
1993 : : }
1994 : :
1995 : 0 : ret = sxe2_fc_state_init(dev);
1996 [ # # ]: 0 : if (ret) {
1997 : 0 : PMD_LOG_ERR(INIT, "Failed to init fc state, ret=%d", ret);
1998 : 0 : goto init_fc_state_err;
1999 : : }
2000 : :
2001 : 0 : ret = sxe2_sched_init(dev);
2002 [ # # ]: 0 : if (ret) {
2003 : 0 : PMD_LOG_ERR(INIT, "Failed to init sched, ret=%d", ret);
2004 : 0 : goto init_sched_err;
2005 : : }
2006 : :
2007 : 0 : ret = sxe2_stats_init(dev);
2008 [ # # ]: 0 : if (ret) {
2009 : 0 : PMD_LOG_ERR(INIT, "Failed to stats init, ret=%d", ret);
2010 : 0 : goto init_xstats_err;
2011 : : }
2012 : :
2013 : 0 : ret = sxe2_mp_init(dev);
2014 [ # # ]: 0 : if (ret) {
2015 : 0 : PMD_LOG_ERR(INIT, "Failed to mp init, ret=%d", ret);
2016 : 0 : goto init_xstats_err;
2017 : : }
2018 : :
2019 : 0 : goto l_end;
2020 : :
2021 : 0 : init_xstats_err:
2022 : 0 : (void)sxe2_sched_uinit(dev);
2023 : 0 : init_sched_err:
2024 : 0 : sxe2_fc_state_uinit(dev);
2025 : 0 : init_fc_state_err:
2026 : 0 : (void)sxe2_flow_uninit(dev);
2027 : 0 : init_flow_err:
2028 : 0 : init_rss_err:
2029 : 0 : sxe2_security_uinit(dev);
2030 : 0 : init_security_err:
2031 : 0 : sxe2_intr_uninit(dev);
2032 : 0 : init_irq_err:
2033 : 0 : sxe2_sw_uninit(dev);
2034 : 0 : init_sw_err:
2035 : 0 : sxe2_eth_uinit(dev);
2036 : 0 : init_eth_err:
2037 : 0 : (void)sxe2_switchdev_uninit(dev);
2038 : 0 : init_switchdev_err:
2039 : 0 : init_dev_info_err:
2040 : 0 : sxe2_vsi_uninit(dev);
2041 : 0 : init_vsi_err:
2042 : 0 : sxe2_dev_pci_map_uinit(dev);
2043 : 0 : l_end:
2044 : 0 : return ret;
2045 : : }
2046 : :
2047 : 0 : static int32_t sxe2_dev_close(struct rte_eth_dev *dev)
2048 : : {
2049 [ # # ]: 0 : if (rte_eal_process_type() != RTE_PROC_PRIMARY) {
2050 : 0 : sxe2_mp_uninit(dev);
2051 : 0 : goto l_end;
2052 : : }
2053 : 0 : sxe2_repr_all_close(dev);
2054 : 0 : (void)sxe2_dev_stop(dev);
2055 : 0 : (void)sxe2_queues_release(dev);
2056 : 0 : sxe2_mp_uninit(dev);
2057 : 0 : (void)sxe2_sched_uinit(dev);
2058 : 0 : (void)sxe2_flow_uninit(dev);
2059 : 0 : (void)sxe2_rss_disable(dev);
2060 : 0 : (void)sxe2_udp_tunnel_port_clear(dev);
2061 : 0 : sxe2_security_uinit(dev);
2062 : 0 : sxe2_intr_uninit(dev);
2063 : 0 : (void)sxe2_switchdev_uninit(dev);
2064 : 0 : sxe2_sw_uninit(dev);
2065 : 0 : sxe2_eth_uinit(dev);
2066 : 0 : sxe2_vsi_uninit(dev);
2067 : 0 : sxe2_dev_pci_map_uinit(dev);
2068 : 0 : sxe2_free_repr_info(dev);
2069 : 0 : sxe2_fc_state_uinit(dev);
2070 : :
2071 : 0 : l_end:
2072 : 0 : return 0;
2073 : : }
2074 : :
2075 : 0 : static int32_t sxe2_dev_uninit(struct rte_eth_dev *dev)
2076 : : {
2077 : 0 : int32_t ret = 0;
2078 : 0 : int32_t i = 0;
2079 : 0 : struct sxe2_adapter *adapter = NULL;
2080 : 0 : struct rte_eth_dev *rep_dev = NULL;
2081 : :
2082 [ # # ]: 0 : if (rte_eal_process_type() != RTE_PROC_PRIMARY)
2083 : 0 : goto l_end;
2084 : :
2085 : 0 : adapter = SXE2_DEV_PRIVATE_TO_ADAPTER(dev);
2086 [ # # ]: 0 : for (i = 0; i < adapter->repr_ctxt.nb_repr_vf; i++) {
2087 : 0 : rep_dev = adapter->repr_ctxt.vf_rep_eth_dev[i];
2088 [ # # ]: 0 : if (rep_dev) {
2089 : 0 : ret = rep_dev->dev_ops->dev_close(rep_dev);
2090 [ # # ]: 0 : if (ret)
2091 : 0 : goto l_end;
2092 : 0 : rte_intr_instance_free(rep_dev->intr_handle);
2093 : 0 : ret = rte_eth_dev_release_port(rep_dev);
2094 [ # # ]: 0 : if (ret)
2095 : 0 : goto l_end;
2096 : 0 : adapter->repr_ctxt.vf_rep_eth_dev[i] = NULL;
2097 : : }
2098 : : }
2099 : :
2100 : 0 : ret = sxe2_dev_close(dev);
2101 [ # # ]: 0 : if (ret) {
2102 : 0 : PMD_LOG_ERR(INIT, "Sxe2 dev close failed, ret=%d", ret);
2103 : 0 : goto l_end;
2104 : : }
2105 : :
2106 : 0 : l_end:
2107 : 0 : return ret;
2108 : : }
2109 : :
2110 : 0 : static int32_t sxe2_eth_pmd_remove(struct sxe2_common_device *cdev)
2111 : : {
2112 : 0 : struct rte_eth_dev *eth_dev;
2113 : 0 : struct rte_pci_device *pci_dev = RTE_BUS_DEVICE(cdev->dev, *pci_dev);
2114 : 0 : int32_t ret = 0;
2115 : :
2116 : 0 : eth_dev = rte_eth_dev_allocated(pci_dev->device.name);
2117 [ # # ]: 0 : if (!eth_dev) {
2118 : 0 : PMD_LOG_INFO(INIT, "Sxe2 dev allocated failed");
2119 : 0 : goto l_end;
2120 : : }
2121 : :
2122 : 0 : ret = sxe2_dev_uninit(eth_dev);
2123 [ # # ]: 0 : if (ret) {
2124 : 0 : PMD_LOG_ERR(INIT, "Sxe2 dev uninit failed, ret=%d", ret);
2125 : 0 : goto l_end;
2126 : : }
2127 : 0 : (void)rte_eth_dev_release_port(eth_dev);
2128 : :
2129 : 0 : l_end:
2130 : 0 : return ret;
2131 : : }
2132 : :
2133 : 0 : static int32_t sxe2_fw_version_string_get(struct rte_eth_dev *dev, char *fw_version, size_t fw_size)
2134 : : {
2135 : 0 : struct sxe2_adapter *adapter =
2136 : 0 : SXE2_DEV_PRIVATE_TO_ADAPTER(dev);
2137 : 0 : struct sxe2_fw_info *fw_info = &adapter->dev_info.fw;
2138 : 0 : int32_t ret_len;
2139 : 0 : int32_t ret;
2140 : :
2141 : 0 : ret_len = snprintf(fw_version, fw_size,
2142 : : "%u.%u.%u.%u",
2143 : 0 : fw_info->main_version_id,
2144 : 0 : fw_info->sub_version_id,
2145 : 0 : fw_info->fix_version_id,
2146 [ # # ]: 0 : fw_info->build_id);
2147 : :
2148 [ # # ]: 0 : if (ret_len < 0) {
2149 : 0 : ret = -EINVAL;
2150 : 0 : goto out;
2151 : : }
2152 : :
2153 : 0 : ret_len += 1;
2154 [ # # ]: 0 : if (fw_size < (size_t)ret_len)
2155 : : ret = -EINVAL;
2156 : : else
2157 : 0 : ret = 0;
2158 : :
2159 : 0 : out:
2160 : 0 : return ret;
2161 : : }
2162 : :
2163 : 0 : static bool sxe2_switchdev_repr_match(struct sxe2_adapter *adapter,
2164 : : struct rte_eth_devargs *req_eth_da)
2165 : : {
2166 : 0 : uint16_t port_idx;
2167 : 0 : uint16_t repr_idx;
2168 : 0 : uint16_t vf_id;
2169 : 0 : uint16_t i;
2170 : :
2171 [ # # # # ]: 0 : switch (req_eth_da->type) {
2172 : 0 : case RTE_ETH_REPRESENTOR_PF:
2173 [ # # ]: 0 : if (adapter->switchdev_info.port_name_type !=
2174 : : SXE2_PHYS_PORT_NAME_TYPE_UPLINK) {
2175 : 0 : rte_errno = EBUSY;
2176 : 0 : return false;
2177 : : }
2178 : : break;
2179 : 0 : case RTE_ETH_REPRESENTOR_VF:
2180 [ # # ]: 0 : if (adapter->switchdev_info.port_name_type !=
2181 : : SXE2_PHYS_PORT_NAME_TYPE_PFVF) {
2182 : 0 : rte_errno = EBUSY;
2183 : 0 : return false;
2184 : : }
2185 : : break;
2186 : 0 : case RTE_ETH_REPRESENTOR_NONE:
2187 : 0 : rte_errno = EBUSY;
2188 : 0 : return false;
2189 : 0 : default:
2190 : 0 : rte_errno = ENOTSUP;
2191 : 0 : return false;
2192 : : }
2193 : :
2194 [ # # ]: 0 : if (req_eth_da->nb_ports > 0) {
2195 [ # # ]: 0 : for (port_idx = 0; port_idx < req_eth_da->nb_ports; ++port_idx) {
2196 [ # # ]: 0 : if (adapter->switchdev_info.pf_num == req_eth_da->ports[port_idx])
2197 : : break;
2198 : : }
2199 [ # # ]: 0 : if (port_idx == req_eth_da->nb_ports) {
2200 : 0 : PMD_DEV_LOG_DEBUG(adapter, DRV, "switchdev pf %u not match req pf",
2201 : : adapter->switchdev_info.pf_num);
2202 : 0 : rte_errno = EBUSY;
2203 : 0 : return false;
2204 : : }
2205 : : }
2206 : :
2207 [ # # ]: 0 : for (repr_idx = 0; repr_idx < req_eth_da->nb_representor_ports; ++repr_idx) {
2208 [ # # ]: 0 : for (i = 0; i < adapter->repr_ctxt.nb_vf; ++i) {
2209 : 0 : vf_id = rte_le_to_cpu_16(adapter->repr_ctxt.repr_vf_id[i].func_id);
2210 [ # # ]: 0 : if (vf_id == req_eth_da->representor_ports[repr_idx])
2211 : : break;
2212 : : }
2213 [ # # ]: 0 : if (i == adapter->repr_ctxt.nb_vf) {
2214 : 0 : PMD_DEV_LOG_DEBUG(adapter, DRV, "switchdev vf %u not match req vf(cnt:%u)",
2215 : : req_eth_da->representor_ports[repr_idx], adapter->repr_ctxt.nb_vf);
2216 : 0 : rte_errno = EBUSY;
2217 : 0 : return false;
2218 : : }
2219 : : }
2220 : :
2221 : : return true;
2222 : : }
2223 : :
2224 : 0 : static int32_t sxe2_eth_pmd_probe_pf(struct sxe2_common_device *cdev,
2225 : : struct rte_eth_devargs *req_eth_da __rte_unused,
2226 : : uint16_t owner_id __rte_unused,
2227 : : struct sxe2_dev_kvargs_info *kvargs)
2228 : : {
2229 : 0 : struct rte_pci_device *pci_dev = RTE_BUS_DEVICE(cdev->dev, *pci_dev);
2230 : 0 : struct rte_eth_dev *eth_dev = NULL;
2231 : 0 : struct sxe2_adapter *adapter = NULL;
2232 : 0 : int32_t ret = 0;
2233 : :
2234 : 0 : if (!cdev) {
2235 : : ret = -EINVAL;
2236 : : goto l_end;
2237 : : }
2238 : :
2239 : 0 : eth_dev = rte_eth_dev_pci_allocate(pci_dev, sizeof(struct sxe2_adapter));
2240 [ # # ]: 0 : if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
2241 [ # # ]: 0 : if (eth_dev == NULL) {
2242 : 0 : PMD_LOG_ERR(INIT, "Can not allocate ethdev");
2243 : 0 : ret = -ENOMEM;
2244 : 0 : goto l_end;
2245 : : }
2246 : : } else {
2247 [ # # ]: 0 : if (!eth_dev) {
2248 : 0 : PMD_LOG_DEBUG(INIT, "Can not attach secondary ethdev");
2249 : 0 : ret = -EINVAL;
2250 : 0 : goto l_end;
2251 : : }
2252 : : }
2253 : :
2254 : 0 : adapter = SXE2_DEV_PRIVATE_TO_ADAPTER(eth_dev);
2255 : 0 : adapter->dev_port_id = eth_dev->data->port_id;
2256 [ # # ]: 0 : if (rte_eal_process_type() == RTE_PROC_PRIMARY)
2257 : 0 : adapter->cdev = cdev;
2258 : :
2259 : 0 : ret = sxe2_dev_init(eth_dev, kvargs);
2260 [ # # ]: 0 : if (ret != 0) {
2261 : 0 : PMD_DEV_LOG_ERR(adapter, INIT, "Sxe2 dev init failed, ret=%d", ret);
2262 : 0 : goto l_release_port;
2263 : : }
2264 : :
2265 [ # # ]: 0 : if (req_eth_da->nb_representor_ports > 0) {
2266 [ # # ]: 0 : if (!adapter->switchdev_info.is_switchdev) {
2267 : 0 : PMD_DEV_LOG_ERR(adapter, INIT, "Representor requested but Switchdev not enabled");
2268 : 0 : ret = -ENOTSUP;
2269 : 0 : goto l_dev_uinit;
2270 : : }
2271 : :
2272 [ # # ]: 0 : if (!sxe2_switchdev_repr_match(adapter, req_eth_da)) {
2273 : 0 : PMD_DEV_LOG_ERR(adapter, INIT, "Representor parameters mismatch");
2274 : 0 : ret = -ENOTSUP;
2275 : 0 : goto l_dev_uinit;
2276 : : }
2277 : :
2278 : 0 : ret = sxe2_switchdev_repr_devs_init(adapter, req_eth_da);
2279 [ # # ]: 0 : if (ret) {
2280 : 0 : PMD_DEV_LOG_ERR(adapter, INIT, "Failed to init representor, ret=%d", ret);
2281 : 0 : goto l_dev_uinit;
2282 : : }
2283 : : } else {
2284 : 0 : PMD_DEV_LOG_DEBUG(adapter, INIT, "No representors requested, skipping.");
2285 : : }
2286 : :
2287 : 0 : rte_eth_dev_probing_finish(eth_dev);
2288 : 0 : PMD_DEV_LOG_DEBUG(adapter, INIT, "Sxe2 eth pmd probe successful!");
2289 : 0 : goto l_end;
2290 : :
2291 : 0 : l_dev_uinit:
2292 : 0 : (void)sxe2_dev_uninit(eth_dev);
2293 : 0 : l_release_port:
2294 : 0 : (void)rte_eth_dev_release_port(eth_dev);
2295 : 0 : l_end:
2296 : 0 : return ret;
2297 : : }
2298 : :
2299 : 0 : static int32_t sxe2_parse_eth_devargs(struct rte_device *dev,
2300 : : struct rte_eth_devargs *eth_da)
2301 : : {
2302 : 0 : int32_t ret = 0;
2303 : :
2304 [ # # ]: 0 : if (dev->devargs == NULL)
2305 : : return 0;
2306 : :
2307 [ # # ]: 0 : memset(eth_da, 0, sizeof(*eth_da));
2308 : :
2309 [ # # ]: 0 : if (dev->devargs->cls_str) {
2310 : 0 : ret = rte_eth_devargs_parse(dev->devargs->cls_str,
2311 : : eth_da,
2312 : : 1);
2313 [ # # ]: 0 : if (ret < 0) {
2314 : 0 : PMD_LOG_ERR(INIT, "Failed to parse device arguments: %s",
2315 : : dev->devargs->cls_str);
2316 : 0 : return ret;
2317 : : }
2318 : : }
2319 : :
2320 [ # # # # ]: 0 : if (eth_da->type == RTE_ETH_REPRESENTOR_NONE && dev->devargs->args) {
2321 : 0 : ret = rte_eth_devargs_parse(dev->devargs->args,
2322 : : eth_da,
2323 : : 1);
2324 [ # # ]: 0 : if (ret < 0) {
2325 : 0 : PMD_LOG_ERR(INIT, "Failed to parse device arguments: %s",
2326 : : dev->devargs->args);
2327 : 0 : return ret;
2328 : : }
2329 : : }
2330 : :
2331 : : return 0;
2332 : : }
2333 : :
2334 : 0 : static int32_t sxe2_eth_pmd_probe(struct sxe2_common_device *cdev,
2335 : : struct sxe2_dev_kvargs_info *kvargs)
2336 : : {
2337 : 0 : struct rte_eth_devargs eth_da = { .nb_ports = 0 };
2338 : 0 : int32_t ret = 0;
2339 : :
2340 : 0 : ret = sxe2_parse_eth_devargs(cdev->dev, ð_da);
2341 [ # # ]: 0 : if (ret != 0) {
2342 : 0 : ret = -EINVAL;
2343 : 0 : goto l_end;
2344 : : }
2345 : :
2346 : 0 : ret = sxe2_eth_pmd_probe_pf(cdev, ð_da, 0, kvargs);
2347 : :
2348 : 0 : l_end:
2349 : 0 : return ret;
2350 : : }
2351 : :
2352 : : static struct sxe2_class_driver sxe2_eth_pmd = {
2353 : : .drv_class = SXE2_CLASS_TYPE_ETH,
2354 : : .name = "SXE2_ETH_PMD_DRIVER_NAME",
2355 : : .probe = sxe2_eth_pmd_probe,
2356 : : .remove = sxe2_eth_pmd_remove,
2357 : : .id_table = pci_id_sxe2_tbl,
2358 : : .intr_lsc = 1,
2359 : : .intr_rmv = 1,
2360 : : };
2361 : :
2362 : 0 : bool sxe2_ethdev_check(struct rte_eth_dev *dev)
2363 : : {
2364 : 0 : return !strcmp(dev->device->driver->name, "sxe2_pci");
2365 : : }
2366 : :
2367 : 302 : RTE_INIT(rte_sxe2_pmd_init)
2368 : : {
2369 : 302 : sxe2_common_init();
2370 : 302 : sxe2_class_driver_register(&sxe2_eth_pmd);
2371 : 302 : }
2372 : :
2373 : : RTE_PMD_EXPORT_NAME(net_sxe2);
2374 : : RTE_PMD_REGISTER_PCI_TABLE(net_sxe2, pci_id_sxe2_tbl);
2375 : : RTE_PMD_REGISTER_KMOD_DEP(net_sxe2, "* sxe2");
2376 : : RTE_PMD_REGISTER_PARAM_STRING(net_sxe2,
2377 : : "flow-duplicate-pattern=<0|1|2> "
2378 : : "function-flow-direct=<0|1> "
2379 : : "fnav-stat-type=<1|2|3> "
2380 : : "acl-stat-type=<1|2|3> "
2381 : : "no-sched-mode=<0|1> "
2382 : : "sched-layer-mode=<0-3> "
2383 : : "rx-low-latency=<0|1>");
2384 : :
2385 [ - + ]: 302 : RTE_LOG_REGISTER_SUFFIX(sxe2_log_init, init, NOTICE);
2386 [ - + ]: 302 : RTE_LOG_REGISTER_SUFFIX(sxe2_log_driver, driver, NOTICE);
2387 [ - + ]: 302 : RTE_LOG_REGISTER_SUFFIX(sxe2_log_rx, rx, NOTICE);
2388 [ - + ]: 302 : RTE_LOG_REGISTER_SUFFIX(sxe2_log_tx, tx, NOTICE);
2389 [ - + ]: 302 : RTE_LOG_REGISTER_SUFFIX(sxe2_log_hw, hw, NOTICE);
|
