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
26static void ef100_update_name(struct efx_nic *efx)
27{
28	strcpy(efx->name, efx->net_dev->name);
29}
30
31static int ef100_alloc_vis(struct efx_nic *efx, unsigned int *allocated_vis)
32{
33	/* EF100 uses a single TXQ per channel, as all checksum offloading
34	 * is configured in the TX descriptor, and there is no TX Pacer for
35	 * HIGHPRI queues.
36	 */
37	unsigned int tx_vis = efx->n_tx_channels + efx->n_extra_tx_channels;
38	unsigned int rx_vis = efx->n_rx_channels;
39	unsigned int min_vis, max_vis;
40
41	EFX_WARN_ON_PARANOID(efx->tx_queues_per_channel != 1);
42
43	tx_vis += efx->n_xdp_channels * efx->xdp_tx_per_channel;
44
45	max_vis = max(rx_vis, tx_vis);
46	/* Currently don't handle resource starvation and only accept
47	 * our maximum needs and no less.
48	 */
49	min_vis = max_vis;
50
51	return efx_mcdi_alloc_vis(efx, min_vis, max_vis,
52				  NULL, allocated_vis);
53}
54
55static int ef100_remap_bar(struct efx_nic *efx, int max_vis)
56{
57	unsigned int uc_mem_map_size;
58	void __iomem *membase;
59
60	efx->max_vis = max_vis;
61	uc_mem_map_size = PAGE_ALIGN(max_vis * efx->vi_stride);
62
63	/* Extend the original UC mapping of the memory BAR */
64	membase = ioremap(efx->membase_phys, uc_mem_map_size);
65	if (!membase) {
66		netif_err(efx, probe, efx->net_dev,
67			  "could not extend memory BAR to %x\n",
68			  uc_mem_map_size);
69		return -ENOMEM;
70	}
71	iounmap(efx->membase);
72	efx->membase = membase;
73	return 0;
74}
75
76/* Context: process, rtnl_lock() held.
77 * Note that the kernel will ignore our return code; this method
78 * should really be a void.
79 */
80static int ef100_net_stop(struct net_device *net_dev)
81{
82	struct efx_nic *efx = netdev_priv(net_dev);
83
84	netif_dbg(efx, ifdown, efx->net_dev, "closing on CPU %d\n",
85		  raw_smp_processor_id());
86
87	netif_stop_queue(net_dev);
88	efx_stop_all(efx);
89	efx_mcdi_mac_fini_stats(efx);
90	efx_disable_interrupts(efx);
91	efx_clear_interrupt_affinity(efx);
92	efx_nic_fini_interrupt(efx);
93	efx_remove_filters(efx);
94	efx_fini_napi(efx);
95	efx_remove_channels(efx);
96	efx_mcdi_free_vis(efx);
97	efx_remove_interrupts(efx);
98
99	efx->state = STATE_NET_DOWN;
100
101	return 0;
102}
103
104/* Context: process, rtnl_lock() held. */
105static int ef100_net_open(struct net_device *net_dev)
106{
107	struct efx_nic *efx = netdev_priv(net_dev);
108	unsigned int allocated_vis;
109	int rc;
110
111	ef100_update_name(efx);
112	netif_dbg(efx, ifup, net_dev, "opening device on CPU %d\n",
113		  raw_smp_processor_id());
114
115	rc = efx_check_disabled(efx);
116	if (rc)
117		goto fail;
118
119	rc = efx_probe_interrupts(efx);
120	if (rc)
121		goto fail;
122
123	rc = efx_set_channels(efx);
124	if (rc)
125		goto fail;
126
127	rc = efx_mcdi_free_vis(efx);
128	if (rc)
129		goto fail;
130
131	rc = ef100_alloc_vis(efx, &allocated_vis);
132	if (rc)
133		goto fail;
134
135	rc = efx_probe_channels(efx);
136	if (rc)
137		return rc;
138
139	rc = ef100_remap_bar(efx, allocated_vis);
140	if (rc)
141		goto fail;
142
143	efx_init_napi(efx);
144
145	rc = efx_probe_filters(efx);
146	if (rc)
147		goto fail;
148
149	rc = efx_nic_init_interrupt(efx);
150	if (rc)
151		goto fail;
152	efx_set_interrupt_affinity(efx);
153
154	rc = efx_enable_interrupts(efx);
155	if (rc)
156		goto fail;
157
158	/* in case the MC rebooted while we were stopped, consume the change
159	 * to the warm reboot count
160	 */
161	(void) efx_mcdi_poll_reboot(efx);
162
163	rc = efx_mcdi_mac_init_stats(efx);
164	if (rc)
165		goto fail;
166
167	efx_start_all(efx);
168
169	/* Link state detection is normally event-driven; we have
170	 * to poll now because we could have missed a change
171	 */
172	mutex_lock(&efx->mac_lock);
173	if (efx_mcdi_phy_poll(efx))
174		efx_link_status_changed(efx);
175	mutex_unlock(&efx->mac_lock);
176
177	efx->state = STATE_NET_UP;
178
179	return 0;
180
181fail:
182	ef100_net_stop(net_dev);
183	return rc;
184}
185
186/* Initiate a packet transmission.  We use one channel per CPU
187 * (sharing when we have more CPUs than channels).
188 *
189 * Context: non-blocking.
190 * Note that returning anything other than NETDEV_TX_OK will cause the
191 * OS to free the skb.
192 */
193static netdev_tx_t ef100_hard_start_xmit(struct sk_buff *skb,
194					 struct net_device *net_dev)
195{
196	struct efx_nic *efx = netdev_priv(net_dev);
197	struct efx_tx_queue *tx_queue;
198	struct efx_channel *channel;
199	int rc;
200
201	channel = efx_get_tx_channel(efx, skb_get_queue_mapping(skb));
202	netif_vdbg(efx, tx_queued, efx->net_dev,
203		   "%s len %d data %d channel %d\n", __func__,
204		   skb->len, skb->data_len, channel->channel);
205	if (!efx->n_channels || !efx->n_tx_channels || !channel) {
206		netif_stop_queue(net_dev);
207		dev_kfree_skb_any(skb);
208		goto err;
209	}
210
211	tx_queue = &channel->tx_queue[0];
212	rc = ef100_enqueue_skb(tx_queue, skb);
213	if (rc == 0)
214		return NETDEV_TX_OK;
215
216err:
217	net_dev->stats.tx_dropped++;
218	return NETDEV_TX_OK;
219}
220
221static const struct net_device_ops ef100_netdev_ops = {
222	.ndo_open               = ef100_net_open,
223	.ndo_stop               = ef100_net_stop,
224	.ndo_start_xmit         = ef100_hard_start_xmit,
225	.ndo_tx_timeout         = efx_watchdog,
226	.ndo_get_stats64        = efx_net_stats,
227	.ndo_change_mtu         = efx_change_mtu,
228	.ndo_validate_addr      = eth_validate_addr,
229	.ndo_set_mac_address    = efx_set_mac_address,
230	.ndo_set_rx_mode        = efx_set_rx_mode, /* Lookout */
231	.ndo_set_features       = efx_set_features,
232	.ndo_get_phys_port_id   = efx_get_phys_port_id,
233	.ndo_get_phys_port_name = efx_get_phys_port_name,
234#ifdef CONFIG_RFS_ACCEL
235	.ndo_rx_flow_steer      = efx_filter_rfs,
236#endif
237};
238
239/*	Netdev registration
240 */
241int ef100_netdev_event(struct notifier_block *this,
242		       unsigned long event, void *ptr)
243{
244	struct efx_nic *efx = container_of(this, struct efx_nic, netdev_notifier);
245	struct net_device *net_dev = netdev_notifier_info_to_dev(ptr);
246
247	if (netdev_priv(net_dev) == efx && event == NETDEV_CHANGENAME)
248		ef100_update_name(efx);
249
250	return NOTIFY_DONE;
251}
252
253int ef100_register_netdev(struct efx_nic *efx)
254{
255	struct net_device *net_dev = efx->net_dev;
256	int rc;
257
258	net_dev->watchdog_timeo = 5 * HZ;
259	net_dev->irq = efx->pci_dev->irq;
260	net_dev->netdev_ops = &ef100_netdev_ops;
261	net_dev->min_mtu = EFX_MIN_MTU;
262	net_dev->max_mtu = EFX_MAX_MTU;
263	net_dev->ethtool_ops = &ef100_ethtool_ops;
264
265	rtnl_lock();
266
267	rc = dev_alloc_name(net_dev, net_dev->name);
268	if (rc < 0)
269		goto fail_locked;
270	ef100_update_name(efx);
271
272	rc = register_netdevice(net_dev);
273	if (rc)
274		goto fail_locked;
275
276	/* Always start with carrier off; PHY events will detect the link */
277	netif_carrier_off(net_dev);
278
279	efx->state = STATE_NET_DOWN;
280	rtnl_unlock();
281	efx_init_mcdi_logging(efx);
282
283	return 0;
284
285fail_locked:
286	rtnl_unlock();
287	netif_err(efx, drv, efx->net_dev, "could not register net dev\n");
288	return rc;
289}
290
291void ef100_unregister_netdev(struct efx_nic *efx)
292{
293	if (efx_dev_registered(efx)) {
294		efx_fini_mcdi_logging(efx);
295		efx->state = STATE_UNINIT;
296		unregister_netdev(efx->net_dev);
297	}
298}
299