Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright(c) 2024 Realtek Corporation. All rights reserved
3 : : */
4 : :
5 : : #include <stdio.h>
6 : : #include <errno.h>
7 : : #include <stdint.h>
8 : :
9 : : #include <rte_eal.h>
10 : :
11 : : #include <rte_common.h>
12 : : #include <rte_interrupts.h>
13 : : #include <rte_byteorder.h>
14 : : #include <rte_pci.h>
15 : : #include <bus_pci_driver.h>
16 : : #include <rte_ether.h>
17 : : #include <ethdev_driver.h>
18 : : #include <ethdev_pci.h>
19 : : #include <rte_memory.h>
20 : : #include <rte_malloc.h>
21 : : #include <dev_driver.h>
22 : :
23 : : #include "r8169_ethdev.h"
24 : : #include "r8169_compat.h"
25 : : #include "r8169_logs.h"
26 : : #include "r8169_hw.h"
27 : : #include "r8169_dash.h"
28 : :
29 : : static int rtl_dev_configure(struct rte_eth_dev *dev __rte_unused);
30 : : static int rtl_dev_start(struct rte_eth_dev *dev);
31 : : static int rtl_dev_stop(struct rte_eth_dev *dev);
32 : : static int rtl_dev_reset(struct rte_eth_dev *dev);
33 : : static int rtl_dev_close(struct rte_eth_dev *dev);
34 : : static int rtl_dev_link_update(struct rte_eth_dev *dev, int wait __rte_unused);
35 : : static int rtl_dev_set_link_up(struct rte_eth_dev *dev);
36 : : static int rtl_dev_set_link_down(struct rte_eth_dev *dev);
37 : : static int rtl_dev_infos_get(struct rte_eth_dev *dev,
38 : : struct rte_eth_dev_info *dev_info);
39 : : static int rtl_dev_stats_get(struct rte_eth_dev *dev,
40 : : struct rte_eth_stats *rte_stats,
41 : : struct eth_queue_stats *qstats);
42 : : static int rtl_dev_stats_reset(struct rte_eth_dev *dev);
43 : : static int rtl_promiscuous_enable(struct rte_eth_dev *dev);
44 : : static int rtl_promiscuous_disable(struct rte_eth_dev *dev);
45 : : static int rtl_allmulticast_enable(struct rte_eth_dev *dev);
46 : : static int rtl_allmulticast_disable(struct rte_eth_dev *dev);
47 : : static int rtl_dev_mtu_set(struct rte_eth_dev *dev, uint16_t mtu);
48 : : static int rtl_fw_version_get(struct rte_eth_dev *dev, char *fw_version,
49 : : size_t fw_size);
50 : : static int rtl_reta_update(struct rte_eth_dev *dev,
51 : : struct rte_eth_rss_reta_entry64 *reta_conf,
52 : : uint16_t reta_size);
53 : : static int rtl_reta_query(struct rte_eth_dev *dev,
54 : : struct rte_eth_rss_reta_entry64 *reta_conf,
55 : : uint16_t reta_size);
56 : : static int rtl_rss_hash_update(struct rte_eth_dev *dev,
57 : : struct rte_eth_rss_conf *rss_conf);
58 : : static int rtl_rss_hash_conf_get(struct rte_eth_dev *dev,
59 : : struct rte_eth_rss_conf *rss_conf);
60 : : /*
61 : : * The set of PCI devices this driver supports
62 : : */
63 : : static const struct rte_pci_id pci_id_r8169_map[] = {
64 : : { RTE_PCI_DEVICE(PCI_VENDOR_ID_REALTEK, 0x8125) },
65 : : { RTE_PCI_DEVICE(PCI_VENDOR_ID_REALTEK, 0x8162) },
66 : : { RTE_PCI_DEVICE(PCI_VENDOR_ID_REALTEK, 0x8126) },
67 : : { RTE_PCI_DEVICE(PCI_VENDOR_ID_REALTEK, 0x5000) },
68 : : { RTE_PCI_DEVICE(PCI_VENDOR_ID_REALTEK, 0x8168) },
69 : : { RTE_PCI_DEVICE(PCI_VENDOR_ID_REALTEK, 0x8127) },
70 : : { RTE_PCI_DEVICE(PCI_VENDOR_ID_REALTEK, 0x0E10) },
71 : : {.vendor_id = 0, /* sentinel */ },
72 : : };
73 : :
74 : : static const struct rte_eth_desc_lim rx_desc_lim = {
75 : : .nb_max = RTL_MAX_RX_DESC,
76 : : .nb_min = RTL_MIN_RX_DESC,
77 : : .nb_align = RTL_DESC_ALIGN,
78 : : };
79 : :
80 : : static const struct rte_eth_desc_lim tx_desc_lim = {
81 : : .nb_max = RTL_MAX_TX_DESC,
82 : : .nb_min = RTL_MIN_TX_DESC,
83 : : .nb_align = RTL_DESC_ALIGN,
84 : : .nb_seg_max = RTL_MAX_TX_SEG,
85 : : .nb_mtu_seg_max = RTL_MAX_TX_SEG,
86 : : };
87 : :
88 : : static const struct eth_dev_ops rtl_eth_dev_ops = {
89 : : .dev_configure = rtl_dev_configure,
90 : : .dev_start = rtl_dev_start,
91 : : .dev_stop = rtl_dev_stop,
92 : : .dev_close = rtl_dev_close,
93 : : .dev_reset = rtl_dev_reset,
94 : : .dev_set_link_up = rtl_dev_set_link_up,
95 : : .dev_set_link_down = rtl_dev_set_link_down,
96 : : .dev_infos_get = rtl_dev_infos_get,
97 : :
98 : : .promiscuous_enable = rtl_promiscuous_enable,
99 : : .promiscuous_disable = rtl_promiscuous_disable,
100 : : .allmulticast_enable = rtl_allmulticast_enable,
101 : : .allmulticast_disable = rtl_allmulticast_disable,
102 : :
103 : : .link_update = rtl_dev_link_update,
104 : :
105 : : .stats_get = rtl_dev_stats_get,
106 : : .stats_reset = rtl_dev_stats_reset,
107 : :
108 : : .mtu_set = rtl_dev_mtu_set,
109 : :
110 : : .fw_version_get = rtl_fw_version_get,
111 : :
112 : : .rx_queue_setup = rtl_rx_queue_setup,
113 : : .rx_queue_release = rtl_rx_queue_release,
114 : : .rxq_info_get = rtl_rxq_info_get,
115 : :
116 : : .tx_queue_setup = rtl_tx_queue_setup,
117 : : .tx_queue_release = rtl_tx_queue_release,
118 : : .tx_done_cleanup = rtl_tx_done_cleanup,
119 : : .txq_info_get = rtl_txq_info_get,
120 : :
121 : : .reta_update = rtl_reta_update,
122 : : .reta_query = rtl_reta_query,
123 : : .rss_hash_update = rtl_rss_hash_update,
124 : : .rss_hash_conf_get = rtl_rss_hash_conf_get,
125 : : };
126 : :
127 : : static int
128 : 0 : rtl_dev_configure(struct rte_eth_dev *dev __rte_unused)
129 : : {
130 : 0 : return 0;
131 : : }
132 : :
133 : : static void
134 : 0 : rtl_disable_intr(struct rtl_hw *hw)
135 : : {
136 : 0 : PMD_INIT_FUNC_TRACE();
137 [ # # ]: 0 : if (rtl_is_8125(hw)) {
138 : 0 : RTL_W32(hw, IMR0_8125, 0x0000);
139 : 0 : RTL_W32(hw, ISR0_8125, RTL_R32(hw, ISR0_8125));
140 : : } else {
141 : 0 : RTL_W16(hw, IntrMask, 0x0000);
142 : 0 : RTL_W16(hw, IntrStatus, RTL_R16(hw, IntrStatus));
143 : : }
144 : 0 : }
145 : :
146 : : static void
147 : 0 : rtl_enable_intr(struct rtl_hw *hw)
148 : : {
149 : 0 : PMD_INIT_FUNC_TRACE();
150 [ # # ]: 0 : if (rtl_is_8125(hw))
151 : 0 : RTL_W32(hw, IMR0_8125, LinkChg);
152 : : else
153 : 0 : RTL_W16(hw, IntrMask, LinkChg);
154 : 0 : }
155 : :
156 : : static int
157 : 0 : _rtl_setup_link(struct rte_eth_dev *dev)
158 : : {
159 : 0 : struct rtl_adapter *adapter = RTL_DEV_PRIVATE(dev);
160 : 0 : struct rtl_hw *hw = &adapter->hw;
161 : : u64 adv = 0;
162 : : u32 *link_speeds = &dev->data->dev_conf.link_speeds;
163 : : unsigned int speed_mode;
164 : :
165 : : /* Setup link speed and duplex */
166 [ # # ]: 0 : if (*link_speeds == RTE_ETH_LINK_SPEED_AUTONEG) {
167 [ # # ]: 0 : switch (hw->chipset_name) {
168 : : case RTL8125A:
169 : : case RTL8125B:
170 : : case RTL8168KB:
171 : : case RTL8125BP:
172 : : case RTL8125D:
173 : : case RTL8125CP:
174 : : speed_mode = SPEED_2500;
175 : : break;
176 : : case RTL8126A:
177 : : speed_mode = SPEED_5000;
178 : : break;
179 : : case RTL8127:
180 : : speed_mode = SPEED_10000;
181 : : break;
182 : : default:
183 : : speed_mode = SPEED_1000;
184 : : break;
185 : : }
186 : :
187 : 0 : rtl_set_link_option(hw, AUTONEG_ENABLE, speed_mode, DUPLEX_FULL,
188 : : rtl_fc_full);
189 : : } else if (*link_speeds != 0) {
190 [ # # ]: 0 : if (*link_speeds & ~(RTE_ETH_LINK_SPEED_10M_HD | RTE_ETH_LINK_SPEED_10M |
191 : : RTE_ETH_LINK_SPEED_100M_HD | RTE_ETH_LINK_SPEED_100M |
192 : : RTE_ETH_LINK_SPEED_1G | RTE_ETH_LINK_SPEED_2_5G |
193 : : RTE_ETH_LINK_SPEED_5G | RTE_ETH_LINK_SPEED_10G |
194 : : RTE_ETH_LINK_SPEED_FIXED))
195 : 0 : goto error_invalid_config;
196 : :
197 [ # # ]: 0 : if (*link_speeds & RTE_ETH_LINK_SPEED_10M_HD) {
198 : 0 : hw->speed = SPEED_10;
199 : 0 : hw->duplex = DUPLEX_HALF;
200 : : adv |= ADVERTISE_10_HALF;
201 : : }
202 [ # # ]: 0 : if (*link_speeds & RTE_ETH_LINK_SPEED_10M) {
203 : 0 : hw->speed = SPEED_10;
204 : 0 : hw->duplex = DUPLEX_FULL;
205 : 0 : adv |= ADVERTISE_10_FULL;
206 : : }
207 [ # # ]: 0 : if (*link_speeds & RTE_ETH_LINK_SPEED_100M_HD) {
208 : 0 : hw->speed = SPEED_100;
209 : 0 : hw->duplex = DUPLEX_HALF;
210 : 0 : adv |= ADVERTISE_100_HALF;
211 : : }
212 [ # # ]: 0 : if (*link_speeds & RTE_ETH_LINK_SPEED_100M) {
213 : 0 : hw->speed = SPEED_100;
214 : 0 : hw->duplex = DUPLEX_FULL;
215 : 0 : adv |= ADVERTISE_100_FULL;
216 : : }
217 [ # # ]: 0 : if (*link_speeds & RTE_ETH_LINK_SPEED_1G) {
218 : 0 : hw->speed = SPEED_1000;
219 : 0 : hw->duplex = DUPLEX_FULL;
220 : 0 : adv |= ADVERTISE_1000_FULL;
221 : : }
222 [ # # ]: 0 : if (*link_speeds & RTE_ETH_LINK_SPEED_2_5G) {
223 : 0 : hw->speed = SPEED_2500;
224 : 0 : hw->duplex = DUPLEX_FULL;
225 : 0 : adv |= ADVERTISE_2500_FULL;
226 : : }
227 [ # # ]: 0 : if (*link_speeds & RTE_ETH_LINK_SPEED_5G) {
228 : 0 : hw->speed = SPEED_5000;
229 : 0 : hw->duplex = DUPLEX_FULL;
230 : 0 : adv |= ADVERTISE_5000_FULL;
231 : : }
232 [ # # ]: 0 : if (*link_speeds & RTE_ETH_LINK_SPEED_10G) {
233 : 0 : hw->speed = SPEED_10000;
234 : 0 : hw->duplex = DUPLEX_FULL;
235 : 0 : adv |= ADVERTISE_10000_FULL;
236 : : }
237 : :
238 : 0 : hw->autoneg = AUTONEG_ENABLE;
239 : 0 : hw->advertising = adv;
240 : : }
241 : :
242 : 0 : rtl_set_speed(hw);
243 : :
244 : 0 : return 0;
245 : :
246 : : error_invalid_config:
247 : 0 : PMD_INIT_LOG(ERR, "Invalid advertised speeds (%u) for port %u",
248 : : dev->data->dev_conf.link_speeds, dev->data->port_id);
249 : 0 : rtl_stop_queues(dev);
250 : 0 : return -EINVAL;
251 : : }
252 : :
253 : : static int
254 : : rtl_setup_link(struct rte_eth_dev *dev)
255 : : {
256 : : #ifdef RTE_EXEC_ENV_FREEBSD
257 : : struct rtl_adapter *adapter = RTL_DEV_PRIVATE(dev);
258 : : struct rtl_hw *hw = &adapter->hw;
259 : : struct rte_eth_link link;
260 : : int count;
261 : : #endif
262 : :
263 : 0 : _rtl_setup_link(dev);
264 : :
265 : : #ifdef RTE_EXEC_ENV_FREEBSD
266 : : for (count = 0; count < R8169_LINK_CHECK_TIMEOUT; count++) {
267 : : if (!(RTL_R16(hw, PHYstatus) & LinkStatus)) {
268 : : rte_delay_ms(R8169_LINK_CHECK_INTERVAL);
269 : : continue;
270 : : }
271 : :
272 : : rtl_dev_link_update(dev, 0);
273 : :
274 : : rte_eth_linkstatus_get(dev, &link);
275 : :
276 : : return 0;
277 : : }
278 : : #endif
279 : : return 0;
280 : : }
281 : :
282 : : /* Set PCI configuration space offset 0x79 to setting */
283 : : static void
284 : 0 : set_offset79(struct rte_pci_device *pdev, u8 setting)
285 : : {
286 : : u8 device_control;
287 : :
288 : 0 : PCI_READ_CONFIG_BYTE(pdev, &device_control, 0x79);
289 : 0 : device_control &= ~0x70;
290 : 0 : device_control |= setting;
291 : 0 : PCI_WRITE_CONFIG_BYTE(pdev, &device_control, 0x79);
292 : 0 : }
293 : :
294 : : /*
295 : : * Configure device link speed and setup link.
296 : : * It returns 0 on success.
297 : : */
298 : : static int
299 : 0 : rtl_dev_start(struct rte_eth_dev *dev)
300 : : {
301 : 0 : struct rtl_adapter *adapter = RTL_DEV_PRIVATE(dev);
302 : 0 : struct rtl_hw *hw = &adapter->hw;
303 : 0 : struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(dev);
304 : 0 : struct rte_intr_handle *intr_handle = pci_dev->intr_handle;
305 : : int err;
306 : :
307 : : /* Disable uio/vfio intr/eventfd mapping */
308 : 0 : rte_intr_disable(intr_handle);
309 : :
310 : 0 : rtl_powerup_pll(hw);
311 : :
312 : 0 : rtl_hw_ephy_config(hw);
313 : :
314 : 0 : rtl_hw_phy_config(hw);
315 : :
316 : 0 : rtl_hw_config(hw);
317 : :
318 [ # # ]: 0 : if (!rtl_is_8125(hw))
319 : 0 : set_offset79(pci_dev, 0x40);
320 : :
321 : : /* Initialize transmission unit */
322 : 0 : rtl_tx_init(dev);
323 : :
324 : : /* This can fail when allocating mbufs for descriptor rings */
325 : 0 : err = rtl_rx_init(dev);
326 [ # # ]: 0 : if (err) {
327 : 0 : PMD_INIT_LOG(ERR, "Unable to initialize RX hardware");
328 : 0 : goto error;
329 : : }
330 : :
331 : : /* This can fail when allocating mem for tally counters */
332 : 0 : err = rtl_tally_init(dev);
333 [ # # ]: 0 : if (err)
334 : 0 : goto error;
335 : :
336 : : /* Enable uio/vfio intr/eventfd mapping */
337 : 0 : rte_intr_enable(intr_handle);
338 : :
339 : : /* Resume enabled intr since hw reset */
340 : 0 : rtl_enable_intr(hw);
341 : :
342 : : rtl_setup_link(dev);
343 : :
344 : 0 : rtl_mdio_write(hw, 0x1F, 0x0000);
345 : :
346 : 0 : return 0;
347 : 0 : error:
348 : 0 : rtl_stop_queues(dev);
349 : 0 : return -EIO;
350 : : }
351 : :
352 : : /*
353 : : * Stop device: disable RX and TX functions to allow for reconfiguring.
354 : : */
355 : : static int
356 : 0 : rtl_dev_stop(struct rte_eth_dev *dev)
357 : : {
358 : 0 : struct rtl_adapter *adapter = RTL_DEV_PRIVATE(dev);
359 : 0 : struct rtl_hw *hw = &adapter->hw;
360 : : struct rte_eth_link link;
361 : :
362 : 0 : rtl_disable_intr(hw);
363 : :
364 : 0 : rtl_nic_reset(hw);
365 : :
366 [ # # ]: 0 : if (rtl_is_8125(hw))
367 : 0 : rtl_mac_ocp_write(hw, 0xE00A, hw->mcu_pme_setting);
368 : :
369 : 0 : rtl_powerdown_pll(hw);
370 : :
371 : 0 : rtl_stop_queues(dev);
372 : :
373 : 0 : rtl_tally_free(dev);
374 : :
375 : : /* Clear the recorded link status */
376 : : memset(&link, 0, sizeof(link));
377 : 0 : rte_eth_linkstatus_set(dev, &link);
378 : :
379 : 0 : return 0;
380 : : }
381 : :
382 : : static int
383 : 0 : rtl_dev_set_link_up(struct rte_eth_dev *dev)
384 : : {
385 : 0 : struct rtl_adapter *adapter = RTL_DEV_PRIVATE(dev);
386 : 0 : struct rtl_hw *hw = &adapter->hw;
387 : :
388 : 0 : rtl_powerup_pll(hw);
389 : :
390 : 0 : return 0;
391 : : }
392 : :
393 : : static int
394 : 0 : rtl_dev_set_link_down(struct rte_eth_dev *dev)
395 : : {
396 : 0 : struct rtl_adapter *adapter = RTL_DEV_PRIVATE(dev);
397 : 0 : struct rtl_hw *hw = &adapter->hw;
398 : :
399 : : /* mcu pme intr masks */
400 [ # # ]: 0 : if (rtl_is_8125(hw))
401 : 0 : rtl_mac_ocp_write(hw, 0xE00A, hw->mcu_pme_setting & ~(BIT_11 | BIT_14));
402 : :
403 : 0 : rtl_powerdown_pll(hw);
404 : :
405 : 0 : return 0;
406 : : }
407 : :
408 : : static int
409 : 0 : rtl_dev_infos_get(struct rte_eth_dev *dev, struct rte_eth_dev_info *dev_info)
410 : : {
411 : 0 : struct rtl_adapter *adapter = RTL_DEV_PRIVATE(dev);
412 : 0 : struct rtl_hw *hw = &adapter->hw;
413 : :
414 : 0 : dev_info->min_rx_bufsize = 1024;
415 : 0 : dev_info->max_rx_pktlen = JUMBO_FRAME_9K;
416 : 0 : dev_info->max_mac_addrs = 1;
417 : :
418 [ # # ]: 0 : if (hw->mcfg >= CFG_METHOD_69) {
419 : 0 : dev_info->max_rx_queues = 4;
420 : 0 : dev_info->max_tx_queues = 2;
421 : : } else {
422 : 0 : dev_info->max_rx_queues = 1;
423 : 0 : dev_info->max_tx_queues = 1;
424 : : }
425 : :
426 : 0 : dev_info->default_rxconf = (struct rte_eth_rxconf) {
427 : : .rx_free_thresh = RTL_RX_FREE_THRESH,
428 : : };
429 : :
430 : 0 : dev_info->default_txconf = (struct rte_eth_txconf) {
431 : : .tx_free_thresh = RTL_TX_FREE_THRESH,
432 : : };
433 : :
434 : 0 : dev_info->rx_desc_lim = rx_desc_lim;
435 : 0 : dev_info->tx_desc_lim = tx_desc_lim;
436 : :
437 : 0 : dev_info->speed_capa = RTE_ETH_LINK_SPEED_10M_HD | RTE_ETH_LINK_SPEED_10M |
438 : : RTE_ETH_LINK_SPEED_100M_HD | RTE_ETH_LINK_SPEED_100M |
439 : : RTE_ETH_LINK_SPEED_1G;
440 : :
441 [ # # # # ]: 0 : switch (hw->chipset_name) {
442 : 0 : case RTL8127:
443 : 0 : dev_info->speed_capa |= RTE_ETH_LINK_SPEED_10G;
444 : : /* fallthrough */
445 : 0 : case RTL8126A:
446 : 0 : dev_info->speed_capa |= RTE_ETH_LINK_SPEED_5G;
447 : : /* fallthrough */
448 : 0 : case RTL8125A:
449 : : case RTL8125B:
450 : : case RTL8125BP:
451 : : case RTL8125D:
452 : : case RTL8125CP:
453 : 0 : dev_info->speed_capa |= RTE_ETH_LINK_SPEED_2_5G;
454 : 0 : break;
455 : : }
456 : :
457 : 0 : dev_info->min_mtu = RTE_ETHER_MIN_MTU;
458 : 0 : dev_info->max_mtu = dev_info->max_rx_pktlen - RTL_ETH_OVERHEAD;
459 : :
460 : 0 : dev_info->rx_offload_capa = (rtl_get_rx_port_offloads(hw) |
461 : 0 : dev_info->rx_queue_offload_capa);
462 : 0 : dev_info->tx_offload_capa = rtl_get_tx_port_offloads();
463 : :
464 : 0 : dev_info->hash_key_size = RTL_RSS_KEY_SIZE;
465 : 0 : dev_info->reta_size = RTL_MAX_INDIRECTION_TABLE_ENTRIES;
466 : 0 : dev_info->flow_type_rss_offloads = RTL_RSS_CTRL_OFFLOAD_ALL;
467 : :
468 : 0 : return 0;
469 : : }
470 : :
471 : : static int
472 : 0 : rtl_promiscuous_enable(struct rte_eth_dev *dev)
473 : : {
474 : 0 : struct rtl_adapter *adapter = RTL_DEV_PRIVATE(dev);
475 : : struct rtl_hw *hw = &adapter->hw;
476 : :
477 : : int rx_mode = AcceptBroadcast | AcceptMulticast | AcceptMyPhys | AcceptAllPhys;
478 : :
479 : 0 : RTL_W32(hw, RxConfig, rx_mode | (RTL_R32(hw, RxConfig)));
480 : : rtl_allmulticast_enable(dev);
481 : :
482 : 0 : return 0;
483 : : }
484 : :
485 : : static int
486 : 0 : rtl_promiscuous_disable(struct rte_eth_dev *dev)
487 : : {
488 : 0 : struct rtl_adapter *adapter = RTL_DEV_PRIVATE(dev);
489 : : struct rtl_hw *hw = &adapter->hw;
490 : : int rx_mode = ~AcceptAllPhys;
491 : :
492 : 0 : RTL_W32(hw, RxConfig, rx_mode & (RTL_R32(hw, RxConfig)));
493 : :
494 [ # # ]: 0 : if (dev->data->all_multicast == 1)
495 : : rtl_allmulticast_enable(dev);
496 : : else
497 : : rtl_allmulticast_disable(dev);
498 : :
499 : 0 : return 0;
500 : : }
501 : :
502 : : static int
503 : 0 : rtl_allmulticast_enable(struct rte_eth_dev *dev)
504 : : {
505 : 0 : struct rtl_adapter *adapter = RTL_DEV_PRIVATE(dev);
506 : : struct rtl_hw *hw = &adapter->hw;
507 : :
508 : 0 : RTL_W32(hw, MAR0 + 0, 0xffffffff);
509 : 0 : RTL_W32(hw, MAR0 + 4, 0xffffffff);
510 : :
511 : 0 : return 0;
512 : : }
513 : :
514 : : static int
515 : 0 : rtl_allmulticast_disable(struct rte_eth_dev *dev)
516 : : {
517 : 0 : struct rtl_adapter *adapter = RTL_DEV_PRIVATE(dev);
518 : : struct rtl_hw *hw = &adapter->hw;
519 : :
520 [ # # # # ]: 0 : if (dev->data->promiscuous == 1)
521 : : return 0; /* Must remain in all_multicast mode */
522 : :
523 : 0 : RTL_W32(hw, MAR0 + 0, 0);
524 : 0 : RTL_W32(hw, MAR0 + 4, 0);
525 : :
526 : 0 : return 0;
527 : : }
528 : :
529 : : static int
530 : 0 : rtl_dev_stats_reset(struct rte_eth_dev *dev)
531 : : {
532 : 0 : struct rtl_adapter *adapter = RTL_DEV_PRIVATE(dev);
533 : 0 : struct rtl_hw *hw = &adapter->hw;
534 : :
535 : 0 : rtl_clear_tally_stats(hw);
536 : :
537 : 0 : memset(&adapter->sw_stats, 0, sizeof(adapter->sw_stats));
538 : :
539 : 0 : return 0;
540 : : }
541 : :
542 : : static void
543 : : rtl_sw_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *rte_stats)
544 : : {
545 : 0 : struct rtl_adapter *adapter = RTL_DEV_PRIVATE(dev);
546 : : struct rtl_sw_stats *sw_stats = &adapter->sw_stats;
547 : :
548 : 0 : rte_stats->ibytes = sw_stats->rx_bytes;
549 : 0 : rte_stats->obytes = sw_stats->tx_bytes;
550 : : }
551 : :
552 : : static int
553 : 0 : rtl_dev_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *rte_stats,
554 : : struct eth_queue_stats *qstats __rte_unused)
555 : : {
556 : 0 : struct rtl_adapter *adapter = RTL_DEV_PRIVATE(dev);
557 : 0 : struct rtl_hw *hw = &adapter->hw;
558 : :
559 : 0 : rtl_get_tally_stats(hw, rte_stats);
560 : : rtl_sw_stats_get(dev, rte_stats);
561 : :
562 : 0 : return 0;
563 : : }
564 : :
565 : : /* Return 0 means link status changed, -1 means not changed */
566 : : static int
567 : 0 : rtl_dev_link_update(struct rte_eth_dev *dev, int wait __rte_unused)
568 : : {
569 : : struct rte_eth_link link, old;
570 : 0 : struct rtl_adapter *adapter = RTL_DEV_PRIVATE(dev);
571 : 0 : struct rtl_hw *hw = &adapter->hw;
572 : : u32 speed;
573 : : u16 status;
574 : :
575 : 0 : link.link_status = RTE_ETH_LINK_DOWN;
576 : 0 : link.link_speed = 0;
577 : 0 : link.link_duplex = RTE_ETH_LINK_FULL_DUPLEX;
578 : 0 : link.link_autoneg = RTE_ETH_LINK_AUTONEG;
579 : :
580 : : memset(&old, 0, sizeof(old));
581 : :
582 : : /* Load old link status */
583 : 0 : rte_eth_linkstatus_get(dev, &old);
584 : :
585 : : /* Read current link status */
586 : 0 : status = RTL_R16(hw, PHYstatus);
587 : :
588 [ # # ]: 0 : if (status & LinkStatus) {
589 : 0 : link.link_status = RTE_ETH_LINK_UP;
590 : :
591 [ # # ]: 0 : if (status & FullDup) {
592 : 0 : link.link_duplex = RTE_ETH_LINK_FULL_DUPLEX;
593 [ # # # # ]: 0 : if (!rtl_is_8125(hw) || hw->mcfg == CFG_METHOD_48)
594 : 0 : RTL_W32(hw, TxConfig, (RTL_R32(hw, TxConfig) |
595 : : (BIT_24 | BIT_25)) & ~BIT_19);
596 : : } else {
597 : 0 : link.link_duplex = RTE_ETH_LINK_HALF_DUPLEX;
598 [ # # # # ]: 0 : if (!rtl_is_8125(hw) || hw->mcfg == CFG_METHOD_48)
599 : 0 : RTL_W32(hw, TxConfig, (RTL_R32(hw, TxConfig) | BIT_25) &
600 : : ~(BIT_19 | BIT_24));
601 : : }
602 : :
603 : : /*
604 : : * The PHYstatus register for the RTL8168 is 8 bits,
605 : : * while for the RTL8125, RTL8126 and RTL8127, it is 16 bits.
606 : : */
607 [ # # # # ]: 0 : if (status & _10000bpsF && rtl_is_8125(hw))
608 : : speed = 10000;
609 [ # # # # ]: 0 : else if (status & _5000bpsF && rtl_is_8125(hw))
610 : : speed = 5000;
611 [ # # # # ]: 0 : else if (status & _2500bpsF && rtl_is_8125(hw))
612 : : speed = 2500;
613 [ # # ]: 0 : else if (status & _1000bpsF)
614 : : speed = 1000;
615 [ # # ]: 0 : else if (status & _100bps)
616 : : speed = 100;
617 : : else
618 : : speed = 10;
619 : :
620 : 0 : link.link_speed = speed;
621 : : }
622 : :
623 [ # # ]: 0 : if (link.link_status == old.link_status)
624 : : return -1;
625 : :
626 : 0 : rte_eth_linkstatus_set(dev, &link);
627 : :
628 : 0 : return 0;
629 : : }
630 : :
631 : : static void
632 : 0 : rtl_dev_interrupt_handler(void *param)
633 : : {
634 : : struct rte_eth_dev *dev = (struct rte_eth_dev *)param;
635 : 0 : struct rtl_adapter *adapter = RTL_DEV_PRIVATE(dev);
636 : 0 : struct rtl_hw *hw = &adapter->hw;
637 : : uint32_t intr;
638 : :
639 [ # # ]: 0 : if (rtl_is_8125(hw))
640 : 0 : intr = RTL_R32(hw, ISR0_8125);
641 : : else
642 : 0 : intr = RTL_R16(hw, IntrStatus);
643 : :
644 : : /* Clear all cause mask */
645 : 0 : rtl_disable_intr(hw);
646 : :
647 [ # # ]: 0 : if (intr & LinkChg)
648 : 0 : rtl_dev_link_update(dev, 0);
649 : : else
650 : 0 : PMD_DRV_LOG(ERR, "r8169: interrupt unhandled.");
651 : :
652 : 0 : rtl_enable_intr(hw);
653 : 0 : }
654 : :
655 : : /*
656 : : * Reset and stop device.
657 : : */
658 : : static int
659 : 0 : rtl_dev_close(struct rte_eth_dev *dev)
660 : : {
661 : 0 : struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(dev);
662 : 0 : struct rte_intr_handle *intr_handle = pci_dev->intr_handle;
663 : 0 : struct rtl_adapter *adapter = RTL_DEV_PRIVATE(dev);
664 : 0 : struct rtl_hw *hw = &adapter->hw;
665 : : int retries = 0;
666 : : int ret_unreg, ret_stp;
667 : :
668 [ # # ]: 0 : if (rte_eal_process_type() != RTE_PROC_PRIMARY)
669 : : return 0;
670 : :
671 [ # # ]: 0 : if (HW_DASH_SUPPORT_DASH(hw))
672 : 0 : rtl_driver_stop(hw);
673 : :
674 : 0 : ret_stp = rtl_dev_stop(dev);
675 : :
676 : 0 : rtl_free_queues(dev);
677 : :
678 : : /* Reprogram the RAR[0] in case user changed it. */
679 : 0 : rtl_rar_set(hw, hw->mac_addr);
680 : :
681 : : /* Disable uio intr before callback unregister */
682 : 0 : rte_intr_disable(intr_handle);
683 : :
684 : : do {
685 : 0 : ret_unreg = rte_intr_callback_unregister(intr_handle, rtl_dev_interrupt_handler,
686 : : dev);
687 [ # # ]: 0 : if (ret_unreg >= 0 || ret_unreg == -ENOENT)
688 : : break;
689 [ # # ]: 0 : else if (ret_unreg != -EAGAIN)
690 : 0 : PMD_DRV_LOG(ERR, "r8169: intr callback unregister failed: %d", ret_unreg);
691 : :
692 : : rte_delay_ms(100);
693 [ # # ]: 0 : } while (retries++ < (10 + 90));
694 : :
695 : : return ret_stp;
696 : : }
697 : :
698 : : static int
699 : 0 : rtl_dev_mtu_set(struct rte_eth_dev *dev, uint16_t mtu)
700 : : {
701 : 0 : struct rtl_adapter *adapter = RTL_DEV_PRIVATE(dev);
702 : : struct rtl_hw *hw = &adapter->hw;
703 : : uint32_t frame_size = mtu + RTL_ETH_OVERHEAD;
704 : :
705 : 0 : hw->mtu = mtu;
706 : :
707 : 0 : RTL_W16(hw, RxMaxSize, frame_size);
708 : :
709 : 0 : return 0;
710 : : }
711 : :
712 : : static int
713 : 0 : rtl_fw_version_get(struct rte_eth_dev *dev, char *fw_version, size_t fw_size)
714 : : {
715 : 0 : struct rtl_adapter *adapter = RTL_DEV_PRIVATE(dev);
716 : : struct rtl_hw *hw = &adapter->hw;
717 : : int ret;
718 : :
719 [ # # ]: 0 : ret = snprintf(fw_version, fw_size, "0x%08x", hw->hw_ram_code_ver);
720 : :
721 : 0 : ret += 1; /* Add the size of '\0' */
722 [ # # ]: 0 : if (fw_size < (u32)ret)
723 : : return ret;
724 : : else
725 : 0 : return 0;
726 : : }
727 : :
728 : : static int
729 : 0 : rtl_reta_update(struct rte_eth_dev *dev,
730 : : struct rte_eth_rss_reta_entry64 *reta_conf, uint16_t reta_size)
731 : : {
732 : 0 : struct rtl_adapter *adapter = RTL_DEV_PRIVATE(dev);
733 : : struct rtl_hw *hw = &adapter->hw;
734 : : u32 reta;
735 : : u16 idx, shift;
736 : : u8 mask, rss_indir_tbl;
737 : : int i, j;
738 : :
739 [ # # ]: 0 : if (reta_size != RTL_MAX_INDIRECTION_TABLE_ENTRIES) {
740 : 0 : PMD_DRV_LOG(ERR, "The size of hash lookup table configured "
741 : : "(%d) doesn't match the number hardware can supported "
742 : : "(%d)", reta_size, RTL_MAX_INDIRECTION_TABLE_ENTRIES);
743 : 0 : return -EINVAL;
744 : : }
745 : :
746 [ # # ]: 0 : for (i = 0; i < reta_size; i += 4) {
747 : 0 : idx = i / RTE_ETH_RETA_GROUP_SIZE;
748 : 0 : shift = i % RTE_ETH_RETA_GROUP_SIZE;
749 : 0 : mask = (reta_conf[idx].mask >> shift) & 0xf;
750 : :
751 [ # # ]: 0 : if (!mask)
752 : 0 : continue;
753 : :
754 [ # # ]: 0 : for (j = 0, reta = 0; j < 4; j++) {
755 : 0 : rss_indir_tbl = (u8)reta_conf[idx].reta[shift + j];
756 : 0 : reta |= rss_indir_tbl << (j * 8);
757 : :
758 [ # # ]: 0 : if (!(mask & (1 << j)))
759 : 0 : continue;
760 : :
761 : 0 : hw->rss_indir_tbl[i + j] = rss_indir_tbl;
762 : : }
763 : :
764 : 0 : RTL_W32(hw, RSS_INDIRECTION_TBL_8125_V2 + i, reta);
765 : : }
766 : :
767 : : return 0;
768 : : }
769 : :
770 : : static int
771 : 0 : rtl_reta_query(struct rte_eth_dev *dev,
772 : : struct rte_eth_rss_reta_entry64 *reta_conf, uint16_t reta_size)
773 : : {
774 : 0 : struct rtl_adapter *adapter = RTL_DEV_PRIVATE(dev);
775 : : struct rtl_hw *hw = &adapter->hw;
776 : : u16 idx, shift;
777 : : int i;
778 : :
779 [ # # ]: 0 : if (reta_size != RTL_MAX_INDIRECTION_TABLE_ENTRIES) {
780 : 0 : PMD_DRV_LOG(ERR, "The size of hash lookup table configured "
781 : : "(%d) doesn't match the number hardware can supported "
782 : : "(%d)", reta_size, RTL_MAX_INDIRECTION_TABLE_ENTRIES);
783 : 0 : return -EINVAL;
784 : : }
785 : :
786 [ # # ]: 0 : for (i = 0; i < reta_size; i++) {
787 : 0 : idx = i / RTE_ETH_RETA_GROUP_SIZE;
788 : 0 : shift = i % RTE_ETH_RETA_GROUP_SIZE;
789 : :
790 [ # # ]: 0 : if (reta_conf[idx].mask & (1ULL << shift))
791 : 0 : reta_conf[idx].reta[shift] = hw->rss_indir_tbl[i];
792 : : }
793 : :
794 : : return 0;
795 : : }
796 : :
797 : : static int
798 : 0 : rtl_rss_hash_update(struct rte_eth_dev *dev, struct rte_eth_rss_conf *rss_conf)
799 : : {
800 : 0 : struct rtl_adapter *adapter = RTL_DEV_PRIVATE(dev);
801 : 0 : struct rtl_hw *hw = &adapter->hw;
802 : : u32 rss_ctrl_8125;
803 : :
804 [ # # # # ]: 0 : if (!hw->EnableRss || !(rss_conf->rss_hf & RTL_RSS_OFFLOAD_ALL))
805 : : return -EINVAL;
806 : :
807 [ # # ]: 0 : if (rss_conf->rss_key)
808 : 0 : memcpy(hw->rss_key, rss_conf->rss_key, RTL_RSS_KEY_SIZE);
809 : :
810 : 0 : rtl8125_store_rss_key(hw);
811 : :
812 : 0 : rss_ctrl_8125 = RTL_R32(hw, RSS_CTRL_8125) & ~RTL_RSS_CTRL_OFFLOAD_ALL;
813 : :
814 [ # # ]: 0 : if (rss_conf->rss_hf & RTE_ETH_RSS_IPV4)
815 : 0 : rss_ctrl_8125 |= RSS_CTRL_IPV4_SUPP;
816 [ # # ]: 0 : if (rss_conf->rss_hf & RTE_ETH_RSS_NONFRAG_IPV4_TCP)
817 : 0 : rss_ctrl_8125 |= RSS_CTRL_TCP_IPV4_SUPP;
818 [ # # ]: 0 : if (rss_conf->rss_hf & RTE_ETH_RSS_NONFRAG_IPV6_TCP)
819 : 0 : rss_ctrl_8125 |= RSS_CTRL_TCP_IPV6_SUPP;
820 [ # # ]: 0 : if (rss_conf->rss_hf & RTE_ETH_RSS_IPV6)
821 : 0 : rss_ctrl_8125 |= RSS_CTRL_IPV6_SUPP;
822 [ # # ]: 0 : if (rss_conf->rss_hf & RTE_ETH_RSS_IPV6_EX)
823 : 0 : rss_ctrl_8125 |= RSS_CTRL_IPV6_EXT_SUPP;
824 [ # # ]: 0 : if (rss_conf->rss_hf & RTE_ETH_RSS_IPV6_TCP_EX)
825 : 0 : rss_ctrl_8125 |= RSS_CTRL_TCP_IPV6_EXT_SUPP;
826 [ # # ]: 0 : if (rss_conf->rss_hf & RTE_ETH_RSS_NONFRAG_IPV4_UDP)
827 : 0 : rss_ctrl_8125 |= RSS_CTRL_UDP_IPV4_SUPP;
828 [ # # ]: 0 : if (rss_conf->rss_hf & RTE_ETH_RSS_NONFRAG_IPV6_UDP)
829 : 0 : rss_ctrl_8125 |= RSS_CTRL_UDP_IPV6_SUPP;
830 [ # # ]: 0 : if (rss_conf->rss_hf & RTE_ETH_RSS_IPV6_UDP_EX)
831 : 0 : rss_ctrl_8125 |= RSS_CTRL_UDP_IPV6_EXT_SUPP;
832 : :
833 : 0 : RTL_W32(hw, RSS_CTRL_8125, rss_ctrl_8125);
834 : :
835 : 0 : return 0;
836 : : }
837 : :
838 : : static int
839 : 0 : rtl_rss_hash_conf_get(struct rte_eth_dev *dev, struct rte_eth_rss_conf *rss_conf)
840 : : {
841 : 0 : struct rtl_adapter *adapter = RTL_DEV_PRIVATE(dev);
842 : : struct rtl_hw *hw = &adapter->hw;
843 : : u64 rss_hf = 0;
844 : : u32 rss_ctrl_8125;
845 : :
846 [ # # ]: 0 : if (!hw->EnableRss) {
847 : 0 : rss_conf->rss_hf = rss_hf;
848 : 0 : return 0;
849 : : }
850 : :
851 [ # # ]: 0 : if (rss_conf->rss_key) {
852 : 0 : rss_conf->rss_key_len = RTL_RSS_KEY_SIZE;
853 : 0 : memcpy(rss_conf->rss_key, hw->rss_key, RTL_RSS_KEY_SIZE);
854 : : }
855 : :
856 : 0 : rss_ctrl_8125 = RTL_R32(hw, RSS_CTRL_8125);
857 : :
858 [ # # ]: 0 : if (rss_ctrl_8125 & RSS_CTRL_IPV4_SUPP)
859 : : rss_hf |= RTE_ETH_RSS_IPV4;
860 [ # # ]: 0 : if (rss_ctrl_8125 & RSS_CTRL_TCP_IPV4_SUPP)
861 : 0 : rss_hf |= RTE_ETH_RSS_NONFRAG_IPV4_TCP;
862 [ # # ]: 0 : if (rss_ctrl_8125 & RSS_CTRL_TCP_IPV6_SUPP)
863 : 0 : rss_hf |= RTE_ETH_RSS_NONFRAG_IPV6_TCP;
864 [ # # ]: 0 : if (rss_ctrl_8125 & RSS_CTRL_IPV6_SUPP)
865 : 0 : rss_hf |= RTE_ETH_RSS_IPV6;
866 [ # # ]: 0 : if (rss_ctrl_8125 & RSS_CTRL_IPV6_EXT_SUPP)
867 : 0 : rss_hf |= RTE_ETH_RSS_IPV6_EX;
868 [ # # ]: 0 : if (rss_ctrl_8125 & RSS_CTRL_TCP_IPV6_EXT_SUPP)
869 : 0 : rss_hf |= RTE_ETH_RSS_IPV6_TCP_EX;
870 [ # # ]: 0 : if (rss_ctrl_8125 & RSS_CTRL_UDP_IPV4_SUPP)
871 : 0 : rss_hf |= RTE_ETH_RSS_NONFRAG_IPV4_UDP;
872 [ # # ]: 0 : if (rss_ctrl_8125 & RSS_CTRL_UDP_IPV6_SUPP)
873 : 0 : rss_hf |= RTE_ETH_RSS_NONFRAG_IPV6_UDP;
874 [ # # ]: 0 : if (rss_ctrl_8125 & RSS_CTRL_UDP_IPV6_EXT_SUPP)
875 : 0 : rss_hf |= RTE_ETH_RSS_IPV6_UDP_EX;
876 : :
877 : 0 : rss_conf->rss_hf = rss_hf;
878 : :
879 : 0 : return 0;
880 : : }
881 : :
882 : : static int
883 : 0 : rtl_dev_init(struct rte_eth_dev *dev)
884 : : {
885 : 0 : struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(dev);
886 : 0 : struct rte_intr_handle *intr_handle = pci_dev->intr_handle;
887 : 0 : struct rtl_adapter *adapter = RTL_DEV_PRIVATE(dev);
888 : 0 : struct rtl_hw *hw = &adapter->hw;
889 : 0 : struct rte_ether_addr *perm_addr = (struct rte_ether_addr *)hw->mac_addr;
890 : : char buf[RTE_ETHER_ADDR_FMT_SIZE];
891 : :
892 : 0 : dev->dev_ops = &rtl_eth_dev_ops;
893 : 0 : dev->tx_pkt_burst = &rtl_xmit_pkts;
894 : 0 : dev->rx_pkt_burst = &rtl_recv_pkts;
895 : :
896 : : /* For secondary processes, the primary process has done all the work. */
897 [ # # ]: 0 : if (rte_eal_process_type() != RTE_PROC_PRIMARY) {
898 [ # # ]: 0 : if (dev->data->scattered_rx)
899 : 0 : dev->rx_pkt_burst = &rtl_recv_scattered_pkts;
900 : 0 : return 0;
901 : : }
902 : :
903 : : /* R8169 uses BAR2 */
904 : 0 : hw->mmio_addr = (u8 *)pci_dev->mem_resource[2].addr;
905 : :
906 : 0 : rtl_get_mac_version(hw, pci_dev);
907 : :
908 [ # # ]: 0 : if (rtl_set_hw_ops(hw))
909 : : return -ENOTSUP;
910 : :
911 : 0 : rtl_disable_intr(hw);
912 : :
913 : 0 : rtl_hw_initialize(hw);
914 : :
915 : : /* Read the permanent MAC address out of ROM */
916 : 0 : rtl_get_mac_address(hw, perm_addr);
917 : :
918 : : if (!rte_is_valid_assigned_ether_addr(perm_addr)) {
919 : 0 : rte_eth_random_addr(&perm_addr->addr_bytes[0]);
920 : :
921 : 0 : rte_ether_format_addr(buf, sizeof(buf), perm_addr);
922 : :
923 : 0 : PMD_INIT_LOG(NOTICE, "r8169: Assign randomly generated MAC address %s", buf);
924 : : }
925 : :
926 : : /* Allocate memory for storing MAC addresses */
927 : 0 : dev->data->mac_addrs = rte_zmalloc("r8169", RTE_ETHER_ADDR_LEN, 0);
928 : :
929 [ # # ]: 0 : if (dev->data->mac_addrs == NULL) {
930 : 0 : PMD_INIT_LOG(ERR, "MAC Malloc failed");
931 : 0 : return -ENOMEM;
932 : : }
933 : :
934 : : /* Copy the permanent MAC address */
935 : : rte_ether_addr_copy(perm_addr, &dev->data->mac_addrs[0]);
936 : :
937 : 0 : rtl_rar_set(hw, &perm_addr->addr_bytes[0]);
938 : :
939 : 0 : rte_intr_callback_register(intr_handle, rtl_dev_interrupt_handler, dev);
940 : :
941 : : /* Enable uio/vfio intr/eventfd mapping */
942 : 0 : rte_intr_enable(intr_handle);
943 : :
944 : 0 : return 0;
945 : : }
946 : :
947 : : static int
948 : 0 : rtl_dev_uninit(struct rte_eth_dev *dev)
949 : : {
950 [ # # # # ]: 0 : if (rte_eal_process_type() != RTE_PROC_PRIMARY)
951 : : return -EPERM;
952 : :
953 : 0 : rtl_dev_close(dev);
954 : :
955 : 0 : return 0;
956 : : }
957 : :
958 : : static int
959 : 0 : rtl_dev_reset(struct rte_eth_dev *dev)
960 : : {
961 : : int ret;
962 : :
963 : : ret = rtl_dev_uninit(dev);
964 : : if (ret)
965 : : return ret;
966 : :
967 : 0 : ret = rtl_dev_init(dev);
968 : :
969 : 0 : return ret;
970 : : }
971 : :
972 : : static int
973 : 0 : rtl_pci_probe(struct rte_pci_driver *pci_drv __rte_unused,
974 : : struct rte_pci_device *pci_dev)
975 : : {
976 : 0 : return rte_eth_dev_pci_generic_probe(pci_dev, sizeof(struct rtl_adapter),
977 : : rtl_dev_init);
978 : : }
979 : :
980 : : static int
981 : 0 : rtl_pci_remove(struct rte_pci_device *pci_dev)
982 : : {
983 : 0 : return rte_eth_dev_pci_generic_remove(pci_dev, rtl_dev_uninit);
984 : : }
985 : :
986 : : static struct rte_pci_driver rte_r8169_pmd = {
987 : : .id_table = pci_id_r8169_map,
988 : : .drv_flags = RTE_PCI_DRV_NEED_MAPPING | RTE_PCI_DRV_INTR_LSC,
989 : : .probe = rtl_pci_probe,
990 : : .remove = rtl_pci_remove,
991 : : };
992 : :
993 : 254 : RTE_PMD_REGISTER_PCI(net_r8169, rte_r8169_pmd);
994 : : RTE_PMD_REGISTER_PCI_TABLE(net_r8169, pci_id_r8169_map);
995 : : RTE_PMD_REGISTER_KMOD_DEP(net_r8169, "* igb_uio | uio_pci_generic | vfio-pci");
996 : :
997 [ - + ]: 254 : RTE_LOG_REGISTER_SUFFIX(r8169_logtype_init, init, NOTICE)
998 [ - + ]: 254 : RTE_LOG_REGISTER_SUFFIX(r8169_logtype_driver, driver, NOTICE)
999 : : #ifdef RTE_ETHDEV_DEBUG_RX
1000 : : RTE_LOG_REGISTER_SUFFIX(r8169_logtype_rx, rx, DEBUG)
1001 : : #endif
1002 : : #ifdef RTE_ETHDEV_DEBUG_TX
1003 : : RTE_LOG_REGISTER_SUFFIX(r8169_logtype_tx, tx, DEBUG)
1004 : : #endif
|
