Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright(c) 2010-2017 Intel Corporation
3 : : */
4 : :
5 : : #include <ethdev_driver.h>
6 : :
7 : : #include "base/ixgbe_api.h"
8 : : #include "base/ixgbe_x550.h"
9 : : #include "ixgbe_ethdev.h"
10 : : #include "rte_pmd_ixgbe.h"
11 : :
12 : : int
13 : 0 : rte_pmd_ixgbe_set_vf_mac_addr(uint16_t port, uint16_t vf,
14 : : struct rte_ether_addr *mac_addr)
15 : : {
16 : : struct ixgbe_hw *hw;
17 : : struct ixgbe_vf_info *vfinfo;
18 : : int rar_entry;
19 : : uint8_t *new_mac = (uint8_t *)(mac_addr);
20 : : struct rte_eth_dev *dev;
21 : : struct rte_pci_device *pci_dev;
22 : :
23 [ # # ]: 0 : RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
24 : :
25 : 0 : dev = &rte_eth_devices[port];
26 : 0 : pci_dev = RTE_ETH_DEV_TO_PCI(dev);
27 : :
28 [ # # ]: 0 : if (!is_ixgbe_supported(dev))
29 : : return -ENOTSUP;
30 : :
31 [ # # ]: 0 : if (vf >= pci_dev->max_vfs)
32 : : return -EINVAL;
33 : :
34 : 0 : hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
35 : 0 : vfinfo = *(IXGBE_DEV_PRIVATE_TO_P_VFDATA(dev->data->dev_private));
36 [ # # ]: 0 : rar_entry = hw->mac.num_rar_entries - (vf + 1);
37 : :
38 : : if (rte_is_valid_assigned_ether_addr(
39 : : (struct rte_ether_addr *)new_mac)) {
40 [ # # ]: 0 : rte_memcpy(vfinfo[vf].vf_mac_addresses, new_mac,
41 : : RTE_ETHER_ADDR_LEN);
42 : 0 : return hw->mac.ops.set_rar(hw, rar_entry, new_mac, vf,
43 : : IXGBE_RAH_AV);
44 : : }
45 : : return -EINVAL;
46 : : }
47 : :
48 : : int
49 : 0 : rte_pmd_ixgbe_ping_vf(uint16_t port, uint16_t vf)
50 : : {
51 : : struct ixgbe_hw *hw;
52 : : struct ixgbe_vf_info *vfinfo;
53 : : struct rte_eth_dev *dev;
54 : : struct rte_pci_device *pci_dev;
55 : : uint32_t ctrl;
56 : :
57 [ # # ]: 0 : RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
58 : :
59 : 0 : dev = &rte_eth_devices[port];
60 : 0 : pci_dev = RTE_ETH_DEV_TO_PCI(dev);
61 : :
62 [ # # ]: 0 : if (!is_ixgbe_supported(dev))
63 : : return -ENOTSUP;
64 : :
65 [ # # ]: 0 : if (vf >= pci_dev->max_vfs)
66 : : return -EINVAL;
67 : :
68 : 0 : hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
69 : 0 : vfinfo = *(IXGBE_DEV_PRIVATE_TO_P_VFDATA(dev->data->dev_private));
70 : :
71 : 0 : ctrl = IXGBE_PF_CONTROL_MSG;
72 [ # # ]: 0 : if (vfinfo[vf].clear_to_send)
73 : 0 : ctrl |= IXGBE_VT_MSGTYPE_CTS;
74 : :
75 : 0 : ixgbe_write_mbx(hw, &ctrl, 1, vf);
76 : :
77 : 0 : return 0;
78 : : }
79 : :
80 : : int
81 : 0 : rte_pmd_ixgbe_set_vf_vlan_anti_spoof(uint16_t port, uint16_t vf, uint8_t on)
82 : : {
83 : : struct ixgbe_hw *hw;
84 : : struct ixgbe_mac_info *mac;
85 : : struct rte_eth_dev *dev;
86 : : struct rte_pci_device *pci_dev;
87 : :
88 [ # # ]: 0 : RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
89 : :
90 : 0 : dev = &rte_eth_devices[port];
91 : 0 : pci_dev = RTE_ETH_DEV_TO_PCI(dev);
92 : :
93 [ # # ]: 0 : if (!is_ixgbe_supported(dev))
94 : : return -ENOTSUP;
95 : :
96 [ # # ]: 0 : if (vf >= pci_dev->max_vfs)
97 : : return -EINVAL;
98 : :
99 [ # # ]: 0 : if (on > 1)
100 : : return -EINVAL;
101 : :
102 : 0 : hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
103 : : mac = &hw->mac;
104 : :
105 : 0 : mac->ops.set_vlan_anti_spoofing(hw, on, vf);
106 : :
107 : 0 : return 0;
108 : : }
109 : :
110 : : int
111 : 0 : rte_pmd_ixgbe_set_vf_mac_anti_spoof(uint16_t port, uint16_t vf, uint8_t on)
112 : : {
113 : : struct ixgbe_hw *hw;
114 : : struct ixgbe_mac_info *mac;
115 : : struct rte_eth_dev *dev;
116 : : struct rte_pci_device *pci_dev;
117 : :
118 [ # # ]: 0 : RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
119 : :
120 : 0 : dev = &rte_eth_devices[port];
121 : 0 : pci_dev = RTE_ETH_DEV_TO_PCI(dev);
122 : :
123 [ # # ]: 0 : if (!is_ixgbe_supported(dev))
124 : : return -ENOTSUP;
125 : :
126 [ # # ]: 0 : if (vf >= pci_dev->max_vfs)
127 : : return -EINVAL;
128 : :
129 [ # # ]: 0 : if (on > 1)
130 : : return -EINVAL;
131 : :
132 : 0 : hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
133 : : mac = &hw->mac;
134 : 0 : mac->ops.set_mac_anti_spoofing(hw, on, vf);
135 : :
136 : 0 : return 0;
137 : : }
138 : :
139 : : int
140 : 0 : rte_pmd_ixgbe_set_vf_vlan_insert(uint16_t port, uint16_t vf, uint16_t vlan_id)
141 : : {
142 : : struct ixgbe_hw *hw;
143 : : uint32_t ctrl;
144 : : struct rte_eth_dev *dev;
145 : : struct rte_pci_device *pci_dev;
146 : :
147 [ # # ]: 0 : RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
148 : :
149 : 0 : dev = &rte_eth_devices[port];
150 : 0 : pci_dev = RTE_ETH_DEV_TO_PCI(dev);
151 : :
152 [ # # ]: 0 : if (!is_ixgbe_supported(dev))
153 : : return -ENOTSUP;
154 : :
155 [ # # ]: 0 : if (vf >= pci_dev->max_vfs)
156 : : return -EINVAL;
157 : :
158 [ # # ]: 0 : if (vlan_id > RTE_ETHER_MAX_VLAN_ID)
159 : : return -EINVAL;
160 : :
161 : 0 : hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
162 : 0 : ctrl = IXGBE_READ_REG(hw, IXGBE_VMVIR(vf));
163 [ # # ]: 0 : if (vlan_id) {
164 : 0 : ctrl = vlan_id;
165 : 0 : ctrl |= IXGBE_VMVIR_VLANA_DEFAULT;
166 : : } else {
167 : : ctrl = 0;
168 : : }
169 : :
170 : 0 : IXGBE_WRITE_REG(hw, IXGBE_VMVIR(vf), ctrl);
171 : :
172 : 0 : return 0;
173 : : }
174 : :
175 : : int
176 : 0 : rte_pmd_ixgbe_set_tx_loopback(uint16_t port, uint8_t on)
177 : : {
178 : : struct ixgbe_hw *hw;
179 : : uint32_t ctrl;
180 : : struct rte_eth_dev *dev;
181 : :
182 [ # # ]: 0 : RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
183 : :
184 : 0 : dev = &rte_eth_devices[port];
185 : :
186 [ # # ]: 0 : if (!is_ixgbe_supported(dev))
187 : : return -ENOTSUP;
188 : :
189 [ # # ]: 0 : if (on > 1)
190 : : return -EINVAL;
191 : :
192 : 0 : hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
193 : 0 : ctrl = IXGBE_READ_REG(hw, IXGBE_PFDTXGSWC);
194 : : /* enable or disable VMDQ loopback */
195 [ # # ]: 0 : if (on)
196 : 0 : ctrl |= IXGBE_PFDTXGSWC_VT_LBEN;
197 : : else
198 : 0 : ctrl &= ~IXGBE_PFDTXGSWC_VT_LBEN;
199 : :
200 : 0 : IXGBE_WRITE_REG(hw, IXGBE_PFDTXGSWC, ctrl);
201 : :
202 : 0 : return 0;
203 : : }
204 : :
205 : : int
206 : 0 : rte_pmd_ixgbe_set_all_queues_drop_en(uint16_t port, uint8_t on)
207 : : {
208 : : struct ixgbe_hw *hw;
209 : : uint32_t reg_value;
210 : : int i;
211 : : int num_queues = (int)(IXGBE_QDE_IDX_MASK >> IXGBE_QDE_IDX_SHIFT);
212 : : struct rte_eth_dev *dev;
213 : :
214 [ # # ]: 0 : RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
215 : :
216 : 0 : dev = &rte_eth_devices[port];
217 : :
218 [ # # ]: 0 : if (!is_ixgbe_supported(dev))
219 : : return -ENOTSUP;
220 : :
221 [ # # ]: 0 : if (on > 1)
222 : : return -EINVAL;
223 : :
224 : 0 : hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
225 [ # # ]: 0 : for (i = 0; i <= num_queues; i++) {
226 : 0 : reg_value = IXGBE_QDE_WRITE |
227 : 0 : (i << IXGBE_QDE_IDX_SHIFT) |
228 : 0 : (on & IXGBE_QDE_ENABLE);
229 : 0 : IXGBE_WRITE_REG(hw, IXGBE_QDE, reg_value);
230 : : }
231 : :
232 : : return 0;
233 : : }
234 : :
235 : : int
236 : 0 : rte_pmd_ixgbe_set_vf_split_drop_en(uint16_t port, uint16_t vf, uint8_t on)
237 : : {
238 : : struct ixgbe_hw *hw;
239 : : uint32_t reg_value;
240 : : struct rte_eth_dev *dev;
241 : : struct rte_pci_device *pci_dev;
242 : :
243 [ # # ]: 0 : RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
244 : :
245 : 0 : dev = &rte_eth_devices[port];
246 : 0 : pci_dev = RTE_ETH_DEV_TO_PCI(dev);
247 : :
248 [ # # ]: 0 : if (!is_ixgbe_supported(dev))
249 : : return -ENOTSUP;
250 : :
251 : : /* only support VF's 0 to 63 */
252 [ # # # # ]: 0 : if ((vf >= pci_dev->max_vfs) || (vf > 63))
253 : : return -EINVAL;
254 : :
255 [ # # ]: 0 : if (on > 1)
256 : : return -EINVAL;
257 : :
258 : 0 : hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
259 [ # # ]: 0 : reg_value = IXGBE_READ_REG(hw, IXGBE_SRRCTL(vf));
260 [ # # ]: 0 : if (on)
261 : 0 : reg_value |= IXGBE_SRRCTL_DROP_EN;
262 : : else
263 : 0 : reg_value &= ~IXGBE_SRRCTL_DROP_EN;
264 : :
265 : 0 : IXGBE_WRITE_REG(hw, IXGBE_SRRCTL(vf), reg_value);
266 : :
267 : 0 : return 0;
268 : : }
269 : :
270 : : int
271 : 0 : rte_pmd_ixgbe_set_vf_vlan_stripq(uint16_t port, uint16_t vf, uint8_t on)
272 : : {
273 : : struct rte_eth_dev *dev;
274 : : struct rte_pci_device *pci_dev;
275 : : struct ixgbe_hw *hw;
276 : : uint16_t queues_per_pool;
277 : : uint32_t q;
278 : :
279 [ # # ]: 0 : RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
280 : :
281 : 0 : dev = &rte_eth_devices[port];
282 : 0 : pci_dev = RTE_ETH_DEV_TO_PCI(dev);
283 : 0 : hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
284 : :
285 [ # # ]: 0 : if (!is_ixgbe_supported(dev))
286 : : return -ENOTSUP;
287 : :
288 [ # # ]: 0 : if (vf >= pci_dev->max_vfs)
289 : : return -EINVAL;
290 : :
291 [ # # ]: 0 : if (on > 1)
292 : : return -EINVAL;
293 : :
294 [ # # ]: 0 : if (*dev->dev_ops->vlan_strip_queue_set == NULL)
295 : : return -ENOTSUP;
296 : :
297 : : /* The PF has 128 queue pairs and in SRIOV configuration
298 : : * those queues will be assigned to VF's, so RXDCTL
299 : : * registers will be dealing with queues which will be
300 : : * assigned to VF's.
301 : : * Let's say we have SRIOV configured with 31 VF's then the
302 : : * first 124 queues 0-123 will be allocated to VF's and only
303 : : * the last 4 queues 123-127 will be assigned to the PF.
304 : : */
305 [ # # ]: 0 : if (hw->mac.type == ixgbe_mac_82598EB)
306 : 0 : queues_per_pool = (uint16_t)hw->mac.max_rx_queues /
307 : : RTE_ETH_16_POOLS;
308 : : else
309 : 0 : queues_per_pool = (uint16_t)hw->mac.max_rx_queues /
310 : : RTE_ETH_64_POOLS;
311 : :
312 [ # # ]: 0 : for (q = 0; q < queues_per_pool; q++)
313 : 0 : (*dev->dev_ops->vlan_strip_queue_set)(dev,
314 : 0 : q + vf * queues_per_pool, on);
315 : : return 0;
316 : : }
317 : :
318 : : int
319 : 0 : rte_pmd_ixgbe_set_vf_rxmode(uint16_t port, uint16_t vf,
320 : : uint16_t rx_mask, uint8_t on)
321 : : {
322 : : int val = 0;
323 : : struct rte_eth_dev *dev;
324 : : struct rte_pci_device *pci_dev;
325 : : struct ixgbe_hw *hw;
326 : : uint32_t vmolr;
327 : :
328 [ # # ]: 0 : RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
329 : :
330 : 0 : dev = &rte_eth_devices[port];
331 : 0 : pci_dev = RTE_ETH_DEV_TO_PCI(dev);
332 : :
333 [ # # ]: 0 : if (!is_ixgbe_supported(dev))
334 : : return -ENOTSUP;
335 : :
336 [ # # ]: 0 : if (vf >= pci_dev->max_vfs)
337 : : return -EINVAL;
338 : :
339 [ # # ]: 0 : if (on > 1)
340 : : return -EINVAL;
341 : :
342 : 0 : hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
343 : 0 : vmolr = IXGBE_READ_REG(hw, IXGBE_VMOLR(vf));
344 : :
345 [ # # ]: 0 : if (hw->mac.type == ixgbe_mac_82598EB) {
346 : 0 : PMD_INIT_LOG(ERR, "setting VF receive mode set should be done"
347 : : " on 82599 hardware and newer");
348 : 0 : return -ENOTSUP;
349 : : }
350 [ # # ]: 0 : if (ixgbe_vt_check(hw) < 0)
351 : : return -ENOTSUP;
352 : :
353 : 0 : val = ixgbe_convert_vm_rx_mask_to_val(rx_mask, val);
354 : :
355 [ # # ]: 0 : if (on)
356 : 0 : vmolr |= val;
357 : : else
358 : 0 : vmolr &= ~val;
359 : :
360 : 0 : IXGBE_WRITE_REG(hw, IXGBE_VMOLR(vf), vmolr);
361 : :
362 : 0 : return 0;
363 : : }
364 : :
365 : : int
366 : 0 : rte_pmd_ixgbe_set_vf_rx(uint16_t port, uint16_t vf, uint8_t on)
367 : : {
368 : : struct rte_eth_dev *dev;
369 : : struct rte_pci_device *pci_dev;
370 : : uint32_t reg, addr;
371 : : uint32_t val;
372 : : const uint8_t bit1 = 0x1;
373 : : struct ixgbe_hw *hw;
374 : :
375 [ # # ]: 0 : RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
376 : :
377 : 0 : dev = &rte_eth_devices[port];
378 : 0 : pci_dev = RTE_ETH_DEV_TO_PCI(dev);
379 : :
380 [ # # ]: 0 : if (!is_ixgbe_supported(dev))
381 : : return -ENOTSUP;
382 : :
383 [ # # ]: 0 : if (vf >= pci_dev->max_vfs)
384 : : return -EINVAL;
385 : :
386 [ # # ]: 0 : if (on > 1)
387 : : return -EINVAL;
388 : :
389 : 0 : hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
390 : :
391 [ # # ]: 0 : if (ixgbe_vt_check(hw) < 0)
392 : : return -ENOTSUP;
393 : :
394 : : /* for vf >= 32, set bit in PFVFRE[1], otherwise PFVFRE[0] */
395 [ # # ]: 0 : if (vf >= 32) {
396 : : addr = IXGBE_VFRE(1);
397 : 0 : val = bit1 << (vf - 32);
398 : : } else {
399 : : addr = IXGBE_VFRE(0);
400 : 0 : val = bit1 << vf;
401 : : }
402 : :
403 : 0 : reg = IXGBE_READ_REG(hw, addr);
404 : :
405 [ # # ]: 0 : if (on)
406 : 0 : reg |= val;
407 : : else
408 : 0 : reg &= ~val;
409 : :
410 : 0 : IXGBE_WRITE_REG(hw, addr, reg);
411 : :
412 : 0 : return 0;
413 : : }
414 : :
415 : : int
416 : 0 : rte_pmd_ixgbe_set_vf_tx(uint16_t port, uint16_t vf, uint8_t on)
417 : : {
418 : : struct rte_eth_dev *dev;
419 : : struct rte_pci_device *pci_dev;
420 : : uint32_t reg, addr;
421 : : uint32_t val;
422 : : const uint8_t bit1 = 0x1;
423 : :
424 : : struct ixgbe_hw *hw;
425 : :
426 [ # # ]: 0 : RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
427 : :
428 : 0 : dev = &rte_eth_devices[port];
429 : 0 : pci_dev = RTE_ETH_DEV_TO_PCI(dev);
430 : :
431 [ # # ]: 0 : if (!is_ixgbe_supported(dev))
432 : : return -ENOTSUP;
433 : :
434 [ # # ]: 0 : if (vf >= pci_dev->max_vfs)
435 : : return -EINVAL;
436 : :
437 [ # # ]: 0 : if (on > 1)
438 : : return -EINVAL;
439 : :
440 : 0 : hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
441 [ # # ]: 0 : if (ixgbe_vt_check(hw) < 0)
442 : : return -ENOTSUP;
443 : :
444 : : /* for vf >= 32, set bit in PFVFTE[1], otherwise PFVFTE[0] */
445 [ # # ]: 0 : if (vf >= 32) {
446 : : addr = IXGBE_VFTE(1);
447 : 0 : val = bit1 << (vf - 32);
448 : : } else {
449 : : addr = IXGBE_VFTE(0);
450 : 0 : val = bit1 << vf;
451 : : }
452 : :
453 : 0 : reg = IXGBE_READ_REG(hw, addr);
454 : :
455 [ # # ]: 0 : if (on)
456 : 0 : reg |= val;
457 : : else
458 : 0 : reg &= ~val;
459 : :
460 : 0 : IXGBE_WRITE_REG(hw, addr, reg);
461 : :
462 : 0 : return 0;
463 : : }
464 : :
465 : : int
466 : 0 : rte_pmd_ixgbe_set_vf_vlan_filter(uint16_t port, uint16_t vlan,
467 : : uint64_t vf_mask, uint8_t vlan_on)
468 : : {
469 : : struct rte_eth_dev *dev;
470 : : int ret = 0;
471 : : uint16_t vf_idx;
472 : : struct ixgbe_hw *hw;
473 : :
474 [ # # ]: 0 : RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
475 : :
476 : 0 : dev = &rte_eth_devices[port];
477 : :
478 [ # # ]: 0 : if (!is_ixgbe_supported(dev))
479 : : return -ENOTSUP;
480 : :
481 [ # # ]: 0 : if (vlan > RTE_ETHER_MAX_VLAN_ID || vf_mask == 0)
482 : : return -EINVAL;
483 : :
484 : 0 : hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
485 [ # # ]: 0 : if (ixgbe_vt_check(hw) < 0)
486 : : return -ENOTSUP;
487 : :
488 [ # # ]: 0 : for (vf_idx = 0; vf_idx < 64; vf_idx++) {
489 [ # # ]: 0 : if (vf_mask & ((uint64_t)(1ULL << vf_idx))) {
490 : 0 : ret = hw->mac.ops.set_vfta(hw, vlan, vf_idx,
491 : : vlan_on, false);
492 [ # # ]: 0 : if (ret < 0)
493 : 0 : return ret;
494 : : }
495 : : }
496 : :
497 : : return ret;
498 : : }
499 : :
500 : : int
501 : 0 : rte_pmd_ixgbe_set_vf_rate_limit(uint16_t port, uint16_t vf,
502 : : uint32_t tx_rate, uint64_t q_msk)
503 : : {
504 : : struct rte_eth_dev *dev;
505 : :
506 [ # # ]: 0 : RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
507 : :
508 : 0 : dev = &rte_eth_devices[port];
509 : :
510 [ # # ]: 0 : if (!is_ixgbe_supported(dev))
511 : : return -ENOTSUP;
512 : :
513 : 0 : return ixgbe_set_vf_rate_limit(dev, vf, tx_rate, q_msk);
514 : : }
515 : :
516 : : int
517 : 0 : rte_pmd_ixgbe_macsec_enable(uint16_t port, uint8_t en, uint8_t rp)
518 : : {
519 : : struct rte_eth_dev *dev;
520 : : struct ixgbe_macsec_setting macsec_setting;
521 : :
522 [ # # ]: 0 : RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
523 : :
524 : 0 : dev = &rte_eth_devices[port];
525 : :
526 [ # # ]: 0 : if (!is_ixgbe_supported(dev))
527 : : return -ENOTSUP;
528 : :
529 : 0 : macsec_setting.offload_en = 1;
530 : 0 : macsec_setting.encrypt_en = en;
531 : 0 : macsec_setting.replayprotect_en = rp;
532 : :
533 : 0 : ixgbe_dev_macsec_setting_save(dev, &macsec_setting);
534 : :
535 : 0 : ixgbe_dev_macsec_register_enable(dev, &macsec_setting);
536 : :
537 : 0 : return 0;
538 : : }
539 : :
540 : : int
541 : 0 : rte_pmd_ixgbe_macsec_disable(uint16_t port)
542 : : {
543 : : struct rte_eth_dev *dev;
544 : :
545 [ # # ]: 0 : RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
546 : :
547 : 0 : dev = &rte_eth_devices[port];
548 : :
549 [ # # ]: 0 : if (!is_ixgbe_supported(dev))
550 : : return -ENOTSUP;
551 : :
552 : 0 : ixgbe_dev_macsec_setting_reset(dev);
553 : :
554 : 0 : ixgbe_dev_macsec_register_disable(dev);
555 : :
556 : 0 : return 0;
557 : : }
558 : :
559 : : int
560 : 0 : rte_pmd_ixgbe_macsec_config_txsc(uint16_t port, uint8_t *mac)
561 : : {
562 : : struct ixgbe_hw *hw;
563 : : struct rte_eth_dev *dev;
564 : : uint32_t ctrl;
565 : :
566 [ # # ]: 0 : RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
567 : :
568 : 0 : dev = &rte_eth_devices[port];
569 : :
570 [ # # ]: 0 : if (!is_ixgbe_supported(dev))
571 : : return -ENOTSUP;
572 : :
573 : 0 : hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
574 : :
575 : 0 : ctrl = mac[0] | (mac[1] << 8) | (mac[2] << 16) | (mac[3] << 24);
576 : 0 : IXGBE_WRITE_REG(hw, IXGBE_LSECTXSCL, ctrl);
577 : :
578 : 0 : ctrl = mac[4] | (mac[5] << 8);
579 : 0 : IXGBE_WRITE_REG(hw, IXGBE_LSECTXSCH, ctrl);
580 : :
581 : 0 : return 0;
582 : : }
583 : :
584 : : int
585 : 0 : rte_pmd_ixgbe_macsec_config_rxsc(uint16_t port, uint8_t *mac, uint16_t pi)
586 : : {
587 : : struct ixgbe_hw *hw;
588 : : struct rte_eth_dev *dev;
589 : : uint32_t ctrl;
590 : :
591 [ # # ]: 0 : RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
592 : :
593 : 0 : dev = &rte_eth_devices[port];
594 : :
595 [ # # ]: 0 : if (!is_ixgbe_supported(dev))
596 : : return -ENOTSUP;
597 : :
598 : 0 : hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
599 : :
600 : 0 : ctrl = mac[0] | (mac[1] << 8) | (mac[2] << 16) | (mac[3] << 24);
601 : 0 : IXGBE_WRITE_REG(hw, IXGBE_LSECRXSCL, ctrl);
602 : :
603 [ # # ]: 0 : pi = rte_cpu_to_be_16(pi);
604 : 0 : ctrl = mac[4] | (mac[5] << 8) | (pi << 16);
605 : 0 : IXGBE_WRITE_REG(hw, IXGBE_LSECRXSCH, ctrl);
606 : :
607 : 0 : return 0;
608 : : }
609 : :
610 : : int
611 : 0 : rte_pmd_ixgbe_macsec_select_txsa(uint16_t port, uint8_t idx, uint8_t an,
612 : : uint32_t pn, uint8_t *key)
613 : : {
614 : : struct ixgbe_hw *hw;
615 : : struct rte_eth_dev *dev;
616 : : uint32_t ctrl, i;
617 : :
618 [ # # ]: 0 : RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
619 : :
620 : 0 : dev = &rte_eth_devices[port];
621 : :
622 [ # # ]: 0 : if (!is_ixgbe_supported(dev))
623 : : return -ENOTSUP;
624 : :
625 : 0 : hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
626 : :
627 [ # # ]: 0 : if (idx != 0 && idx != 1)
628 : : return -EINVAL;
629 : :
630 [ # # ]: 0 : if (an >= 4)
631 : : return -EINVAL;
632 : :
633 : : hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
634 : :
635 : : /* Set the PN and key */
636 [ # # ]: 0 : pn = rte_cpu_to_be_32(pn);
637 [ # # ]: 0 : if (idx == 0) {
638 : 0 : IXGBE_WRITE_REG(hw, IXGBE_LSECTXPN0, pn);
639 : :
640 [ # # ]: 0 : for (i = 0; i < 4; i++) {
641 : 0 : ctrl = (key[i * 4 + 0] << 0) |
642 : 0 : (key[i * 4 + 1] << 8) |
643 : 0 : (key[i * 4 + 2] << 16) |
644 : 0 : (key[i * 4 + 3] << 24);
645 : 0 : IXGBE_WRITE_REG(hw, IXGBE_LSECTXKEY0(i), ctrl);
646 : : }
647 : : } else {
648 : 0 : IXGBE_WRITE_REG(hw, IXGBE_LSECTXPN1, pn);
649 : :
650 [ # # ]: 0 : for (i = 0; i < 4; i++) {
651 : 0 : ctrl = (key[i * 4 + 0] << 0) |
652 : 0 : (key[i * 4 + 1] << 8) |
653 : 0 : (key[i * 4 + 2] << 16) |
654 : 0 : (key[i * 4 + 3] << 24);
655 : 0 : IXGBE_WRITE_REG(hw, IXGBE_LSECTXKEY1(i), ctrl);
656 : : }
657 : : }
658 : :
659 : : /* Set AN and select the SA */
660 : 0 : ctrl = (an << idx * 2) | (idx << 4);
661 : 0 : IXGBE_WRITE_REG(hw, IXGBE_LSECTXSA, ctrl);
662 : :
663 : 0 : return 0;
664 : : }
665 : :
666 : : int
667 : 0 : rte_pmd_ixgbe_macsec_select_rxsa(uint16_t port, uint8_t idx, uint8_t an,
668 : : uint32_t pn, uint8_t *key)
669 : : {
670 : : struct ixgbe_hw *hw;
671 : : struct rte_eth_dev *dev;
672 : : uint32_t ctrl, i;
673 : :
674 [ # # ]: 0 : RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
675 : :
676 : 0 : dev = &rte_eth_devices[port];
677 : :
678 [ # # ]: 0 : if (!is_ixgbe_supported(dev))
679 : : return -ENOTSUP;
680 : :
681 : 0 : hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
682 : :
683 [ # # ]: 0 : if (idx != 0 && idx != 1)
684 : : return -EINVAL;
685 : :
686 [ # # ]: 0 : if (an >= 4)
687 : : return -EINVAL;
688 : :
689 : : /* Set the PN */
690 [ # # ]: 0 : pn = rte_cpu_to_be_32(pn);
691 : 0 : IXGBE_WRITE_REG(hw, IXGBE_LSECRXPN(idx), pn);
692 : :
693 : : /* Set the key */
694 [ # # ]: 0 : for (i = 0; i < 4; i++) {
695 : 0 : ctrl = (key[i * 4 + 0] << 0) |
696 : 0 : (key[i * 4 + 1] << 8) |
697 : 0 : (key[i * 4 + 2] << 16) |
698 : 0 : (key[i * 4 + 3] << 24);
699 : 0 : IXGBE_WRITE_REG(hw, IXGBE_LSECRXKEY(idx, i), ctrl);
700 : : }
701 : :
702 : : /* Set the AN and validate the SA */
703 : 0 : ctrl = an | (1 << 2);
704 : 0 : IXGBE_WRITE_REG(hw, IXGBE_LSECRXSA(idx), ctrl);
705 : :
706 : 0 : return 0;
707 : : }
708 : :
709 : : int
710 : 0 : rte_pmd_ixgbe_set_tc_bw_alloc(uint16_t port,
711 : : uint8_t tc_num,
712 : : uint8_t *bw_weight)
713 : : {
714 : : struct rte_eth_dev *dev;
715 : : struct ixgbe_dcb_config *dcb_config;
716 : : struct ixgbe_dcb_tc_config *tc;
717 : : struct rte_eth_conf *eth_conf;
718 : : struct ixgbe_bw_conf *bw_conf;
719 : : uint8_t i;
720 : : uint8_t nb_tcs;
721 : : uint16_t sum;
722 : :
723 [ # # ]: 0 : RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
724 : :
725 : 0 : dev = &rte_eth_devices[port];
726 : :
727 [ # # ]: 0 : if (!is_ixgbe_supported(dev))
728 : : return -ENOTSUP;
729 : :
730 [ # # ]: 0 : if (tc_num > IXGBE_DCB_MAX_TRAFFIC_CLASS) {
731 : 0 : PMD_DRV_LOG(ERR, "TCs should be no more than %d.",
732 : : IXGBE_DCB_MAX_TRAFFIC_CLASS);
733 : 0 : return -EINVAL;
734 : : }
735 : :
736 : 0 : dcb_config = IXGBE_DEV_PRIVATE_TO_DCB_CFG(dev->data->dev_private);
737 : : bw_conf = IXGBE_DEV_PRIVATE_TO_BW_CONF(dev->data->dev_private);
738 : : eth_conf = &dev->data->dev_conf;
739 : :
740 [ # # ]: 0 : if (eth_conf->txmode.mq_mode == RTE_ETH_MQ_TX_DCB) {
741 : 0 : nb_tcs = eth_conf->tx_adv_conf.dcb_tx_conf.nb_tcs;
742 [ # # ]: 0 : } else if (eth_conf->txmode.mq_mode == RTE_ETH_MQ_TX_VMDQ_DCB) {
743 [ # # ]: 0 : if (eth_conf->tx_adv_conf.vmdq_dcb_tx_conf.nb_queue_pools ==
744 : : RTE_ETH_32_POOLS)
745 : : nb_tcs = RTE_ETH_4_TCS;
746 : : else
747 : : nb_tcs = RTE_ETH_8_TCS;
748 : : } else {
749 : : nb_tcs = 1;
750 : : }
751 : :
752 [ # # ]: 0 : if (nb_tcs != tc_num) {
753 : 0 : PMD_DRV_LOG(ERR,
754 : : "Weight should be set for all %d enabled TCs.",
755 : : nb_tcs);
756 : 0 : return -EINVAL;
757 : : }
758 : :
759 : : sum = 0;
760 [ # # ]: 0 : for (i = 0; i < nb_tcs; i++)
761 : 0 : sum += bw_weight[i];
762 [ # # ]: 0 : if (sum != 100) {
763 : 0 : PMD_DRV_LOG(ERR,
764 : : "The summary of the TC weight should be 100.");
765 : 0 : return -EINVAL;
766 : : }
767 : :
768 [ # # ]: 0 : for (i = 0; i < nb_tcs; i++) {
769 : 0 : tc = &dcb_config->tc_config[i];
770 : 0 : tc->path[IXGBE_DCB_TX_CONFIG].bwg_percent = bw_weight[i];
771 : : }
772 [ # # ]: 0 : for (; i < IXGBE_DCB_MAX_TRAFFIC_CLASS; i++) {
773 : 0 : tc = &dcb_config->tc_config[i];
774 : 0 : tc->path[IXGBE_DCB_TX_CONFIG].bwg_percent = 0;
775 : : }
776 : :
777 : 0 : bw_conf->tc_num = nb_tcs;
778 : :
779 : 0 : return 0;
780 : : }
781 : :
782 : : int
783 : 0 : rte_pmd_ixgbe_upd_fctrl_sbp(uint16_t port, int enable)
784 : : {
785 : : struct ixgbe_hw *hw;
786 : : struct rte_eth_dev *dev;
787 : : uint32_t fctrl;
788 : :
789 [ # # ]: 0 : RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
790 : 0 : dev = &rte_eth_devices[port];
791 [ # # ]: 0 : if (!is_ixgbe_supported(dev))
792 : : return -ENOTSUP;
793 : :
794 : 0 : hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
795 [ # # ]: 0 : if (!hw)
796 : : return -ENOTSUP;
797 : :
798 : 0 : fctrl = IXGBE_READ_REG(hw, IXGBE_FCTRL);
799 : :
800 : : /* If 'enable' set the SBP bit else clear it */
801 [ # # ]: 0 : if (enable)
802 : 0 : fctrl |= IXGBE_FCTRL_SBP;
803 : : else
804 : 0 : fctrl &= ~(IXGBE_FCTRL_SBP);
805 : :
806 : 0 : IXGBE_WRITE_REG(hw, IXGBE_FCTRL, fctrl);
807 : 0 : return 0;
808 : : }
809 : :
810 : : #ifdef RTE_LIBRTE_IXGBE_BYPASS
811 : : int
812 : 0 : rte_pmd_ixgbe_bypass_init(uint16_t port_id)
813 : : {
814 : : struct rte_eth_dev *dev;
815 : :
816 [ # # ]: 0 : RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
817 : :
818 : 0 : dev = &rte_eth_devices[port_id];
819 [ # # ]: 0 : if (!is_ixgbe_supported(dev))
820 : : return -ENOTSUP;
821 : :
822 : 0 : ixgbe_bypass_init(dev);
823 : 0 : return 0;
824 : : }
825 : :
826 : : int
827 : 0 : rte_pmd_ixgbe_bypass_state_show(uint16_t port_id, uint32_t *state)
828 : : {
829 : : struct rte_eth_dev *dev;
830 : :
831 [ # # ]: 0 : RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
832 : :
833 : 0 : dev = &rte_eth_devices[port_id];
834 [ # # ]: 0 : if (!is_ixgbe_supported(dev))
835 : : return -ENOTSUP;
836 : :
837 : 0 : return ixgbe_bypass_state_show(dev, state);
838 : : }
839 : :
840 : : int
841 : 0 : rte_pmd_ixgbe_bypass_state_set(uint16_t port_id, uint32_t *new_state)
842 : : {
843 : : struct rte_eth_dev *dev;
844 : :
845 [ # # ]: 0 : RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
846 : :
847 : 0 : dev = &rte_eth_devices[port_id];
848 [ # # ]: 0 : if (!is_ixgbe_supported(dev))
849 : : return -ENOTSUP;
850 : :
851 : 0 : return ixgbe_bypass_state_store(dev, new_state);
852 : : }
853 : :
854 : : int
855 : 0 : rte_pmd_ixgbe_bypass_event_show(uint16_t port_id,
856 : : uint32_t event,
857 : : uint32_t *state)
858 : : {
859 : : struct rte_eth_dev *dev;
860 : :
861 [ # # ]: 0 : RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
862 : :
863 : 0 : dev = &rte_eth_devices[port_id];
864 [ # # ]: 0 : if (!is_ixgbe_supported(dev))
865 : : return -ENOTSUP;
866 : :
867 : 0 : return ixgbe_bypass_event_show(dev, event, state);
868 : : }
869 : :
870 : : int
871 : 0 : rte_pmd_ixgbe_bypass_event_store(uint16_t port_id,
872 : : uint32_t event,
873 : : uint32_t state)
874 : : {
875 : : struct rte_eth_dev *dev;
876 : :
877 [ # # ]: 0 : RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
878 : :
879 : 0 : dev = &rte_eth_devices[port_id];
880 [ # # ]: 0 : if (!is_ixgbe_supported(dev))
881 : : return -ENOTSUP;
882 : :
883 : 0 : return ixgbe_bypass_event_store(dev, event, state);
884 : : }
885 : :
886 : : int
887 : 0 : rte_pmd_ixgbe_bypass_wd_timeout_store(uint16_t port_id, uint32_t timeout)
888 : : {
889 : : struct rte_eth_dev *dev;
890 : :
891 [ # # ]: 0 : RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
892 : :
893 : 0 : dev = &rte_eth_devices[port_id];
894 [ # # ]: 0 : if (!is_ixgbe_supported(dev))
895 : : return -ENOTSUP;
896 : :
897 : 0 : return ixgbe_bypass_wd_timeout_store(dev, timeout);
898 : : }
899 : :
900 : : int
901 : 0 : rte_pmd_ixgbe_bypass_ver_show(uint16_t port_id, uint32_t *ver)
902 : : {
903 : : struct rte_eth_dev *dev;
904 : :
905 [ # # ]: 0 : RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
906 : :
907 : 0 : dev = &rte_eth_devices[port_id];
908 [ # # ]: 0 : if (!is_ixgbe_supported(dev))
909 : : return -ENOTSUP;
910 : :
911 : 0 : return ixgbe_bypass_ver_show(dev, ver);
912 : : }
913 : :
914 : : int
915 : 0 : rte_pmd_ixgbe_bypass_wd_timeout_show(uint16_t port_id, uint32_t *wd_timeout)
916 : : {
917 : : struct rte_eth_dev *dev;
918 : :
919 [ # # ]: 0 : RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
920 : :
921 : 0 : dev = &rte_eth_devices[port_id];
922 [ # # ]: 0 : if (!is_ixgbe_supported(dev))
923 : : return -ENOTSUP;
924 : :
925 : 0 : return ixgbe_bypass_wd_timeout_show(dev, wd_timeout);
926 : : }
927 : :
928 : : int
929 : 0 : rte_pmd_ixgbe_bypass_wd_reset(uint16_t port_id)
930 : : {
931 : : struct rte_eth_dev *dev;
932 : :
933 [ # # ]: 0 : RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
934 : :
935 : 0 : dev = &rte_eth_devices[port_id];
936 [ # # ]: 0 : if (!is_ixgbe_supported(dev))
937 : : return -ENOTSUP;
938 : :
939 : 0 : return ixgbe_bypass_wd_reset(dev);
940 : : }
941 : : #endif
942 : :
943 : : /**
944 : : * rte_pmd_ixgbe_acquire_swfw - Acquire SWFW semaphore
945 : : * @hw: pointer to hardware structure
946 : : * @mask: Mask to specify which semaphore to acquire
947 : : *
948 : : * Acquires the SWFW semaphore and get the shared phy token as needed
949 : : */
950 : 0 : STATIC s32 rte_pmd_ixgbe_acquire_swfw(struct ixgbe_hw *hw, u32 mask)
951 : : {
952 : : int retries = FW_PHY_TOKEN_RETRIES;
953 : : s32 status = IXGBE_SUCCESS;
954 : :
955 [ # # ]: 0 : while (--retries) {
956 : 0 : status = ixgbe_acquire_swfw_semaphore(hw, mask);
957 [ # # ]: 0 : if (status) {
958 : 0 : PMD_DRV_LOG(ERR, "Get SWFW sem failed, Status = %d",
959 : : status);
960 : 0 : return status;
961 : : }
962 : 0 : status = ixgbe_get_phy_token(hw);
963 [ # # ]: 0 : if (status == IXGBE_SUCCESS)
964 : : return IXGBE_SUCCESS;
965 : :
966 [ # # ]: 0 : if (status == IXGBE_ERR_TOKEN_RETRY)
967 : 0 : PMD_DRV_LOG(ERR, "Get PHY token failed, Status = %d",
968 : : status);
969 : :
970 : 0 : ixgbe_release_swfw_semaphore(hw, mask);
971 [ # # ]: 0 : if (status != IXGBE_ERR_TOKEN_RETRY) {
972 : 0 : PMD_DRV_LOG(ERR,
973 : : "Retry get PHY token failed, Status=%d",
974 : : status);
975 : 0 : return status;
976 : : }
977 : : }
978 : 0 : PMD_DRV_LOG(ERR, "swfw acquisition retries failed!: PHY ID = 0x%08X",
979 : : hw->phy.id);
980 : 0 : return status;
981 : : }
982 : :
983 : : /**
984 : : * rte_pmd_ixgbe_release_swfw_sync - Release SWFW semaphore
985 : : * @hw: pointer to hardware structure
986 : : * @mask: Mask to specify which semaphore to release
987 : : *
988 : : * Releases the SWFW semaphore and puts the shared phy token as needed
989 : : */
990 : : STATIC void rte_pmd_ixgbe_release_swfw(struct ixgbe_hw *hw, u32 mask)
991 : : {
992 : 0 : ixgbe_put_phy_token(hw);
993 : 0 : ixgbe_release_swfw_semaphore(hw, mask);
994 : : }
995 : :
996 : : int
997 : 0 : rte_pmd_ixgbe_mdio_lock(uint16_t port)
998 : : {
999 : : struct ixgbe_hw *hw;
1000 : : struct rte_eth_dev *dev;
1001 : : u32 swfw_mask;
1002 : :
1003 [ # # ]: 0 : RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
1004 : 0 : dev = &rte_eth_devices[port];
1005 [ # # ]: 0 : if (!is_ixgbe_supported(dev))
1006 : : return -ENOTSUP;
1007 : :
1008 : 0 : hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1009 [ # # ]: 0 : if (!hw)
1010 : : return -ENOTSUP;
1011 : :
1012 [ # # ]: 0 : if (hw->bus.lan_id)
1013 : : swfw_mask = IXGBE_GSSR_PHY1_SM;
1014 : : else
1015 : : swfw_mask = IXGBE_GSSR_PHY0_SM;
1016 : :
1017 [ # # ]: 0 : if (rte_pmd_ixgbe_acquire_swfw(hw, swfw_mask))
1018 : 0 : return IXGBE_ERR_SWFW_SYNC;
1019 : :
1020 : : return IXGBE_SUCCESS;
1021 : : }
1022 : :
1023 : : int
1024 : 0 : rte_pmd_ixgbe_mdio_unlock(uint16_t port)
1025 : : {
1026 : : struct rte_eth_dev *dev;
1027 : : struct ixgbe_hw *hw;
1028 : : u32 swfw_mask;
1029 : :
1030 [ # # ]: 0 : RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
1031 : :
1032 : 0 : dev = &rte_eth_devices[port];
1033 [ # # ]: 0 : if (!is_ixgbe_supported(dev))
1034 : : return -ENOTSUP;
1035 : :
1036 : 0 : hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1037 [ # # ]: 0 : if (!hw)
1038 : : return -ENOTSUP;
1039 : :
1040 [ # # ]: 0 : if (hw->bus.lan_id)
1041 : : swfw_mask = IXGBE_GSSR_PHY1_SM;
1042 : : else
1043 : : swfw_mask = IXGBE_GSSR_PHY0_SM;
1044 : :
1045 : : rte_pmd_ixgbe_release_swfw(hw, swfw_mask);
1046 : :
1047 : 0 : return IXGBE_SUCCESS;
1048 : : }
1049 : :
1050 : : int
1051 : 0 : rte_pmd_ixgbe_mdio_unlocked_read(uint16_t port, uint32_t reg_addr,
1052 : : uint32_t dev_type, uint16_t *phy_data)
1053 : : {
1054 : : struct ixgbe_hw *hw;
1055 : : struct rte_eth_dev *dev;
1056 : : u32 i, data, command;
1057 : :
1058 [ # # ]: 0 : RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
1059 : 0 : dev = &rte_eth_devices[port];
1060 [ # # ]: 0 : if (!is_ixgbe_supported(dev))
1061 : : return -ENOTSUP;
1062 : :
1063 : 0 : hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1064 [ # # ]: 0 : if (!hw)
1065 : : return -ENOTSUP;
1066 : :
1067 : : /* Setup and write the read command */
1068 : 0 : command = (reg_addr << IXGBE_MSCA_DEV_TYPE_SHIFT) |
1069 : 0 : (dev_type << IXGBE_MSCA_PHY_ADDR_SHIFT) |
1070 : : IXGBE_MSCA_OLD_PROTOCOL | IXGBE_MSCA_READ_AUTOINC |
1071 : : IXGBE_MSCA_MDI_COMMAND;
1072 : :
1073 : 0 : IXGBE_WRITE_REG(hw, IXGBE_MSCA, command);
1074 : :
1075 : : /* Check every 10 usec to see if the access completed.
1076 : : * The MDI Command bit will clear when the operation is
1077 : : * complete
1078 : : */
1079 [ # # ]: 0 : for (i = 0; i < IXGBE_MDIO_COMMAND_TIMEOUT; i++) {
1080 : 0 : usec_delay(10);
1081 : :
1082 : 0 : command = IXGBE_READ_REG(hw, IXGBE_MSCA);
1083 [ # # ]: 0 : if (!(command & IXGBE_MSCA_MDI_COMMAND))
1084 : : break;
1085 : : }
1086 [ # # ]: 0 : if (command & IXGBE_MSCA_MDI_COMMAND)
1087 : : return IXGBE_ERR_PHY;
1088 : :
1089 : : /* Read operation is complete. Get the data from MSRWD */
1090 : 0 : data = IXGBE_READ_REG(hw, IXGBE_MSRWD);
1091 : 0 : data >>= IXGBE_MSRWD_READ_DATA_SHIFT;
1092 : 0 : *phy_data = (u16)data;
1093 : :
1094 : 0 : return 0;
1095 : : }
1096 : :
1097 : : int
1098 : 0 : rte_pmd_ixgbe_mdio_unlocked_write(uint16_t port, uint32_t reg_addr,
1099 : : uint32_t dev_type, uint16_t phy_data)
1100 : : {
1101 : : struct ixgbe_hw *hw;
1102 : : u32 i, command;
1103 : : struct rte_eth_dev *dev;
1104 : :
1105 [ # # ]: 0 : RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
1106 : 0 : dev = &rte_eth_devices[port];
1107 [ # # ]: 0 : if (!is_ixgbe_supported(dev))
1108 : : return -ENOTSUP;
1109 : :
1110 : 0 : hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1111 [ # # ]: 0 : if (!hw)
1112 : : return -ENOTSUP;
1113 : :
1114 : : /* Put the data in the MDI single read and write data register*/
1115 : 0 : IXGBE_WRITE_REG(hw, IXGBE_MSRWD, (u32)phy_data);
1116 : :
1117 : : /* Setup and write the write command */
1118 : 0 : command = (reg_addr << IXGBE_MSCA_DEV_TYPE_SHIFT) |
1119 : 0 : (dev_type << IXGBE_MSCA_PHY_ADDR_SHIFT) |
1120 : : IXGBE_MSCA_OLD_PROTOCOL | IXGBE_MSCA_WRITE |
1121 : : IXGBE_MSCA_MDI_COMMAND;
1122 : :
1123 : 0 : IXGBE_WRITE_REG(hw, IXGBE_MSCA, command);
1124 : :
1125 : : /* Check every 10 usec to see if the access completed.
1126 : : * The MDI Command bit will clear when the operation is
1127 : : * complete
1128 : : */
1129 [ # # ]: 0 : for (i = 0; i < IXGBE_MDIO_COMMAND_TIMEOUT; i++) {
1130 : 0 : usec_delay(10);
1131 : :
1132 : 0 : command = IXGBE_READ_REG(hw, IXGBE_MSCA);
1133 [ # # ]: 0 : if (!(command & IXGBE_MSCA_MDI_COMMAND))
1134 : : break;
1135 : : }
1136 [ # # ]: 0 : if (command & IXGBE_MSCA_MDI_COMMAND) {
1137 : 0 : ERROR_REPORT1(IXGBE_ERROR_POLLING,
1138 : : "PHY write cmd didn't complete\n");
1139 : 0 : return IXGBE_ERR_PHY;
1140 : : }
1141 : : return 0;
1142 : : }
1143 : :
1144 : : int
1145 : 0 : rte_pmd_ixgbe_get_fdir_info(uint16_t port, struct rte_eth_fdir_info *fdir_info)
1146 : : {
1147 : : struct rte_eth_dev *dev;
1148 : :
1149 [ # # ]: 0 : RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
1150 : :
1151 : 0 : dev = &rte_eth_devices[port];
1152 [ # # ]: 0 : if (!is_ixgbe_supported(dev))
1153 : : return -ENOTSUP;
1154 : :
1155 : 0 : ixgbe_fdir_info_get(dev, fdir_info);
1156 : :
1157 : 0 : return 0;
1158 : : }
1159 : :
1160 : : int
1161 : 0 : rte_pmd_ixgbe_get_fdir_stats(uint16_t port,
1162 : : struct rte_eth_fdir_stats *fdir_stats)
1163 : : {
1164 : : struct rte_eth_dev *dev;
1165 : :
1166 [ # # ]: 0 : RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
1167 : :
1168 : 0 : dev = &rte_eth_devices[port];
1169 [ # # ]: 0 : if (!is_ixgbe_supported(dev))
1170 : : return -ENOTSUP;
1171 : :
1172 : 0 : ixgbe_fdir_stats_get(dev, fdir_stats);
1173 : :
1174 : 0 : return 0;
1175 : : }
|
