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