]> git.proxmox.com Git - ceph.git/blob - ceph/src/spdk/dpdk/drivers/net/atlantic/atl_ethdev.c
projects / ceph.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
import 15.2.0 Octopus source
[ceph.git] / ceph / src / spdk / dpdk / drivers / net / atlantic / atl_ethdev.c
1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2018 Aquantia Corporation
3 */
4
5 #include <rte_string_fns.h>
6 #include <rte_ethdev_pci.h>
7 #include <rte_alarm.h>
8
9 #include "atl_ethdev.h"
10 #include "atl_common.h"
11 #include "atl_hw_regs.h"
12 #include "atl_logs.h"
13 #include "hw_atl/hw_atl_llh.h"
14 #include "hw_atl/hw_atl_b0.h"
15 #include "hw_atl/hw_atl_b0_internal.h"
16
17 static int eth_atl_dev_init(struct rte_eth_dev *eth_dev);
18 static int eth_atl_dev_uninit(struct rte_eth_dev *eth_dev);
19
20 static int atl_dev_configure(struct rte_eth_dev *dev);
21 static int atl_dev_start(struct rte_eth_dev *dev);
22 static void atl_dev_stop(struct rte_eth_dev *dev);
23 static int atl_dev_set_link_up(struct rte_eth_dev *dev);
24 static int atl_dev_set_link_down(struct rte_eth_dev *dev);
25 static void atl_dev_close(struct rte_eth_dev *dev);
26 static int atl_dev_reset(struct rte_eth_dev *dev);
27 static void atl_dev_promiscuous_enable(struct rte_eth_dev *dev);
28 static void atl_dev_promiscuous_disable(struct rte_eth_dev *dev);
29 static void atl_dev_allmulticast_enable(struct rte_eth_dev *dev);
30 static void atl_dev_allmulticast_disable(struct rte_eth_dev *dev);
31 static int atl_dev_link_update(struct rte_eth_dev *dev, int wait);
32
33 static int atl_dev_xstats_get_names(struct rte_eth_dev *dev __rte_unused,
34 struct rte_eth_xstat_name *xstats_names,
35 unsigned int size);
36
37 static int atl_dev_stats_get(struct rte_eth_dev *dev,
38 struct rte_eth_stats *stats);
39
40 static int atl_dev_xstats_get(struct rte_eth_dev *dev,
41 struct rte_eth_xstat *stats, unsigned int n);
42
43 static void atl_dev_stats_reset(struct rte_eth_dev *dev);
44
45 static int atl_fw_version_get(struct rte_eth_dev *dev, char *fw_version,
46 size_t fw_size);
47
48 static void atl_dev_info_get(struct rte_eth_dev *dev,
49 struct rte_eth_dev_info *dev_info);
50
51 static const uint32_t *atl_dev_supported_ptypes_get(struct rte_eth_dev *dev);
52
53 static int atl_dev_mtu_set(struct rte_eth_dev *dev, uint16_t mtu);
54
55 /* VLAN stuff */
56 static int atl_vlan_filter_set(struct rte_eth_dev *dev,
57 uint16_t vlan_id, int on);
58
59 static int atl_vlan_offload_set(struct rte_eth_dev *dev, int mask);
60
61 static void atl_vlan_strip_queue_set(struct rte_eth_dev *dev,
62 uint16_t queue_id, int on);
63
64 static int atl_vlan_tpid_set(struct rte_eth_dev *dev,
65 enum rte_vlan_type vlan_type, uint16_t tpid);
66
67 /* EEPROM */
68 static int atl_dev_get_eeprom_length(struct rte_eth_dev *dev);
69 static int atl_dev_get_eeprom(struct rte_eth_dev *dev,
70 struct rte_dev_eeprom_info *eeprom);
71 static int atl_dev_set_eeprom(struct rte_eth_dev *dev,
72 struct rte_dev_eeprom_info *eeprom);
73
74 /* Regs */
75 static int atl_dev_get_regs(struct rte_eth_dev *dev,
76 struct rte_dev_reg_info *regs);
77
78 /* Flow control */
79 static int atl_flow_ctrl_get(struct rte_eth_dev *dev,
80 struct rte_eth_fc_conf *fc_conf);
81 static int atl_flow_ctrl_set(struct rte_eth_dev *dev,
82 struct rte_eth_fc_conf *fc_conf);
83
84 static void atl_dev_link_status_print(struct rte_eth_dev *dev);
85
86 /* Interrupts */
87 static int atl_dev_rxq_interrupt_setup(struct rte_eth_dev *dev);
88 static int atl_dev_lsc_interrupt_setup(struct rte_eth_dev *dev, uint8_t on);
89 static int atl_dev_interrupt_get_status(struct rte_eth_dev *dev);
90 static int atl_dev_interrupt_action(struct rte_eth_dev *dev,
91 struct rte_intr_handle *handle);
92 static void atl_dev_interrupt_handler(void *param);
93
94
95 static int atl_add_mac_addr(struct rte_eth_dev *dev,
96 struct ether_addr *mac_addr,
97 uint32_t index, uint32_t pool);
98 static void atl_remove_mac_addr(struct rte_eth_dev *dev, uint32_t index);
99 static int atl_set_default_mac_addr(struct rte_eth_dev *dev,
100 struct ether_addr *mac_addr);
101
102 static int atl_dev_set_mc_addr_list(struct rte_eth_dev *dev,
103 struct ether_addr *mc_addr_set,
104 uint32_t nb_mc_addr);
105
106 /* RSS */
107 static int atl_reta_update(struct rte_eth_dev *dev,
108 struct rte_eth_rss_reta_entry64 *reta_conf,
109 uint16_t reta_size);
110 static int atl_reta_query(struct rte_eth_dev *dev,
111 struct rte_eth_rss_reta_entry64 *reta_conf,
112 uint16_t reta_size);
113 static int atl_rss_hash_update(struct rte_eth_dev *dev,
114 struct rte_eth_rss_conf *rss_conf);
115 static int atl_rss_hash_conf_get(struct rte_eth_dev *dev,
116 struct rte_eth_rss_conf *rss_conf);
117
118
119 static int eth_atl_pci_probe(struct rte_pci_driver *pci_drv __rte_unused,
120 struct rte_pci_device *pci_dev);
121 static int eth_atl_pci_remove(struct rte_pci_device *pci_dev);
122
123 static void atl_dev_info_get(struct rte_eth_dev *dev,
124 struct rte_eth_dev_info *dev_info);
125
126 int atl_logtype_init;
127 int atl_logtype_driver;
128
129 /*
130 * The set of PCI devices this driver supports
131 */
132 static const struct rte_pci_id pci_id_atl_map[] = {
133 { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_0001) },
134 { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_D100) },
135 { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_D107) },
136 { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_D108) },
137 { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_D109) },
138
139 { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_AQC100) },
140 { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_AQC107) },
141 { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_AQC108) },
142 { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_AQC109) },
143 { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_AQC111) },
144 { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_AQC112) },
145
146 { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_AQC100S) },
147 { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_AQC107S) },
148 { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_AQC108S) },
149 { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_AQC109S) },
150 { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_AQC111S) },
151 { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_AQC112S) },
152
153 { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_AQC111E) },
154 { RTE_PCI_DEVICE(PCI_VENDOR_ID_AQUANTIA, AQ_DEVICE_ID_AQC112E) },
155 { .vendor_id = 0, /* sentinel */ },
156 };
157
158 static struct rte_pci_driver rte_atl_pmd = {
159 .id_table = pci_id_atl_map,
160 .drv_flags = RTE_PCI_DRV_NEED_MAPPING | RTE_PCI_DRV_INTR_LSC |
161 RTE_PCI_DRV_IOVA_AS_VA,
162 .probe = eth_atl_pci_probe,
163 .remove = eth_atl_pci_remove,
164 };
165
166 #define ATL_RX_OFFLOADS (DEV_RX_OFFLOAD_VLAN_STRIP \
167 | DEV_RX_OFFLOAD_IPV4_CKSUM \
168 | DEV_RX_OFFLOAD_UDP_CKSUM \
169 | DEV_RX_OFFLOAD_TCP_CKSUM \
170 | DEV_RX_OFFLOAD_JUMBO_FRAME \
171 | DEV_RX_OFFLOAD_MACSEC_STRIP \
172 | DEV_RX_OFFLOAD_VLAN_FILTER)
173
174 #define ATL_TX_OFFLOADS (DEV_TX_OFFLOAD_VLAN_INSERT \
175 | DEV_TX_OFFLOAD_IPV4_CKSUM \
176 | DEV_TX_OFFLOAD_UDP_CKSUM \
177 | DEV_TX_OFFLOAD_TCP_CKSUM \
178 | DEV_TX_OFFLOAD_TCP_TSO \
179 | DEV_TX_OFFLOAD_MACSEC_INSERT \
180 | DEV_TX_OFFLOAD_MULTI_SEGS)
181
182 #define SFP_EEPROM_SIZE 0x100
183
184 static const struct rte_eth_desc_lim rx_desc_lim = {
185 .nb_max = ATL_MAX_RING_DESC,
186 .nb_min = ATL_MIN_RING_DESC,
187 .nb_align = ATL_RXD_ALIGN,
188 };
189
190 static const struct rte_eth_desc_lim tx_desc_lim = {
191 .nb_max = ATL_MAX_RING_DESC,
192 .nb_min = ATL_MIN_RING_DESC,
193 .nb_align = ATL_TXD_ALIGN,
194 .nb_seg_max = ATL_TX_MAX_SEG,
195 .nb_mtu_seg_max = ATL_TX_MAX_SEG,
196 };
197
198 enum atl_xstats_type {
199 XSTATS_TYPE_MSM = 0,
200 XSTATS_TYPE_MACSEC,
201 };
202
203 #define ATL_XSTATS_FIELD(name) { \
204 #name, \
205 offsetof(struct aq_stats_s, name), \
206 XSTATS_TYPE_MSM \
207 }
208
209 #define ATL_MACSEC_XSTATS_FIELD(name) { \
210 #name, \
211 offsetof(struct macsec_stats, name), \
212 XSTATS_TYPE_MACSEC \
213 }
214
215 struct atl_xstats_tbl_s {
216 const char *name;
217 unsigned int offset;
218 enum atl_xstats_type type;
219 };
220
221 static struct atl_xstats_tbl_s atl_xstats_tbl[] = {
222 ATL_XSTATS_FIELD(uprc),
223 ATL_XSTATS_FIELD(mprc),
224 ATL_XSTATS_FIELD(bprc),
225 ATL_XSTATS_FIELD(erpt),
226 ATL_XSTATS_FIELD(uptc),
227 ATL_XSTATS_FIELD(mptc),
228 ATL_XSTATS_FIELD(bptc),
229 ATL_XSTATS_FIELD(erpr),
230 ATL_XSTATS_FIELD(ubrc),
231 ATL_XSTATS_FIELD(ubtc),
232 ATL_XSTATS_FIELD(mbrc),
233 ATL_XSTATS_FIELD(mbtc),
234 ATL_XSTATS_FIELD(bbrc),
235 ATL_XSTATS_FIELD(bbtc),
236 /* Ingress Common Counters */
237 ATL_MACSEC_XSTATS_FIELD(in_ctl_pkts),
238 ATL_MACSEC_XSTATS_FIELD(in_tagged_miss_pkts),
239 ATL_MACSEC_XSTATS_FIELD(in_untagged_miss_pkts),
240 ATL_MACSEC_XSTATS_FIELD(in_notag_pkts),
241 ATL_MACSEC_XSTATS_FIELD(in_untagged_pkts),
242 ATL_MACSEC_XSTATS_FIELD(in_bad_tag_pkts),
243 ATL_MACSEC_XSTATS_FIELD(in_no_sci_pkts),
244 ATL_MACSEC_XSTATS_FIELD(in_unknown_sci_pkts),
245 /* Ingress SA Counters */
246 ATL_MACSEC_XSTATS_FIELD(in_untagged_hit_pkts),
247 ATL_MACSEC_XSTATS_FIELD(in_not_using_sa),
248 ATL_MACSEC_XSTATS_FIELD(in_unused_sa),
249 ATL_MACSEC_XSTATS_FIELD(in_not_valid_pkts),
250 ATL_MACSEC_XSTATS_FIELD(in_invalid_pkts),
251 ATL_MACSEC_XSTATS_FIELD(in_ok_pkts),
252 ATL_MACSEC_XSTATS_FIELD(in_unchecked_pkts),
253 ATL_MACSEC_XSTATS_FIELD(in_validated_octets),
254 ATL_MACSEC_XSTATS_FIELD(in_decrypted_octets),
255 /* Egress Common Counters */
256 ATL_MACSEC_XSTATS_FIELD(out_ctl_pkts),
257 ATL_MACSEC_XSTATS_FIELD(out_unknown_sa_pkts),
258 ATL_MACSEC_XSTATS_FIELD(out_untagged_pkts),
259 ATL_MACSEC_XSTATS_FIELD(out_too_long),
260 /* Egress SC Counters */
261 ATL_MACSEC_XSTATS_FIELD(out_sc_protected_pkts),
262 ATL_MACSEC_XSTATS_FIELD(out_sc_encrypted_pkts),
263 /* Egress SA Counters */
264 ATL_MACSEC_XSTATS_FIELD(out_sa_hit_drop_redirect),
265 ATL_MACSEC_XSTATS_FIELD(out_sa_protected2_pkts),
266 ATL_MACSEC_XSTATS_FIELD(out_sa_protected_pkts),
267 ATL_MACSEC_XSTATS_FIELD(out_sa_encrypted_pkts),
268 };
269
270 static const struct eth_dev_ops atl_eth_dev_ops = {
271 .dev_configure = atl_dev_configure,
272 .dev_start = atl_dev_start,
273 .dev_stop = atl_dev_stop,
274 .dev_set_link_up = atl_dev_set_link_up,
275 .dev_set_link_down = atl_dev_set_link_down,
276 .dev_close = atl_dev_close,
277 .dev_reset = atl_dev_reset,
278
279 /* PROMISC */
280 .promiscuous_enable = atl_dev_promiscuous_enable,
281 .promiscuous_disable = atl_dev_promiscuous_disable,
282 .allmulticast_enable = atl_dev_allmulticast_enable,
283 .allmulticast_disable = atl_dev_allmulticast_disable,
284
285 /* Link */
286 .link_update = atl_dev_link_update,
287
288 .get_reg = atl_dev_get_regs,
289
290 /* Stats */
291 .stats_get = atl_dev_stats_get,
292 .xstats_get = atl_dev_xstats_get,
293 .xstats_get_names = atl_dev_xstats_get_names,
294 .stats_reset = atl_dev_stats_reset,
295 .xstats_reset = atl_dev_stats_reset,
296
297 .fw_version_get = atl_fw_version_get,
298 .dev_infos_get = atl_dev_info_get,
299 .dev_supported_ptypes_get = atl_dev_supported_ptypes_get,
300
301 .mtu_set = atl_dev_mtu_set,
302
303 /* VLAN */
304 .vlan_filter_set = atl_vlan_filter_set,
305 .vlan_offload_set = atl_vlan_offload_set,
306 .vlan_tpid_set = atl_vlan_tpid_set,
307 .vlan_strip_queue_set = atl_vlan_strip_queue_set,
308
309 /* Queue Control */
310 .rx_queue_start = atl_rx_queue_start,
311 .rx_queue_stop = atl_rx_queue_stop,
312 .rx_queue_setup = atl_rx_queue_setup,
313 .rx_queue_release = atl_rx_queue_release,
314
315 .tx_queue_start = atl_tx_queue_start,
316 .tx_queue_stop = atl_tx_queue_stop,
317 .tx_queue_setup = atl_tx_queue_setup,
318 .tx_queue_release = atl_tx_queue_release,
319
320 .rx_queue_intr_enable = atl_dev_rx_queue_intr_enable,
321 .rx_queue_intr_disable = atl_dev_rx_queue_intr_disable,
322
323 .rx_queue_count = atl_rx_queue_count,
324 .rx_descriptor_status = atl_dev_rx_descriptor_status,
325 .tx_descriptor_status = atl_dev_tx_descriptor_status,
326
327 /* EEPROM */
328 .get_eeprom_length = atl_dev_get_eeprom_length,
329 .get_eeprom = atl_dev_get_eeprom,
330 .set_eeprom = atl_dev_set_eeprom,
331
332 /* Flow Control */
333 .flow_ctrl_get = atl_flow_ctrl_get,
334 .flow_ctrl_set = atl_flow_ctrl_set,
335
336 /* MAC */
337 .mac_addr_add = atl_add_mac_addr,
338 .mac_addr_remove = atl_remove_mac_addr,
339 .mac_addr_set = atl_set_default_mac_addr,
340 .set_mc_addr_list = atl_dev_set_mc_addr_list,
341 .rxq_info_get = atl_rxq_info_get,
342 .txq_info_get = atl_txq_info_get,
343
344 .reta_update = atl_reta_update,
345 .reta_query = atl_reta_query,
346 .rss_hash_update = atl_rss_hash_update,
347 .rss_hash_conf_get = atl_rss_hash_conf_get,
348 };
349
350 static inline int32_t
351 atl_reset_hw(struct aq_hw_s *hw)
352 {
353 return hw_atl_b0_hw_reset(hw);
354 }
355
356 static inline void
357 atl_enable_intr(struct rte_eth_dev *dev)
358 {
359 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private);
360
361 hw_atl_itr_irq_msk_setlsw_set(hw, 0xffffffff);
362 }
363
364 static void
365 atl_disable_intr(struct aq_hw_s *hw)
366 {
367 PMD_INIT_FUNC_TRACE();
368 hw_atl_itr_irq_msk_clearlsw_set(hw, 0xffffffff);
369 }
370
371 static int
372 eth_atl_dev_init(struct rte_eth_dev *eth_dev)
373 {
374 struct atl_adapter *adapter =
375 (struct atl_adapter *)eth_dev->data->dev_private;
376 struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev);
377 struct rte_intr_handle *intr_handle = &pci_dev->intr_handle;
378 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private);
379 int err = 0;
380
381 PMD_INIT_FUNC_TRACE();
382
383 eth_dev->dev_ops = &atl_eth_dev_ops;
384 eth_dev->rx_pkt_burst = &atl_recv_pkts;
385 eth_dev->tx_pkt_burst = &atl_xmit_pkts;
386 eth_dev->tx_pkt_prepare = &atl_prep_pkts;
387
388 /* For secondary processes, the primary process has done all the work */
389 if (rte_eal_process_type() != RTE_PROC_PRIMARY)
390 return 0;
391
392 /* Vendor and Device ID need to be set before init of shared code */
393 hw->device_id = pci_dev->id.device_id;
394 hw->vendor_id = pci_dev->id.vendor_id;
395 hw->mmio = (void *)pci_dev->mem_resource[0].addr;
396
397 /* Hardware configuration - hardcode */
398 adapter->hw_cfg.is_lro = false;
399 adapter->hw_cfg.wol = false;
400 adapter->hw_cfg.is_rss = false;
401 adapter->hw_cfg.num_rss_queues = HW_ATL_B0_RSS_MAX;
402
403 adapter->hw_cfg.link_speed_msk = AQ_NIC_RATE_10G |
404 AQ_NIC_RATE_5G |
405 AQ_NIC_RATE_2G5 |
406 AQ_NIC_RATE_1G |
407 AQ_NIC_RATE_100M;
408
409 adapter->hw_cfg.flow_control = (AQ_NIC_FC_RX | AQ_NIC_FC_TX);
410 adapter->hw_cfg.aq_rss.indirection_table_size =
411 HW_ATL_B0_RSS_REDIRECTION_MAX;
412
413 hw->aq_nic_cfg = &adapter->hw_cfg;
414
415 /* disable interrupt */
416 atl_disable_intr(hw);
417
418 /* Allocate memory for storing MAC addresses */
419 eth_dev->data->mac_addrs = rte_zmalloc("atlantic", ETHER_ADDR_LEN, 0);
420 if (eth_dev->data->mac_addrs == NULL) {
421 PMD_INIT_LOG(ERR, "MAC Malloc failed");
422 return -ENOMEM;
423 }
424
425 err = hw_atl_utils_initfw(hw, &hw->aq_fw_ops);
426 if (err)
427 return err;
428
429 /* Copy the permanent MAC address */
430 if (hw->aq_fw_ops->get_mac_permanent(hw,
431 eth_dev->data->mac_addrs->addr_bytes) != 0)
432 return -EINVAL;
433
434 /* Reset the hw statistics */
435 atl_dev_stats_reset(eth_dev);
436
437 rte_intr_callback_register(intr_handle,
438 atl_dev_interrupt_handler, eth_dev);
439
440 /* enable uio/vfio intr/eventfd mapping */
441 rte_intr_enable(intr_handle);
442
443 /* enable support intr */
444 atl_enable_intr(eth_dev);
445
446 return err;
447 }
448
449 static int
450 eth_atl_dev_uninit(struct rte_eth_dev *eth_dev)
451 {
452 struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev);
453 struct rte_intr_handle *intr_handle = &pci_dev->intr_handle;
454 struct aq_hw_s *hw;
455
456 PMD_INIT_FUNC_TRACE();
457
458 if (rte_eal_process_type() != RTE_PROC_PRIMARY)
459 return -EPERM;
460
461 hw = ATL_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private);
462
463 if (hw->adapter_stopped == 0)
464 atl_dev_close(eth_dev);
465
466 eth_dev->dev_ops = NULL;
467 eth_dev->rx_pkt_burst = NULL;
468 eth_dev->tx_pkt_burst = NULL;
469
470 /* disable uio intr before callback unregister */
471 rte_intr_disable(intr_handle);
472 rte_intr_callback_unregister(intr_handle,
473 atl_dev_interrupt_handler, eth_dev);
474
475 rte_free(eth_dev->data->mac_addrs);
476 eth_dev->data->mac_addrs = NULL;
477
478 return 0;
479 }
480
481 static int
482 eth_atl_pci_probe(struct rte_pci_driver *pci_drv __rte_unused,
483 struct rte_pci_device *pci_dev)
484 {
485 return rte_eth_dev_pci_generic_probe(pci_dev,
486 sizeof(struct atl_adapter), eth_atl_dev_init);
487 }
488
489 static int
490 eth_atl_pci_remove(struct rte_pci_device *pci_dev)
491 {
492 return rte_eth_dev_pci_generic_remove(pci_dev, eth_atl_dev_uninit);
493 }
494
495 static int
496 atl_dev_configure(struct rte_eth_dev *dev)
497 {
498 struct atl_interrupt *intr =
499 ATL_DEV_PRIVATE_TO_INTR(dev->data->dev_private);
500
501 PMD_INIT_FUNC_TRACE();
502
503 /* set flag to update link status after init */
504 intr->flags |= ATL_FLAG_NEED_LINK_UPDATE;
505
506 return 0;
507 }
508
509 /*
510 * Configure device link speed and setup link.
511 * It returns 0 on success.
512 */
513 static int
514 atl_dev_start(struct rte_eth_dev *dev)
515 {
516 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private);
517 struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(dev);
518 struct rte_intr_handle *intr_handle = &pci_dev->intr_handle;
519 uint32_t intr_vector = 0;
520 int status;
521 int err;
522
523 PMD_INIT_FUNC_TRACE();
524
525 /* set adapter started */
526 hw->adapter_stopped = 0;
527
528 if (dev->data->dev_conf.link_speeds & ETH_LINK_SPEED_FIXED) {
529 PMD_INIT_LOG(ERR,
530 "Invalid link_speeds for port %u, fix speed not supported",
531 dev->data->port_id);
532 return -EINVAL;
533 }
534
535 /* disable uio/vfio intr/eventfd mapping */
536 rte_intr_disable(intr_handle);
537
538 /* reinitialize adapter
539 * this calls reset and start
540 */
541 status = atl_reset_hw(hw);
542 if (status != 0)
543 return -EIO;
544
545 err = hw_atl_b0_hw_init(hw, dev->data->mac_addrs->addr_bytes);
546
547 hw_atl_b0_hw_start(hw);
548 /* check and configure queue intr-vector mapping */
549 if ((rte_intr_cap_multiple(intr_handle) ||
550 !RTE_ETH_DEV_SRIOV(dev).active) &&
551 dev->data->dev_conf.intr_conf.rxq != 0) {
552 intr_vector = dev->data->nb_rx_queues;
553 if (intr_vector > ATL_MAX_INTR_QUEUE_NUM) {
554 PMD_INIT_LOG(ERR, "At most %d intr queues supported",
555 ATL_MAX_INTR_QUEUE_NUM);
556 return -ENOTSUP;
557 }
558 if (rte_intr_efd_enable(intr_handle, intr_vector)) {
559 PMD_INIT_LOG(ERR, "rte_intr_efd_enable failed");
560 return -1;
561 }
562 }
563
564 if (rte_intr_dp_is_en(intr_handle) && !intr_handle->intr_vec) {
565 intr_handle->intr_vec = rte_zmalloc("intr_vec",
566 dev->data->nb_rx_queues * sizeof(int), 0);
567 if (intr_handle->intr_vec == NULL) {
568 PMD_INIT_LOG(ERR, "Failed to allocate %d rx_queues"
569 " intr_vec", dev->data->nb_rx_queues);
570 return -ENOMEM;
571 }
572 }
573
574 /* initialize transmission unit */
575 atl_tx_init(dev);
576
577 /* This can fail when allocating mbufs for descriptor rings */
578 err = atl_rx_init(dev);
579 if (err) {
580 PMD_INIT_LOG(ERR, "Unable to initialize RX hardware");
581 goto error;
582 }
583
584 PMD_INIT_LOG(DEBUG, "FW version: %u.%u.%u",
585 hw->fw_ver_actual >> 24,
586 (hw->fw_ver_actual >> 16) & 0xFF,
587 hw->fw_ver_actual & 0xFFFF);
588 PMD_INIT_LOG(DEBUG, "Driver version: %s", ATL_PMD_DRIVER_VERSION);
589
590 err = atl_start_queues(dev);
591 if (err < 0) {
592 PMD_INIT_LOG(ERR, "Unable to start rxtx queues");
593 goto error;
594 }
595
596 err = atl_dev_set_link_up(dev);
597
598 err = hw->aq_fw_ops->update_link_status(hw);
599
600 if (err)
601 goto error;
602
603 dev->data->dev_link.link_status = hw->aq_link_status.mbps != 0;
604
605 if (rte_intr_allow_others(intr_handle)) {
606 /* check if lsc interrupt is enabled */
607 if (dev->data->dev_conf.intr_conf.lsc != 0)
608 atl_dev_lsc_interrupt_setup(dev, true);
609 else
610 atl_dev_lsc_interrupt_setup(dev, false);
611 } else {
612 rte_intr_callback_unregister(intr_handle,
613 atl_dev_interrupt_handler, dev);
614 if (dev->data->dev_conf.intr_conf.lsc != 0)
615 PMD_INIT_LOG(INFO, "lsc won't enable because of"
616 " no intr multiplex");
617 }
618
619 /* check if rxq interrupt is enabled */
620 if (dev->data->dev_conf.intr_conf.rxq != 0 &&
621 rte_intr_dp_is_en(intr_handle))
622 atl_dev_rxq_interrupt_setup(dev);
623
624 /* enable uio/vfio intr/eventfd mapping */
625 rte_intr_enable(intr_handle);
626
627 /* resume enabled intr since hw reset */
628 atl_enable_intr(dev);
629
630 return 0;
631
632 error:
633 atl_stop_queues(dev);
634 return -EIO;
635 }
636
637 /*
638 * Stop device: disable rx and tx functions to allow for reconfiguring.
639 */
640 static void
641 atl_dev_stop(struct rte_eth_dev *dev)
642 {
643 struct rte_eth_link link;
644 struct aq_hw_s *hw =
645 ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private);
646 struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(dev);
647 struct rte_intr_handle *intr_handle = &pci_dev->intr_handle;
648
649 PMD_INIT_FUNC_TRACE();
650
651 /* disable interrupts */
652 atl_disable_intr(hw);
653
654 /* reset the NIC */
655 atl_reset_hw(hw);
656 hw->adapter_stopped = 1;
657
658 atl_stop_queues(dev);
659
660 /* Clear stored conf */
661 dev->data->scattered_rx = 0;
662 dev->data->lro = 0;
663
664 /* Clear recorded link status */
665 memset(&link, 0, sizeof(link));
666 rte_eth_linkstatus_set(dev, &link);
667
668 if (!rte_intr_allow_others(intr_handle))
669 /* resume to the default handler */
670 rte_intr_callback_register(intr_handle,
671 atl_dev_interrupt_handler,
672 (void *)dev);
673
674 /* Clean datapath event and queue/vec mapping */
675 rte_intr_efd_disable(intr_handle);
676 if (intr_handle->intr_vec != NULL) {
677 rte_free(intr_handle->intr_vec);
678 intr_handle->intr_vec = NULL;
679 }
680 }
681
682 /*
683 * Set device link up: enable tx.
684 */
685 static int
686 atl_dev_set_link_up(struct rte_eth_dev *dev)
687 {
688 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private);
689 uint32_t link_speeds = dev->data->dev_conf.link_speeds;
690 uint32_t speed_mask = 0;
691
692 if (link_speeds == ETH_LINK_SPEED_AUTONEG) {
693 speed_mask = hw->aq_nic_cfg->link_speed_msk;
694 } else {
695 if (link_speeds & ETH_LINK_SPEED_10G)
696 speed_mask |= AQ_NIC_RATE_10G;
697 if (link_speeds & ETH_LINK_SPEED_5G)
698 speed_mask |= AQ_NIC_RATE_5G;
699 if (link_speeds & ETH_LINK_SPEED_1G)
700 speed_mask |= AQ_NIC_RATE_1G;
701 if (link_speeds & ETH_LINK_SPEED_2_5G)
702 speed_mask |= AQ_NIC_RATE_2G5;
703 if (link_speeds & ETH_LINK_SPEED_100M)
704 speed_mask |= AQ_NIC_RATE_100M;
705 }
706
707 return hw->aq_fw_ops->set_link_speed(hw, speed_mask);
708 }
709
710 /*
711 * Set device link down: disable tx.
712 */
713 static int
714 atl_dev_set_link_down(struct rte_eth_dev *dev)
715 {
716 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private);
717
718 return hw->aq_fw_ops->set_link_speed(hw, 0);
719 }
720
721 /*
722 * Reset and stop device.
723 */
724 static void
725 atl_dev_close(struct rte_eth_dev *dev)
726 {
727 PMD_INIT_FUNC_TRACE();
728
729 atl_dev_stop(dev);
730
731 atl_free_queues(dev);
732 }
733
734 static int
735 atl_dev_reset(struct rte_eth_dev *dev)
736 {
737 int ret;
738
739 ret = eth_atl_dev_uninit(dev);
740 if (ret)
741 return ret;
742
743 ret = eth_atl_dev_init(dev);
744
745 return ret;
746 }
747
748 static int
749 atl_dev_configure_macsec(struct rte_eth_dev *dev)
750 {
751 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private);
752 struct aq_hw_cfg_s *cf = ATL_DEV_PRIVATE_TO_CFG(dev->data->dev_private);
753 struct aq_macsec_config *aqcfg = &cf->aq_macsec;
754 struct macsec_msg_fw_request msg_macsec;
755 struct macsec_msg_fw_response response;
756
757 if (!aqcfg->common.macsec_enabled ||
758 hw->aq_fw_ops->send_macsec_req == NULL)
759 return 0;
760
761 memset(&msg_macsec, 0, sizeof(msg_macsec));
762
763 /* Creating set of sc/sa structures from parameters provided by DPDK */
764
765 /* Configure macsec */
766 msg_macsec.msg_type = macsec_cfg_msg;
767 msg_macsec.cfg.enabled = aqcfg->common.macsec_enabled;
768 msg_macsec.cfg.interrupts_enabled = 1;
769
770 hw->aq_fw_ops->send_macsec_req(hw, &msg_macsec, &response);
771
772 if (response.result)
773 return -1;
774
775 memset(&msg_macsec, 0, sizeof(msg_macsec));
776
777 /* Configure TX SC */
778
779 msg_macsec.msg_type = macsec_add_tx_sc_msg;
780 msg_macsec.txsc.index = 0; /* TXSC always one (??) */
781 msg_macsec.txsc.protect = aqcfg->common.encryption_enabled;
782
783 /* MAC addr for TX */
784 msg_macsec.txsc.mac_sa[0] = rte_bswap32(aqcfg->txsc.mac[1]);
785 msg_macsec.txsc.mac_sa[1] = rte_bswap32(aqcfg->txsc.mac[0]);
786 msg_macsec.txsc.sa_mask = 0x3f;
787
788 msg_macsec.txsc.da_mask = 0;
789 msg_macsec.txsc.tci = 0x0B;
790 msg_macsec.txsc.curr_an = 0; /* SA index which currently used */
791
792 /*
793 * Creating SCI (Secure Channel Identifier).
794 * SCI constructed from Source MAC and Port identifier
795 */
796 uint32_t sci_hi_part = (msg_macsec.txsc.mac_sa[1] << 16) |
797 (msg_macsec.txsc.mac_sa[0] >> 16);
798 uint32_t sci_low_part = (msg_macsec.txsc.mac_sa[0] << 16);
799
800 uint32_t port_identifier = 1;
801
802 msg_macsec.txsc.sci[1] = sci_hi_part;
803 msg_macsec.txsc.sci[0] = sci_low_part | port_identifier;
804
805 hw->aq_fw_ops->send_macsec_req(hw, &msg_macsec, &response);
806
807 if (response.result)
808 return -1;
809
810 memset(&msg_macsec, 0, sizeof(msg_macsec));
811
812 /* Configure RX SC */
813
814 msg_macsec.msg_type = macsec_add_rx_sc_msg;
815 msg_macsec.rxsc.index = aqcfg->rxsc.pi;
816 msg_macsec.rxsc.replay_protect =
817 aqcfg->common.replay_protection_enabled;
818 msg_macsec.rxsc.anti_replay_window = 0;
819
820 /* MAC addr for RX */
821 msg_macsec.rxsc.mac_da[0] = rte_bswap32(aqcfg->rxsc.mac[1]);
822 msg_macsec.rxsc.mac_da[1] = rte_bswap32(aqcfg->rxsc.mac[0]);
823 msg_macsec.rxsc.da_mask = 0;//0x3f;
824
825 msg_macsec.rxsc.sa_mask = 0;
826
827 hw->aq_fw_ops->send_macsec_req(hw, &msg_macsec, &response);
828
829 if (response.result)
830 return -1;
831
832 memset(&msg_macsec, 0, sizeof(msg_macsec));
833
834 /* Configure RX SC */
835
836 msg_macsec.msg_type = macsec_add_tx_sa_msg;
837 msg_macsec.txsa.index = aqcfg->txsa.idx;
838 msg_macsec.txsa.next_pn = aqcfg->txsa.pn;
839
840 msg_macsec.txsa.key[0] = rte_bswap32(aqcfg->txsa.key[3]);
841 msg_macsec.txsa.key[1] = rte_bswap32(aqcfg->txsa.key[2]);
842 msg_macsec.txsa.key[2] = rte_bswap32(aqcfg->txsa.key[1]);
843 msg_macsec.txsa.key[3] = rte_bswap32(aqcfg->txsa.key[0]);
844
845 hw->aq_fw_ops->send_macsec_req(hw, &msg_macsec, &response);
846
847 if (response.result)
848 return -1;
849
850 memset(&msg_macsec, 0, sizeof(msg_macsec));
851
852 /* Configure RX SA */
853
854 msg_macsec.msg_type = macsec_add_rx_sa_msg;
855 msg_macsec.rxsa.index = aqcfg->rxsa.idx;
856 msg_macsec.rxsa.next_pn = aqcfg->rxsa.pn;
857
858 msg_macsec.rxsa.key[0] = rte_bswap32(aqcfg->rxsa.key[3]);
859 msg_macsec.rxsa.key[1] = rte_bswap32(aqcfg->rxsa.key[2]);
860 msg_macsec.rxsa.key[2] = rte_bswap32(aqcfg->rxsa.key[1]);
861 msg_macsec.rxsa.key[3] = rte_bswap32(aqcfg->rxsa.key[0]);
862
863 hw->aq_fw_ops->send_macsec_req(hw, &msg_macsec, &response);
864
865 if (response.result)
866 return -1;
867
868 return 0;
869 }
870
871 int atl_macsec_enable(struct rte_eth_dev *dev,
872 uint8_t encr, uint8_t repl_prot)
873 {
874 struct aq_hw_cfg_s *cfg =
875 ATL_DEV_PRIVATE_TO_CFG(dev->data->dev_private);
876
877 cfg->aq_macsec.common.macsec_enabled = 1;
878 cfg->aq_macsec.common.encryption_enabled = encr;
879 cfg->aq_macsec.common.replay_protection_enabled = repl_prot;
880
881 return 0;
882 }
883
884 int atl_macsec_disable(struct rte_eth_dev *dev)
885 {
886 struct aq_hw_cfg_s *cfg =
887 ATL_DEV_PRIVATE_TO_CFG(dev->data->dev_private);
888
889 cfg->aq_macsec.common.macsec_enabled = 0;
890
891 return 0;
892 }
893
894 int atl_macsec_config_txsc(struct rte_eth_dev *dev, uint8_t *mac)
895 {
896 struct aq_hw_cfg_s *cfg =
897 ATL_DEV_PRIVATE_TO_CFG(dev->data->dev_private);
898
899 memset(&cfg->aq_macsec.txsc.mac, 0, sizeof(cfg->aq_macsec.txsc.mac));
900 memcpy((uint8_t *)&cfg->aq_macsec.txsc.mac + 2, mac, ETHER_ADDR_LEN);
901
902 return 0;
903 }
904
905 int atl_macsec_config_rxsc(struct rte_eth_dev *dev,
906 uint8_t *mac, uint16_t pi)
907 {
908 struct aq_hw_cfg_s *cfg =
909 ATL_DEV_PRIVATE_TO_CFG(dev->data->dev_private);
910
911 memset(&cfg->aq_macsec.rxsc.mac, 0, sizeof(cfg->aq_macsec.rxsc.mac));
912 memcpy((uint8_t *)&cfg->aq_macsec.rxsc.mac + 2, mac, ETHER_ADDR_LEN);
913 cfg->aq_macsec.rxsc.pi = pi;
914
915 return 0;
916 }
917
918 int atl_macsec_select_txsa(struct rte_eth_dev *dev,
919 uint8_t idx, uint8_t an,
920 uint32_t pn, uint8_t *key)
921 {
922 struct aq_hw_cfg_s *cfg =
923 ATL_DEV_PRIVATE_TO_CFG(dev->data->dev_private);
924
925 cfg->aq_macsec.txsa.idx = idx;
926 cfg->aq_macsec.txsa.pn = pn;
927 cfg->aq_macsec.txsa.an = an;
928
929 memcpy(&cfg->aq_macsec.txsa.key, key, 16);
930 return 0;
931 }
932
933 int atl_macsec_select_rxsa(struct rte_eth_dev *dev,
934 uint8_t idx, uint8_t an,
935 uint32_t pn, uint8_t *key)
936 {
937 struct aq_hw_cfg_s *cfg =
938 ATL_DEV_PRIVATE_TO_CFG(dev->data->dev_private);
939
940 cfg->aq_macsec.rxsa.idx = idx;
941 cfg->aq_macsec.rxsa.pn = pn;
942 cfg->aq_macsec.rxsa.an = an;
943
944 memcpy(&cfg->aq_macsec.rxsa.key, key, 16);
945 return 0;
946 }
947
948 static int
949 atl_dev_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats)
950 {
951 struct atl_adapter *adapter = ATL_DEV_TO_ADAPTER(dev);
952 struct aq_hw_s *hw = &adapter->hw;
953 struct atl_sw_stats *swstats = &adapter->sw_stats;
954 unsigned int i;
955
956 hw->aq_fw_ops->update_stats(hw);
957
958 /* Fill out the rte_eth_stats statistics structure */
959 stats->ipackets = hw->curr_stats.dma_pkt_rc;
960 stats->ibytes = hw->curr_stats.dma_oct_rc;
961 stats->imissed = hw->curr_stats.dpc;
962 stats->ierrors = hw->curr_stats.erpt;
963
964 stats->opackets = hw->curr_stats.dma_pkt_tc;
965 stats->obytes = hw->curr_stats.dma_oct_tc;
966 stats->oerrors = 0;
967
968 stats->rx_nombuf = swstats->rx_nombuf;
969
970 for (i = 0; i < RTE_ETHDEV_QUEUE_STAT_CNTRS; i++) {
971 stats->q_ipackets[i] = swstats->q_ipackets[i];
972 stats->q_opackets[i] = swstats->q_opackets[i];
973 stats->q_ibytes[i] = swstats->q_ibytes[i];
974 stats->q_obytes[i] = swstats->q_obytes[i];
975 stats->q_errors[i] = swstats->q_errors[i];
976 }
977 return 0;
978 }
979
980 static void
981 atl_dev_stats_reset(struct rte_eth_dev *dev)
982 {
983 struct atl_adapter *adapter = ATL_DEV_TO_ADAPTER(dev);
984 struct aq_hw_s *hw = &adapter->hw;
985
986 hw->aq_fw_ops->update_stats(hw);
987
988 /* Reset software totals */
989 memset(&hw->curr_stats, 0, sizeof(hw->curr_stats));
990
991 memset(&adapter->sw_stats, 0, sizeof(adapter->sw_stats));
992 }
993
994 static int
995 atl_dev_xstats_get_names(struct rte_eth_dev *dev __rte_unused,
996 struct rte_eth_xstat_name *xstats_names,
997 unsigned int size)
998 {
999 unsigned int i;
1000
1001 if (!xstats_names)
1002 return RTE_DIM(atl_xstats_tbl);
1003
1004 for (i = 0; i < size && i < RTE_DIM(atl_xstats_tbl); i++)
1005 strlcpy(xstats_names[i].name, atl_xstats_tbl[i].name,
1006 RTE_ETH_XSTATS_NAME_SIZE);
1007
1008 return i;
1009 }
1010
1011 static int
1012 atl_dev_xstats_get(struct rte_eth_dev *dev, struct rte_eth_xstat *stats,
1013 unsigned int n)
1014 {
1015 struct atl_adapter *adapter =
1016 (struct atl_adapter *)dev->data->dev_private;
1017 struct aq_hw_s *hw = &adapter->hw;
1018 struct get_stats req = { 0 };
1019 struct macsec_msg_fw_request msg = { 0 };
1020 struct macsec_msg_fw_response resp = { 0 };
1021 int err = -1;
1022 unsigned int i;
1023
1024 if (!stats)
1025 return 0;
1026
1027 if (hw->aq_fw_ops->send_macsec_req != NULL) {
1028 req.ingress_sa_index = 0xff;
1029 req.egress_sc_index = 0xff;
1030 req.egress_sa_index = 0xff;
1031
1032 msg.msg_type = macsec_get_stats_msg;
1033 msg.stats = req;
1034
1035 err = hw->aq_fw_ops->send_macsec_req(hw, &msg, &resp);
1036 }
1037
1038 for (i = 0; i < n && i < RTE_DIM(atl_xstats_tbl); i++) {
1039 stats[i].id = i;
1040
1041 switch (atl_xstats_tbl[i].type) {
1042 case XSTATS_TYPE_MSM:
1043 stats[i].value = *(u64 *)((uint8_t *)&hw->curr_stats +
1044 atl_xstats_tbl[i].offset);
1045 break;
1046 case XSTATS_TYPE_MACSEC:
1047 if (err)
1048 goto done;
1049 stats[i].value = *(u64 *)((uint8_t *)&resp.stats +
1050 atl_xstats_tbl[i].offset);
1051 break;
1052 }
1053 }
1054 done:
1055 return i;
1056 }
1057
1058 static int
1059 atl_fw_version_get(struct rte_eth_dev *dev, char *fw_version, size_t fw_size)
1060 {
1061 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1062 uint32_t fw_ver = 0;
1063 unsigned int ret = 0;
1064
1065 ret = hw_atl_utils_get_fw_version(hw, &fw_ver);
1066 if (ret)
1067 return -EIO;
1068
1069 ret = snprintf(fw_version, fw_size, "%u.%u.%u", fw_ver >> 24,
1070 (fw_ver >> 16) & 0xFFU, fw_ver & 0xFFFFU);
1071
1072 ret += 1; /* add string null-terminator */
1073
1074 if (fw_size < ret)
1075 return ret;
1076
1077 return 0;
1078 }
1079
1080 static void
1081 atl_dev_info_get(struct rte_eth_dev *dev, struct rte_eth_dev_info *dev_info)
1082 {
1083 struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(dev);
1084
1085 dev_info->max_rx_queues = AQ_HW_MAX_RX_QUEUES;
1086 dev_info->max_tx_queues = AQ_HW_MAX_TX_QUEUES;
1087
1088 dev_info->min_rx_bufsize = 1024;
1089 dev_info->max_rx_pktlen = HW_ATL_B0_MTU_JUMBO;
1090 dev_info->max_mac_addrs = HW_ATL_B0_MAC_MAX;
1091 dev_info->max_vfs = pci_dev->max_vfs;
1092
1093 dev_info->max_hash_mac_addrs = 0;
1094 dev_info->max_vmdq_pools = 0;
1095 dev_info->vmdq_queue_num = 0;
1096
1097 dev_info->rx_offload_capa = ATL_RX_OFFLOADS;
1098
1099 dev_info->tx_offload_capa = ATL_TX_OFFLOADS;
1100
1101
1102 dev_info->default_rxconf = (struct rte_eth_rxconf) {
1103 .rx_free_thresh = ATL_DEFAULT_RX_FREE_THRESH,
1104 };
1105
1106 dev_info->default_txconf = (struct rte_eth_txconf) {
1107 .tx_free_thresh = ATL_DEFAULT_TX_FREE_THRESH,
1108 };
1109
1110 dev_info->rx_desc_lim = rx_desc_lim;
1111 dev_info->tx_desc_lim = tx_desc_lim;
1112
1113 dev_info->hash_key_size = HW_ATL_B0_RSS_HASHKEY_BITS / 8;
1114 dev_info->reta_size = HW_ATL_B0_RSS_REDIRECTION_MAX;
1115 dev_info->flow_type_rss_offloads = ATL_RSS_OFFLOAD_ALL;
1116
1117 dev_info->speed_capa = ETH_LINK_SPEED_1G | ETH_LINK_SPEED_10G;
1118 dev_info->speed_capa |= ETH_LINK_SPEED_100M;
1119 dev_info->speed_capa |= ETH_LINK_SPEED_2_5G;
1120 dev_info->speed_capa |= ETH_LINK_SPEED_5G;
1121 }
1122
1123 static const uint32_t *
1124 atl_dev_supported_ptypes_get(struct rte_eth_dev *dev)
1125 {
1126 static const uint32_t ptypes[] = {
1127 RTE_PTYPE_L2_ETHER,
1128 RTE_PTYPE_L2_ETHER_ARP,
1129 RTE_PTYPE_L2_ETHER_VLAN,
1130 RTE_PTYPE_L3_IPV4,
1131 RTE_PTYPE_L3_IPV6,
1132 RTE_PTYPE_L4_TCP,
1133 RTE_PTYPE_L4_UDP,
1134 RTE_PTYPE_L4_SCTP,
1135 RTE_PTYPE_L4_ICMP,
1136 RTE_PTYPE_UNKNOWN
1137 };
1138
1139 if (dev->rx_pkt_burst == atl_recv_pkts)
1140 return ptypes;
1141
1142 return NULL;
1143 }
1144
1145 static void
1146 atl_dev_delayed_handler(void *param)
1147 {
1148 struct rte_eth_dev *dev = (struct rte_eth_dev *)param;
1149
1150 atl_dev_configure_macsec(dev);
1151 }
1152
1153
1154 /* return 0 means link status changed, -1 means not changed */
1155 static int
1156 atl_dev_link_update(struct rte_eth_dev *dev, int wait __rte_unused)
1157 {
1158 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1159 struct rte_eth_link link, old;
1160 u32 fc = AQ_NIC_FC_OFF;
1161 int err = 0;
1162
1163 link.link_status = ETH_LINK_DOWN;
1164 link.link_speed = 0;
1165 link.link_duplex = ETH_LINK_FULL_DUPLEX;
1166 link.link_autoneg = hw->is_autoneg ? ETH_LINK_AUTONEG : ETH_LINK_FIXED;
1167 memset(&old, 0, sizeof(old));
1168
1169 /* load old link status */
1170 rte_eth_linkstatus_get(dev, &old);
1171
1172 /* read current link status */
1173 err = hw->aq_fw_ops->update_link_status(hw);
1174
1175 if (err)
1176 return 0;
1177
1178 if (hw->aq_link_status.mbps == 0) {
1179 /* write default (down) link status */
1180 rte_eth_linkstatus_set(dev, &link);
1181 if (link.link_status == old.link_status)
1182 return -1;
1183 return 0;
1184 }
1185
1186 link.link_status = ETH_LINK_UP;
1187 link.link_duplex = ETH_LINK_FULL_DUPLEX;
1188 link.link_speed = hw->aq_link_status.mbps;
1189
1190 rte_eth_linkstatus_set(dev, &link);
1191
1192 if (link.link_status == old.link_status)
1193 return -1;
1194
1195 /* Driver has to update flow control settings on RX block
1196 * on any link event.
1197 * We should query FW whether it negotiated FC.
1198 */
1199 if (hw->aq_fw_ops->get_flow_control) {
1200 hw->aq_fw_ops->get_flow_control(hw, &fc);
1201 hw_atl_b0_set_fc(hw, fc, 0U);
1202 }
1203
1204 if (rte_eal_alarm_set(1000 * 1000,
1205 atl_dev_delayed_handler, (void *)dev) < 0)
1206 PMD_DRV_LOG(ERR, "rte_eal_alarm_set fail");
1207
1208 return 0;
1209 }
1210
1211 static void
1212 atl_dev_promiscuous_enable(struct rte_eth_dev *dev)
1213 {
1214 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1215
1216 hw_atl_rpfl2promiscuous_mode_en_set(hw, true);
1217 }
1218
1219 static void
1220 atl_dev_promiscuous_disable(struct rte_eth_dev *dev)
1221 {
1222 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1223
1224 hw_atl_rpfl2promiscuous_mode_en_set(hw, false);
1225 }
1226
1227 static void
1228 atl_dev_allmulticast_enable(struct rte_eth_dev *dev)
1229 {
1230 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1231
1232 hw_atl_rpfl2_accept_all_mc_packets_set(hw, true);
1233 }
1234
1235 static void
1236 atl_dev_allmulticast_disable(struct rte_eth_dev *dev)
1237 {
1238 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1239
1240 if (dev->data->promiscuous == 1)
1241 return; /* must remain in all_multicast mode */
1242
1243 hw_atl_rpfl2_accept_all_mc_packets_set(hw, false);
1244 }
1245
1246 /**
1247 * It clears the interrupt causes and enables the interrupt.
1248 * It will be called once only during nic initialized.
1249 *
1250 * @param dev
1251 * Pointer to struct rte_eth_dev.
1252 * @param on
1253 * Enable or Disable.
1254 *
1255 * @return
1256 * - On success, zero.
1257 * - On failure, a negative value.
1258 */
1259
1260 static int
1261 atl_dev_lsc_interrupt_setup(struct rte_eth_dev *dev, uint8_t on __rte_unused)
1262 {
1263 atl_dev_link_status_print(dev);
1264 return 0;
1265 }
1266
1267 static int
1268 atl_dev_rxq_interrupt_setup(struct rte_eth_dev *dev __rte_unused)
1269 {
1270 return 0;
1271 }
1272
1273
1274 static int
1275 atl_dev_interrupt_get_status(struct rte_eth_dev *dev)
1276 {
1277 struct atl_interrupt *intr =
1278 ATL_DEV_PRIVATE_TO_INTR(dev->data->dev_private);
1279 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1280 u64 cause = 0;
1281
1282 hw_atl_b0_hw_irq_read(hw, &cause);
1283
1284 atl_disable_intr(hw);
1285
1286 if (cause & BIT(ATL_IRQ_CAUSE_LINK))
1287 intr->flags |= ATL_FLAG_NEED_LINK_UPDATE;
1288
1289 return 0;
1290 }
1291
1292 /**
1293 * It gets and then prints the link status.
1294 *
1295 * @param dev
1296 * Pointer to struct rte_eth_dev.
1297 *
1298 * @return
1299 * - On success, zero.
1300 * - On failure, a negative value.
1301 */
1302 static void
1303 atl_dev_link_status_print(struct rte_eth_dev *dev)
1304 {
1305 struct rte_eth_link link;
1306
1307 memset(&link, 0, sizeof(link));
1308 rte_eth_linkstatus_get(dev, &link);
1309 if (link.link_status) {
1310 PMD_DRV_LOG(INFO, "Port %d: Link Up - speed %u Mbps - %s",
1311 (int)(dev->data->port_id),
1312 (unsigned int)link.link_speed,
1313 link.link_duplex == ETH_LINK_FULL_DUPLEX ?
1314 "full-duplex" : "half-duplex");
1315 } else {
1316 PMD_DRV_LOG(INFO, " Port %d: Link Down",
1317 (int)(dev->data->port_id));
1318 }
1319
1320
1321 #ifdef DEBUG
1322 {
1323 struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(dev);
1324
1325 PMD_DRV_LOG(DEBUG, "PCI Address: " PCI_PRI_FMT,
1326 pci_dev->addr.domain,
1327 pci_dev->addr.bus,
1328 pci_dev->addr.devid,
1329 pci_dev->addr.function);
1330 }
1331 #endif
1332
1333 PMD_DRV_LOG(INFO, "Link speed:%d", link.link_speed);
1334 }
1335
1336 /*
1337 * It executes link_update after knowing an interrupt occurred.
1338 *
1339 * @param dev
1340 * Pointer to struct rte_eth_dev.
1341 *
1342 * @return
1343 * - On success, zero.
1344 * - On failure, a negative value.
1345 */
1346 static int
1347 atl_dev_interrupt_action(struct rte_eth_dev *dev,
1348 struct rte_intr_handle *intr_handle)
1349 {
1350 struct atl_interrupt *intr =
1351 ATL_DEV_PRIVATE_TO_INTR(dev->data->dev_private);
1352 struct atl_adapter *adapter =
1353 (struct atl_adapter *)dev->data->dev_private;
1354 struct aq_hw_s *hw = &adapter->hw;
1355
1356 if (!(intr->flags & ATL_FLAG_NEED_LINK_UPDATE))
1357 goto done;
1358
1359 intr->flags &= ~ATL_FLAG_NEED_LINK_UPDATE;
1360
1361 /* Notify userapp if link status changed */
1362 if (!atl_dev_link_update(dev, 0)) {
1363 atl_dev_link_status_print(dev);
1364 _rte_eth_dev_callback_process(dev,
1365 RTE_ETH_EVENT_INTR_LSC, NULL);
1366 } else {
1367 if (hw->aq_fw_ops->send_macsec_req == NULL)
1368 goto done;
1369
1370 /* Check macsec Keys expired */
1371 struct get_stats req = { 0 };
1372 struct macsec_msg_fw_request msg = { 0 };
1373 struct macsec_msg_fw_response resp = { 0 };
1374
1375 req.ingress_sa_index = 0x0;
1376 req.egress_sc_index = 0x0;
1377 req.egress_sa_index = 0x0;
1378 msg.msg_type = macsec_get_stats_msg;
1379 msg.stats = req;
1380
1381 int err = hw->aq_fw_ops->send_macsec_req(hw, &msg, &resp);
1382 if (err) {
1383 PMD_DRV_LOG(ERR, "send_macsec_req fail");
1384 goto done;
1385 }
1386 if (resp.stats.egress_threshold_expired ||
1387 resp.stats.ingress_threshold_expired ||
1388 resp.stats.egress_expired ||
1389 resp.stats.ingress_expired) {
1390 PMD_DRV_LOG(INFO, "RTE_ETH_EVENT_MACSEC");
1391 _rte_eth_dev_callback_process(dev,
1392 RTE_ETH_EVENT_MACSEC, NULL);
1393 }
1394 }
1395 done:
1396 atl_enable_intr(dev);
1397 rte_intr_enable(intr_handle);
1398
1399 return 0;
1400 }
1401
1402 /**
1403 * Interrupt handler triggered by NIC for handling
1404 * specific interrupt.
1405 *
1406 * @param handle
1407 * Pointer to interrupt handle.
1408 * @param param
1409 * The address of parameter (struct rte_eth_dev *) regsitered before.
1410 *
1411 * @return
1412 * void
1413 */
1414 static void
1415 atl_dev_interrupt_handler(void *param)
1416 {
1417 struct rte_eth_dev *dev = (struct rte_eth_dev *)param;
1418
1419 atl_dev_interrupt_get_status(dev);
1420 atl_dev_interrupt_action(dev, dev->intr_handle);
1421 }
1422
1423
1424 static int
1425 atl_dev_get_eeprom_length(struct rte_eth_dev *dev __rte_unused)
1426 {
1427 return SFP_EEPROM_SIZE;
1428 }
1429
1430 int atl_dev_get_eeprom(struct rte_eth_dev *dev,
1431 struct rte_dev_eeprom_info *eeprom)
1432 {
1433 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1434 uint32_t dev_addr = SMBUS_DEVICE_ID;
1435
1436 if (hw->aq_fw_ops->get_eeprom == NULL)
1437 return -ENOTSUP;
1438
1439 if (eeprom->length + eeprom->offset > SFP_EEPROM_SIZE ||
1440 eeprom->data == NULL)
1441 return -EINVAL;
1442
1443 if (eeprom->magic > 0x7F)
1444 return -EINVAL;
1445
1446 if (eeprom->magic)
1447 dev_addr = eeprom->magic;
1448
1449 return hw->aq_fw_ops->get_eeprom(hw, dev_addr, eeprom->data,
1450 eeprom->length, eeprom->offset);
1451 }
1452
1453 int atl_dev_set_eeprom(struct rte_eth_dev *dev,
1454 struct rte_dev_eeprom_info *eeprom)
1455 {
1456 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1457 uint32_t dev_addr = SMBUS_DEVICE_ID;
1458
1459 if (hw->aq_fw_ops->set_eeprom == NULL)
1460 return -ENOTSUP;
1461
1462 if (eeprom->length + eeprom->offset > SFP_EEPROM_SIZE ||
1463 eeprom->data == NULL)
1464 return -EINVAL;
1465
1466 if (eeprom->magic > 0x7F)
1467 return -EINVAL;
1468
1469 if (eeprom->magic)
1470 dev_addr = eeprom->magic;
1471
1472 return hw->aq_fw_ops->set_eeprom(hw, dev_addr, eeprom->data,
1473 eeprom->length, eeprom->offset);
1474 }
1475
1476 static int
1477 atl_dev_get_regs(struct rte_eth_dev *dev, struct rte_dev_reg_info *regs)
1478 {
1479 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1480 u32 mif_id;
1481 int err;
1482
1483 if (regs->data == NULL) {
1484 regs->length = hw_atl_utils_hw_get_reg_length();
1485 regs->width = sizeof(u32);
1486 return 0;
1487 }
1488
1489 /* Only full register dump is supported */
1490 if (regs->length && regs->length != hw_atl_utils_hw_get_reg_length())
1491 return -ENOTSUP;
1492
1493 err = hw_atl_utils_hw_get_regs(hw, regs->data);
1494
1495 /* Device version */
1496 mif_id = hw_atl_reg_glb_mif_id_get(hw);
1497 regs->version = mif_id & 0xFFU;
1498
1499 return err;
1500 }
1501
1502 static int
1503 atl_flow_ctrl_get(struct rte_eth_dev *dev, struct rte_eth_fc_conf *fc_conf)
1504 {
1505 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1506 u32 fc = AQ_NIC_FC_OFF;
1507
1508 if (hw->aq_fw_ops->get_flow_control == NULL)
1509 return -ENOTSUP;
1510
1511 hw->aq_fw_ops->get_flow_control(hw, &fc);
1512
1513 if (fc == AQ_NIC_FC_OFF)
1514 fc_conf->mode = RTE_FC_NONE;
1515 else if (fc & (AQ_NIC_FC_RX | AQ_NIC_FC_TX))
1516 fc_conf->mode = RTE_FC_FULL;
1517 else if (fc & AQ_NIC_FC_RX)
1518 fc_conf->mode = RTE_FC_RX_PAUSE;
1519 else if (fc & AQ_NIC_FC_RX)
1520 fc_conf->mode = RTE_FC_TX_PAUSE;
1521
1522 return 0;
1523 }
1524
1525 static int
1526 atl_flow_ctrl_set(struct rte_eth_dev *dev, struct rte_eth_fc_conf *fc_conf)
1527 {
1528 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1529 uint32_t old_flow_control = hw->aq_nic_cfg->flow_control;
1530
1531
1532 if (hw->aq_fw_ops->set_flow_control == NULL)
1533 return -ENOTSUP;
1534
1535 if (fc_conf->mode == RTE_FC_NONE)
1536 hw->aq_nic_cfg->flow_control = AQ_NIC_FC_OFF;
1537 else if (fc_conf->mode == RTE_FC_RX_PAUSE)
1538 hw->aq_nic_cfg->flow_control = AQ_NIC_FC_RX;
1539 else if (fc_conf->mode == RTE_FC_TX_PAUSE)
1540 hw->aq_nic_cfg->flow_control = AQ_NIC_FC_TX;
1541 else if (fc_conf->mode == RTE_FC_FULL)
1542 hw->aq_nic_cfg->flow_control = (AQ_NIC_FC_RX | AQ_NIC_FC_TX);
1543
1544 if (old_flow_control != hw->aq_nic_cfg->flow_control)
1545 return hw->aq_fw_ops->set_flow_control(hw);
1546
1547 return 0;
1548 }
1549
1550 static int
1551 atl_update_mac_addr(struct rte_eth_dev *dev, uint32_t index,
1552 u8 *mac_addr, bool enable)
1553 {
1554 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1555 unsigned int h = 0U;
1556 unsigned int l = 0U;
1557 int err;
1558
1559 if (mac_addr) {
1560 h = (mac_addr[0] << 8) | (mac_addr[1]);
1561 l = (mac_addr[2] << 24) | (mac_addr[3] << 16) |
1562 (mac_addr[4] << 8) | mac_addr[5];
1563 }
1564
1565 hw_atl_rpfl2_uc_flr_en_set(hw, 0U, index);
1566 hw_atl_rpfl2unicast_dest_addresslsw_set(hw, l, index);
1567 hw_atl_rpfl2unicast_dest_addressmsw_set(hw, h, index);
1568
1569 if (enable)
1570 hw_atl_rpfl2_uc_flr_en_set(hw, 1U, index);
1571
1572 err = aq_hw_err_from_flags(hw);
1573
1574 return err;
1575 }
1576
1577 static int
1578 atl_add_mac_addr(struct rte_eth_dev *dev, struct ether_addr *mac_addr,
1579 uint32_t index __rte_unused, uint32_t pool __rte_unused)
1580 {
1581 if (is_zero_ether_addr(mac_addr)) {
1582 PMD_DRV_LOG(ERR, "Invalid Ethernet Address");
1583 return -EINVAL;
1584 }
1585
1586 return atl_update_mac_addr(dev, index, (u8 *)mac_addr, true);
1587 }
1588
1589 static void
1590 atl_remove_mac_addr(struct rte_eth_dev *dev, uint32_t index)
1591 {
1592 atl_update_mac_addr(dev, index, NULL, false);
1593 }
1594
1595 static int
1596 atl_set_default_mac_addr(struct rte_eth_dev *dev, struct ether_addr *addr)
1597 {
1598 atl_remove_mac_addr(dev, 0);
1599 atl_add_mac_addr(dev, addr, 0, 0);
1600 return 0;
1601 }
1602
1603 static int
1604 atl_dev_mtu_set(struct rte_eth_dev *dev, uint16_t mtu)
1605 {
1606 struct rte_eth_dev_info dev_info;
1607 uint32_t frame_size = mtu + ETHER_HDR_LEN + ETHER_CRC_LEN;
1608
1609 atl_dev_info_get(dev, &dev_info);
1610
1611 if ((mtu < ETHER_MIN_MTU) || (frame_size > dev_info.max_rx_pktlen))
1612 return -EINVAL;
1613
1614 /* update max frame size */
1615 dev->data->dev_conf.rxmode.max_rx_pkt_len = frame_size;
1616
1617 return 0;
1618 }
1619
1620 static int
1621 atl_vlan_filter_set(struct rte_eth_dev *dev, uint16_t vlan_id, int on)
1622 {
1623 struct aq_hw_cfg_s *cfg =
1624 ATL_DEV_PRIVATE_TO_CFG(dev->data->dev_private);
1625 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1626 int err = 0;
1627 int i = 0;
1628
1629 PMD_INIT_FUNC_TRACE();
1630
1631 for (i = 0; i < HW_ATL_B0_MAX_VLAN_IDS; i++) {
1632 if (cfg->vlan_filter[i] == vlan_id) {
1633 if (!on) {
1634 /* Disable VLAN filter. */
1635 hw_atl_rpf_vlan_flr_en_set(hw, 0U, i);
1636
1637 /* Clear VLAN filter entry */
1638 cfg->vlan_filter[i] = 0;
1639 }
1640 break;
1641 }
1642 }
1643
1644 /* VLAN_ID was not found. So, nothing to delete. */
1645 if (i == HW_ATL_B0_MAX_VLAN_IDS && !on)
1646 goto exit;
1647
1648 /* VLAN_ID already exist, or already removed above. Nothing to do. */
1649 if (i != HW_ATL_B0_MAX_VLAN_IDS)
1650 goto exit;
1651
1652 /* Try to found free VLAN filter to add new VLAN_ID */
1653 for (i = 0; i < HW_ATL_B0_MAX_VLAN_IDS; i++) {
1654 if (cfg->vlan_filter[i] == 0)
1655 break;
1656 }
1657
1658 if (i == HW_ATL_B0_MAX_VLAN_IDS) {
1659 /* We have no free VLAN filter to add new VLAN_ID*/
1660 err = -ENOMEM;
1661 goto exit;
1662 }
1663
1664 cfg->vlan_filter[i] = vlan_id;
1665 hw_atl_rpf_vlan_flr_act_set(hw, 1U, i);
1666 hw_atl_rpf_vlan_id_flr_set(hw, vlan_id, i);
1667 hw_atl_rpf_vlan_flr_en_set(hw, 1U, i);
1668
1669 exit:
1670 /* Enable VLAN promisc mode if vlan_filter empty */
1671 for (i = 0; i < HW_ATL_B0_MAX_VLAN_IDS; i++) {
1672 if (cfg->vlan_filter[i] != 0)
1673 break;
1674 }
1675
1676 hw_atl_rpf_vlan_prom_mode_en_set(hw, i == HW_ATL_B0_MAX_VLAN_IDS);
1677
1678 return err;
1679 }
1680
1681 static int
1682 atl_enable_vlan_filter(struct rte_eth_dev *dev, int en)
1683 {
1684 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1685 struct aq_hw_cfg_s *cfg =
1686 ATL_DEV_PRIVATE_TO_CFG(dev->data->dev_private);
1687 int i;
1688
1689 PMD_INIT_FUNC_TRACE();
1690
1691 for (i = 0; i < HW_ATL_B0_MAX_VLAN_IDS; i++) {
1692 if (cfg->vlan_filter[i])
1693 hw_atl_rpf_vlan_flr_en_set(hw, en, i);
1694 }
1695 return 0;
1696 }
1697
1698 static int
1699 atl_vlan_offload_set(struct rte_eth_dev *dev, int mask)
1700 {
1701 struct aq_hw_cfg_s *cfg =
1702 ATL_DEV_PRIVATE_TO_CFG(dev->data->dev_private);
1703 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1704 int ret = 0;
1705 int i;
1706
1707 PMD_INIT_FUNC_TRACE();
1708
1709 ret = atl_enable_vlan_filter(dev, mask & ETH_VLAN_FILTER_MASK);
1710
1711 cfg->vlan_strip = !!(mask & ETH_VLAN_STRIP_MASK);
1712
1713 for (i = 0; i < dev->data->nb_rx_queues; i++)
1714 hw_atl_rpo_rx_desc_vlan_stripping_set(hw, cfg->vlan_strip, i);
1715
1716 if (mask & ETH_VLAN_EXTEND_MASK)
1717 ret = -ENOTSUP;
1718
1719 return ret;
1720 }
1721
1722 static int
1723 atl_vlan_tpid_set(struct rte_eth_dev *dev, enum rte_vlan_type vlan_type,
1724 uint16_t tpid)
1725 {
1726 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1727 int err = 0;
1728
1729 PMD_INIT_FUNC_TRACE();
1730
1731 switch (vlan_type) {
1732 case ETH_VLAN_TYPE_INNER:
1733 hw_atl_rpf_vlan_inner_etht_set(hw, tpid);
1734 break;
1735 case ETH_VLAN_TYPE_OUTER:
1736 hw_atl_rpf_vlan_outer_etht_set(hw, tpid);
1737 break;
1738 default:
1739 PMD_DRV_LOG(ERR, "Unsupported VLAN type");
1740 err = -ENOTSUP;
1741 }
1742
1743 return err;
1744 }
1745
1746 static void
1747 atl_vlan_strip_queue_set(struct rte_eth_dev *dev, uint16_t queue_id, int on)
1748 {
1749 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1750
1751 PMD_INIT_FUNC_TRACE();
1752
1753 if (queue_id > dev->data->nb_rx_queues) {
1754 PMD_DRV_LOG(ERR, "Invalid queue id");
1755 return;
1756 }
1757
1758 hw_atl_rpo_rx_desc_vlan_stripping_set(hw, on, queue_id);
1759 }
1760
1761 static int
1762 atl_dev_set_mc_addr_list(struct rte_eth_dev *dev,
1763 struct ether_addr *mc_addr_set,
1764 uint32_t nb_mc_addr)
1765 {
1766 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1767 u32 i;
1768
1769 if (nb_mc_addr > AQ_HW_MULTICAST_ADDRESS_MAX - HW_ATL_B0_MAC_MIN)
1770 return -EINVAL;
1771
1772 /* Update whole uc filters table */
1773 for (i = 0; i < AQ_HW_MULTICAST_ADDRESS_MAX - HW_ATL_B0_MAC_MIN; i++) {
1774 u8 *mac_addr = NULL;
1775 u32 l = 0, h = 0;
1776
1777 if (i < nb_mc_addr) {
1778 mac_addr = mc_addr_set[i].addr_bytes;
1779 l = (mac_addr[2] << 24) | (mac_addr[3] << 16) |
1780 (mac_addr[4] << 8) | mac_addr[5];
1781 h = (mac_addr[0] << 8) | mac_addr[1];
1782 }
1783
1784 hw_atl_rpfl2_uc_flr_en_set(hw, 0U, HW_ATL_B0_MAC_MIN + i);
1785 hw_atl_rpfl2unicast_dest_addresslsw_set(hw, l,
1786 HW_ATL_B0_MAC_MIN + i);
1787 hw_atl_rpfl2unicast_dest_addressmsw_set(hw, h,
1788 HW_ATL_B0_MAC_MIN + i);
1789 hw_atl_rpfl2_uc_flr_en_set(hw, !!mac_addr,
1790 HW_ATL_B0_MAC_MIN + i);
1791 }
1792
1793 return 0;
1794 }
1795
1796 static int
1797 atl_reta_update(struct rte_eth_dev *dev,
1798 struct rte_eth_rss_reta_entry64 *reta_conf,
1799 uint16_t reta_size)
1800 {
1801 int i;
1802 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1803 struct aq_hw_cfg_s *cf = ATL_DEV_PRIVATE_TO_CFG(dev->data->dev_private);
1804
1805 for (i = 0; i < reta_size && i < cf->aq_rss.indirection_table_size; i++)
1806 cf->aq_rss.indirection_table[i] = min(reta_conf->reta[i],
1807 dev->data->nb_rx_queues - 1);
1808
1809 hw_atl_b0_hw_rss_set(hw, &cf->aq_rss);
1810 return 0;
1811 }
1812
1813 static int
1814 atl_reta_query(struct rte_eth_dev *dev,
1815 struct rte_eth_rss_reta_entry64 *reta_conf,
1816 uint16_t reta_size)
1817 {
1818 int i;
1819 struct aq_hw_cfg_s *cf = ATL_DEV_PRIVATE_TO_CFG(dev->data->dev_private);
1820
1821 for (i = 0; i < reta_size && i < cf->aq_rss.indirection_table_size; i++)
1822 reta_conf->reta[i] = cf->aq_rss.indirection_table[i];
1823 reta_conf->mask = ~0U;
1824 return 0;
1825 }
1826
1827 static int
1828 atl_rss_hash_update(struct rte_eth_dev *dev,
1829 struct rte_eth_rss_conf *rss_conf)
1830 {
1831 struct aq_hw_s *hw = ATL_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1832 struct aq_hw_cfg_s *cfg =
1833 ATL_DEV_PRIVATE_TO_CFG(dev->data->dev_private);
1834 static u8 def_rss_key[40] = {
1835 0x1e, 0xad, 0x71, 0x87, 0x65, 0xfc, 0x26, 0x7d,
1836 0x0d, 0x45, 0x67, 0x74, 0xcd, 0x06, 0x1a, 0x18,
1837 0xb6, 0xc1, 0xf0, 0xc7, 0xbb, 0x18, 0xbe, 0xf8,
1838 0x19, 0x13, 0x4b, 0xa9, 0xd0, 0x3e, 0xfe, 0x70,
1839 0x25, 0x03, 0xab, 0x50, 0x6a, 0x8b, 0x82, 0x0c
1840 };
1841
1842 cfg->is_rss = !!rss_conf->rss_hf;
1843 if (rss_conf->rss_key) {
1844 memcpy(cfg->aq_rss.hash_secret_key, rss_conf->rss_key,
1845 rss_conf->rss_key_len);
1846 cfg->aq_rss.hash_secret_key_size = rss_conf->rss_key_len;
1847 } else {
1848 memcpy(cfg->aq_rss.hash_secret_key, def_rss_key,
1849 sizeof(def_rss_key));
1850 cfg->aq_rss.hash_secret_key_size = sizeof(def_rss_key);
1851 }
1852
1853 hw_atl_b0_hw_rss_set(hw, &cfg->aq_rss);
1854 hw_atl_b0_hw_rss_hash_set(hw, &cfg->aq_rss);
1855 return 0;
1856 }
1857
1858 static int
1859 atl_rss_hash_conf_get(struct rte_eth_dev *dev,
1860 struct rte_eth_rss_conf *rss_conf)
1861 {
1862 struct aq_hw_cfg_s *cfg =
1863 ATL_DEV_PRIVATE_TO_CFG(dev->data->dev_private);
1864
1865 rss_conf->rss_hf = cfg->is_rss ? ATL_RSS_OFFLOAD_ALL : 0;
1866 if (rss_conf->rss_key) {
1867 rss_conf->rss_key_len = cfg->aq_rss.hash_secret_key_size;
1868 memcpy(rss_conf->rss_key, cfg->aq_rss.hash_secret_key,
1869 rss_conf->rss_key_len);
1870 }
1871
1872 return 0;
1873 }
1874
1875 static bool
1876 is_device_supported(struct rte_eth_dev *dev, struct rte_pci_driver *drv)
1877 {
1878 if (strcmp(dev->device->driver->name, drv->driver.name))
1879 return false;
1880
1881 return true;
1882 }
1883
1884 bool
1885 is_atlantic_supported(struct rte_eth_dev *dev)
1886 {
1887 return is_device_supported(dev, &rte_atl_pmd);
1888 }
1889
1890 RTE_PMD_REGISTER_PCI(net_atlantic, rte_atl_pmd);
1891 RTE_PMD_REGISTER_PCI_TABLE(net_atlantic, pci_id_atl_map);
1892 RTE_PMD_REGISTER_KMOD_DEP(net_atlantic, "* igb_uio | uio_pci_generic");
1893
1894 RTE_INIT(atl_init_log)
1895 {
1896 atl_logtype_init = rte_log_register("pmd.net.atlantic.init");
1897 if (atl_logtype_init >= 0)
1898 rte_log_set_level(atl_logtype_init, RTE_LOG_NOTICE);
1899 atl_logtype_driver = rte_log_register("pmd.net.atlantic.driver");
1900 if (atl_logtype_driver >= 0)
1901 rte_log_set_level(atl_logtype_driver, RTE_LOG_NOTICE);
1902 }
Ceph