1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /**************************************************************************** |
3 | * Driver for Solarflare network controllers and boards |
4 | * Copyright 2018 Solarflare Communications Inc. |
5 | * Copyright 2019-2020 Xilinx Inc. |
6 | * |
7 | * This program is free software; you can redistribute it and/or modify it |
8 | * under the terms of the GNU General Public License version 2 as published |
9 | * by the Free Software Foundation, incorporated herein by reference. |
10 | */ |
11 | #include "net_driver.h" |
12 | #include "mcdi_port_common.h" |
13 | #include "mcdi_functions.h" |
14 | #include "efx_common.h" |
15 | #include "efx_channels.h" |
16 | #include "tx_common.h" |
17 | #include "ef100_netdev.h" |
18 | #include "ef100_ethtool.h" |
19 | #include "nic_common.h" |
20 | #include "ef100_nic.h" |
21 | #include "ef100_tx.h" |
22 | #include "ef100_regs.h" |
23 | #include "mcdi_filters.h" |
24 | #include "rx_common.h" |
25 | #include "ef100_sriov.h" |
26 | #include "tc_bindings.h" |
27 | #include "tc_encap_actions.h" |
28 | #include "efx_devlink.h" |
29 | |
30 | static void ef100_update_name(struct efx_nic *efx) |
31 | { |
32 | strcpy(p: efx->name, q: efx->net_dev->name); |
33 | } |
34 | |
35 | static int ef100_alloc_vis(struct efx_nic *efx, unsigned int *allocated_vis) |
36 | { |
37 | /* EF100 uses a single TXQ per channel, as all checksum offloading |
38 | * is configured in the TX descriptor, and there is no TX Pacer for |
39 | * HIGHPRI queues. |
40 | */ |
41 | unsigned int tx_vis = efx->n_tx_channels + efx->n_extra_tx_channels; |
42 | unsigned int rx_vis = efx->n_rx_channels; |
43 | unsigned int min_vis, max_vis; |
44 | int rc; |
45 | |
46 | EFX_WARN_ON_PARANOID(efx->tx_queues_per_channel != 1); |
47 | |
48 | tx_vis += efx->n_xdp_channels * efx->xdp_tx_per_channel; |
49 | |
50 | max_vis = max(rx_vis, tx_vis); |
51 | /* We require at least a single complete TX channel worth of queues. */ |
52 | min_vis = efx->tx_queues_per_channel; |
53 | |
54 | rc = efx_mcdi_alloc_vis(efx, min_vis, max_vis, |
55 | NULL, allocated_vis); |
56 | |
57 | /* We retry allocating VIs by reallocating channels when we have not |
58 | * been able to allocate the maximum VIs. |
59 | */ |
60 | if (!rc && *allocated_vis < max_vis) |
61 | rc = -EAGAIN; |
62 | |
63 | return rc; |
64 | } |
65 | |
66 | static int ef100_remap_bar(struct efx_nic *efx, int max_vis) |
67 | { |
68 | unsigned int uc_mem_map_size; |
69 | void __iomem *membase; |
70 | |
71 | efx->max_vis = max_vis; |
72 | uc_mem_map_size = PAGE_ALIGN(max_vis * efx->vi_stride); |
73 | |
74 | /* Extend the original UC mapping of the memory BAR */ |
75 | membase = ioremap(offset: efx->membase_phys, size: uc_mem_map_size); |
76 | if (!membase) { |
77 | netif_err(efx, probe, efx->net_dev, |
78 | "could not extend memory BAR to %x\n" , |
79 | uc_mem_map_size); |
80 | return -ENOMEM; |
81 | } |
82 | iounmap(addr: efx->membase); |
83 | efx->membase = membase; |
84 | return 0; |
85 | } |
86 | |
87 | /* Context: process, rtnl_lock() held. |
88 | * Note that the kernel will ignore our return code; this method |
89 | * should really be a void. |
90 | */ |
91 | static int ef100_net_stop(struct net_device *net_dev) |
92 | { |
93 | struct efx_nic *efx = efx_netdev_priv(dev: net_dev); |
94 | |
95 | netif_dbg(efx, ifdown, efx->net_dev, "closing on CPU %d\n" , |
96 | raw_smp_processor_id()); |
97 | |
98 | efx_detach_reps(efx); |
99 | netif_stop_queue(dev: net_dev); |
100 | efx_stop_all(efx); |
101 | efx_mcdi_mac_fini_stats(efx); |
102 | efx_disable_interrupts(efx); |
103 | efx_clear_interrupt_affinity(efx); |
104 | efx_nic_fini_interrupt(efx); |
105 | efx_remove_filters(efx); |
106 | efx_fini_napi(efx); |
107 | efx_remove_channels(efx); |
108 | efx_mcdi_free_vis(efx); |
109 | efx_remove_interrupts(efx); |
110 | |
111 | efx->state = STATE_NET_DOWN; |
112 | |
113 | return 0; |
114 | } |
115 | |
116 | /* Context: process, rtnl_lock() held. */ |
117 | static int ef100_net_open(struct net_device *net_dev) |
118 | { |
119 | struct efx_nic *efx = efx_netdev_priv(dev: net_dev); |
120 | unsigned int allocated_vis; |
121 | int rc; |
122 | |
123 | ef100_update_name(efx); |
124 | netif_dbg(efx, ifup, net_dev, "opening device on CPU %d\n" , |
125 | raw_smp_processor_id()); |
126 | |
127 | rc = efx_check_disabled(efx); |
128 | if (rc) |
129 | goto fail; |
130 | |
131 | rc = efx_probe_interrupts(efx); |
132 | if (rc) |
133 | goto fail; |
134 | |
135 | rc = efx_set_channels(efx); |
136 | if (rc) |
137 | goto fail; |
138 | |
139 | rc = efx_mcdi_free_vis(efx); |
140 | if (rc) |
141 | goto fail; |
142 | |
143 | rc = ef100_alloc_vis(efx, allocated_vis: &allocated_vis); |
144 | if (rc && rc != -EAGAIN) |
145 | goto fail; |
146 | |
147 | /* Try one more time but with the maximum number of channels |
148 | * equal to the allocated VIs, which would more likely succeed. |
149 | */ |
150 | if (rc == -EAGAIN) { |
151 | rc = efx_mcdi_free_vis(efx); |
152 | if (rc) |
153 | goto fail; |
154 | |
155 | efx_remove_interrupts(efx); |
156 | efx->max_channels = allocated_vis; |
157 | |
158 | rc = efx_probe_interrupts(efx); |
159 | if (rc) |
160 | goto fail; |
161 | |
162 | rc = efx_set_channels(efx); |
163 | if (rc) |
164 | goto fail; |
165 | |
166 | rc = ef100_alloc_vis(efx, allocated_vis: &allocated_vis); |
167 | if (rc && rc != -EAGAIN) |
168 | goto fail; |
169 | |
170 | /* It should be very unlikely that we failed here again, but in |
171 | * such a case we return ENOSPC. |
172 | */ |
173 | if (rc == -EAGAIN) { |
174 | rc = -ENOSPC; |
175 | goto fail; |
176 | } |
177 | } |
178 | |
179 | rc = efx_probe_channels(efx); |
180 | if (rc) |
181 | return rc; |
182 | |
183 | rc = ef100_remap_bar(efx, max_vis: allocated_vis); |
184 | if (rc) |
185 | goto fail; |
186 | |
187 | efx_init_napi(efx); |
188 | |
189 | rc = efx_probe_filters(efx); |
190 | if (rc) |
191 | goto fail; |
192 | |
193 | rc = efx_nic_init_interrupt(efx); |
194 | if (rc) |
195 | goto fail; |
196 | efx_set_interrupt_affinity(efx); |
197 | |
198 | rc = efx_enable_interrupts(efx); |
199 | if (rc) |
200 | goto fail; |
201 | |
202 | /* in case the MC rebooted while we were stopped, consume the change |
203 | * to the warm reboot count |
204 | */ |
205 | (void) efx_mcdi_poll_reboot(efx); |
206 | |
207 | rc = efx_mcdi_mac_init_stats(efx); |
208 | if (rc) |
209 | goto fail; |
210 | |
211 | efx_start_all(efx); |
212 | |
213 | /* Link state detection is normally event-driven; we have |
214 | * to poll now because we could have missed a change |
215 | */ |
216 | mutex_lock(&efx->mac_lock); |
217 | if (efx_mcdi_phy_poll(efx)) |
218 | efx_link_status_changed(efx); |
219 | mutex_unlock(lock: &efx->mac_lock); |
220 | |
221 | efx->state = STATE_NET_UP; |
222 | if (netif_running(dev: efx->net_dev)) |
223 | efx_attach_reps(efx); |
224 | |
225 | return 0; |
226 | |
227 | fail: |
228 | ef100_net_stop(net_dev); |
229 | return rc; |
230 | } |
231 | |
232 | /* Initiate a packet transmission. We use one channel per CPU |
233 | * (sharing when we have more CPUs than channels). |
234 | * |
235 | * Context: non-blocking. |
236 | * Note that returning anything other than NETDEV_TX_OK will cause the |
237 | * OS to free the skb. |
238 | */ |
239 | static netdev_tx_t ef100_hard_start_xmit(struct sk_buff *skb, |
240 | struct net_device *net_dev) |
241 | { |
242 | struct efx_nic *efx = efx_netdev_priv(dev: net_dev); |
243 | |
244 | return __ef100_hard_start_xmit(skb, efx, net_dev, NULL); |
245 | } |
246 | |
247 | netdev_tx_t __ef100_hard_start_xmit(struct sk_buff *skb, |
248 | struct efx_nic *efx, |
249 | struct net_device *net_dev, |
250 | struct efx_rep *efv) |
251 | { |
252 | struct efx_tx_queue *tx_queue; |
253 | struct efx_channel *channel; |
254 | int rc; |
255 | |
256 | channel = efx_get_tx_channel(efx, index: skb_get_queue_mapping(skb)); |
257 | netif_vdbg(efx, tx_queued, efx->net_dev, |
258 | "%s len %d data %d channel %d\n" , __func__, |
259 | skb->len, skb->data_len, channel->channel); |
260 | if (!efx->n_channels || !efx->n_tx_channels || !channel) { |
261 | netif_stop_queue(dev: net_dev); |
262 | dev_kfree_skb_any(skb); |
263 | goto err; |
264 | } |
265 | |
266 | tx_queue = &channel->tx_queue[0]; |
267 | rc = __ef100_enqueue_skb(tx_queue, skb, efv); |
268 | if (rc == 0) |
269 | return NETDEV_TX_OK; |
270 | |
271 | err: |
272 | net_dev->stats.tx_dropped++; |
273 | return NETDEV_TX_OK; |
274 | } |
275 | |
276 | static const struct net_device_ops ef100_netdev_ops = { |
277 | .ndo_open = ef100_net_open, |
278 | .ndo_stop = ef100_net_stop, |
279 | .ndo_start_xmit = ef100_hard_start_xmit, |
280 | .ndo_tx_timeout = efx_watchdog, |
281 | .ndo_get_stats64 = efx_net_stats, |
282 | .ndo_change_mtu = efx_change_mtu, |
283 | .ndo_validate_addr = eth_validate_addr, |
284 | .ndo_set_mac_address = efx_set_mac_address, |
285 | .ndo_set_rx_mode = efx_set_rx_mode, /* Lookout */ |
286 | .ndo_set_features = efx_set_features, |
287 | .ndo_get_phys_port_id = efx_get_phys_port_id, |
288 | .ndo_get_phys_port_name = efx_get_phys_port_name, |
289 | #ifdef CONFIG_RFS_ACCEL |
290 | .ndo_rx_flow_steer = efx_filter_rfs, |
291 | #endif |
292 | #ifdef CONFIG_SFC_SRIOV |
293 | .ndo_setup_tc = efx_tc_setup, |
294 | #endif |
295 | }; |
296 | |
297 | /* Netdev registration |
298 | */ |
299 | int ef100_netdev_event(struct notifier_block *this, |
300 | unsigned long event, void *ptr) |
301 | { |
302 | struct efx_nic *efx = container_of(this, struct efx_nic, netdev_notifier); |
303 | struct net_device *net_dev = netdev_notifier_info_to_dev(info: ptr); |
304 | struct ef100_nic_data *nic_data = efx->nic_data; |
305 | int err; |
306 | |
307 | if (efx->net_dev == net_dev && |
308 | (event == NETDEV_CHANGENAME || event == NETDEV_REGISTER)) |
309 | ef100_update_name(efx); |
310 | |
311 | if (!nic_data->grp_mae) |
312 | return NOTIFY_DONE; |
313 | err = efx_tc_netdev_event(efx, event, net_dev); |
314 | if (err & NOTIFY_STOP_MASK) |
315 | return err; |
316 | |
317 | return NOTIFY_DONE; |
318 | } |
319 | |
320 | static int ef100_netevent_event(struct notifier_block *this, |
321 | unsigned long event, void *ptr) |
322 | { |
323 | struct efx_nic *efx = container_of(this, struct efx_nic, netevent_notifier); |
324 | struct ef100_nic_data *nic_data = efx->nic_data; |
325 | int err; |
326 | |
327 | if (!nic_data->grp_mae) |
328 | return NOTIFY_DONE; |
329 | err = efx_tc_netevent_event(efx, event, ptr); |
330 | if (err & NOTIFY_STOP_MASK) |
331 | return err; |
332 | |
333 | return NOTIFY_DONE; |
334 | }; |
335 | |
336 | static int ef100_register_netdev(struct efx_nic *efx) |
337 | { |
338 | struct net_device *net_dev = efx->net_dev; |
339 | int rc; |
340 | |
341 | net_dev->watchdog_timeo = 5 * HZ; |
342 | net_dev->irq = efx->pci_dev->irq; |
343 | net_dev->netdev_ops = &ef100_netdev_ops; |
344 | net_dev->min_mtu = EFX_MIN_MTU; |
345 | net_dev->max_mtu = EFX_MAX_MTU; |
346 | net_dev->ethtool_ops = &ef100_ethtool_ops; |
347 | |
348 | rtnl_lock(); |
349 | |
350 | rc = dev_alloc_name(dev: net_dev, name: net_dev->name); |
351 | if (rc < 0) |
352 | goto fail_locked; |
353 | ef100_update_name(efx); |
354 | |
355 | rc = register_netdevice(dev: net_dev); |
356 | if (rc) |
357 | goto fail_locked; |
358 | |
359 | /* Always start with carrier off; PHY events will detect the link */ |
360 | netif_carrier_off(dev: net_dev); |
361 | |
362 | efx->state = STATE_NET_DOWN; |
363 | rtnl_unlock(); |
364 | efx_init_mcdi_logging(efx); |
365 | |
366 | return 0; |
367 | |
368 | fail_locked: |
369 | rtnl_unlock(); |
370 | netif_err(efx, drv, efx->net_dev, "could not register net dev\n" ); |
371 | return rc; |
372 | } |
373 | |
374 | static void ef100_unregister_netdev(struct efx_nic *efx) |
375 | { |
376 | if (efx_dev_registered(efx)) { |
377 | efx_fini_mcdi_logging(efx); |
378 | efx->state = STATE_PROBED; |
379 | unregister_netdev(dev: efx->net_dev); |
380 | } |
381 | } |
382 | |
383 | void ef100_remove_netdev(struct efx_probe_data *probe_data) |
384 | { |
385 | struct efx_nic *efx = &probe_data->efx; |
386 | |
387 | if (!efx->net_dev) |
388 | return; |
389 | |
390 | rtnl_lock(); |
391 | dev_close(dev: efx->net_dev); |
392 | rtnl_unlock(); |
393 | |
394 | unregister_netdevice_notifier(nb: &efx->netdev_notifier); |
395 | unregister_netevent_notifier(nb: &efx->netevent_notifier); |
396 | #if defined(CONFIG_SFC_SRIOV) |
397 | if (!efx->type->is_vf) |
398 | efx_ef100_pci_sriov_disable(efx, force: true); |
399 | #endif |
400 | |
401 | efx_fini_devlink_lock(efx); |
402 | ef100_unregister_netdev(efx); |
403 | |
404 | #ifdef CONFIG_SFC_SRIOV |
405 | ef100_pf_unset_devlink_port(efx); |
406 | efx_fini_tc(efx); |
407 | #endif |
408 | |
409 | down_write(sem: &efx->filter_sem); |
410 | efx_mcdi_filter_table_remove(efx); |
411 | up_write(sem: &efx->filter_sem); |
412 | efx_fini_channels(efx); |
413 | kfree(objp: efx->phy_data); |
414 | efx->phy_data = NULL; |
415 | |
416 | efx_fini_devlink_and_unlock(efx); |
417 | |
418 | free_netdev(dev: efx->net_dev); |
419 | efx->net_dev = NULL; |
420 | efx->state = STATE_PROBED; |
421 | } |
422 | |
423 | int ef100_probe_netdev(struct efx_probe_data *probe_data) |
424 | { |
425 | struct efx_nic *efx = &probe_data->efx; |
426 | struct efx_probe_data **probe_ptr; |
427 | struct ef100_nic_data *nic_data; |
428 | struct net_device *net_dev; |
429 | int rc; |
430 | |
431 | if (efx->mcdi->fn_flags & |
432 | (1 << MC_CMD_DRV_ATTACH_EXT_OUT_FLAG_NO_ACTIVE_PORT)) { |
433 | pci_info(efx->pci_dev, "No network port on this PCI function" ); |
434 | return 0; |
435 | } |
436 | |
437 | /* Allocate and initialise a struct net_device */ |
438 | net_dev = alloc_etherdev_mq(sizeof(probe_data), EFX_MAX_CORE_TX_QUEUES); |
439 | if (!net_dev) |
440 | return -ENOMEM; |
441 | probe_ptr = netdev_priv(dev: net_dev); |
442 | *probe_ptr = probe_data; |
443 | efx->net_dev = net_dev; |
444 | SET_NETDEV_DEV(net_dev, &efx->pci_dev->dev); |
445 | |
446 | /* enable all supported features except rx-fcs and rx-all */ |
447 | net_dev->features |= efx->type->offload_features & |
448 | ~(NETIF_F_RXFCS | NETIF_F_RXALL); |
449 | net_dev->hw_features |= efx->type->offload_features; |
450 | net_dev->hw_enc_features |= efx->type->offload_features; |
451 | net_dev->vlan_features |= NETIF_F_HW_CSUM | NETIF_F_SG | |
452 | NETIF_F_HIGHDMA | NETIF_F_ALL_TSO; |
453 | netif_set_tso_max_segs(dev: net_dev, |
454 | ESE_EF100_DP_GZ_TSO_MAX_HDR_NUM_SEGS_DEFAULT); |
455 | efx->mdio.dev = net_dev; |
456 | |
457 | rc = efx_ef100_init_datapath_caps(efx); |
458 | if (rc < 0) |
459 | goto fail; |
460 | |
461 | rc = ef100_phy_probe(efx); |
462 | if (rc) |
463 | goto fail; |
464 | |
465 | rc = efx_init_channels(efx); |
466 | if (rc) |
467 | goto fail; |
468 | |
469 | down_write(sem: &efx->filter_sem); |
470 | rc = ef100_filter_table_probe(efx); |
471 | up_write(sem: &efx->filter_sem); |
472 | if (rc) |
473 | goto fail; |
474 | |
475 | netdev_rss_key_fill(buffer: efx->rss_context.rx_hash_key, |
476 | len: sizeof(efx->rss_context.rx_hash_key)); |
477 | |
478 | /* Don't fail init if RSS setup doesn't work. */ |
479 | efx_mcdi_push_default_indir_table(efx, rss_spread: efx->n_rx_channels); |
480 | |
481 | nic_data = efx->nic_data; |
482 | rc = ef100_get_mac_address(efx, mac_address: net_dev->perm_addr, CLIENT_HANDLE_SELF, |
483 | empty_ok: efx->type->is_vf); |
484 | if (rc) |
485 | return rc; |
486 | /* Assign MAC address */ |
487 | eth_hw_addr_set(dev: net_dev, addr: net_dev->perm_addr); |
488 | ether_addr_copy(dst: nic_data->port_id, src: net_dev->perm_addr); |
489 | |
490 | /* devlink creation, registration and lock */ |
491 | rc = efx_probe_devlink_and_lock(efx); |
492 | if (rc) |
493 | pci_info(efx->pci_dev, "devlink registration failed" ); |
494 | |
495 | rc = ef100_register_netdev(efx); |
496 | if (rc) |
497 | goto fail; |
498 | |
499 | if (!efx->type->is_vf) { |
500 | rc = ef100_probe_netdev_pf(efx); |
501 | if (rc) |
502 | goto fail; |
503 | #ifdef CONFIG_SFC_SRIOV |
504 | ef100_pf_set_devlink_port(efx); |
505 | #endif |
506 | } |
507 | |
508 | efx->netdev_notifier.notifier_call = ef100_netdev_event; |
509 | rc = register_netdevice_notifier(nb: &efx->netdev_notifier); |
510 | if (rc) { |
511 | netif_err(efx, probe, efx->net_dev, |
512 | "Failed to register netdevice notifier, rc=%d\n" , rc); |
513 | goto fail; |
514 | } |
515 | |
516 | efx->netevent_notifier.notifier_call = ef100_netevent_event; |
517 | rc = register_netevent_notifier(nb: &efx->netevent_notifier); |
518 | if (rc) { |
519 | netif_err(efx, probe, efx->net_dev, |
520 | "Failed to register netevent notifier, rc=%d\n" , rc); |
521 | goto fail; |
522 | } |
523 | |
524 | efx_probe_devlink_unlock(efx); |
525 | return rc; |
526 | fail: |
527 | #ifdef CONFIG_SFC_SRIOV |
528 | /* remove devlink port if does exist */ |
529 | ef100_pf_unset_devlink_port(efx); |
530 | #endif |
531 | efx_probe_devlink_unlock(efx); |
532 | return rc; |
533 | } |
534 | |