Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : *
3 : : * Copyright(c) 2019-2021 Xilinx, Inc.
4 : : * Copyright(c) 2016-2019 Solarflare Communications Inc.
5 : : *
6 : : * This software was jointly developed between OKTET Labs (under contract
7 : : * for Solarflare) and Solarflare Communications, Inc.
8 : : */
9 : :
10 : : /*
11 : : * At the moment of writing DPDK v16.07 has notion of two types of
12 : : * interrupts: LSC (link status change) and RXQ (receive indication).
13 : : * It allows to register interrupt callback for entire device which is
14 : : * not intended to be used for receive indication (i.e. link status
15 : : * change indication only). The handler has no information which HW
16 : : * interrupt has triggered it, so we don't know which event queue should
17 : : * be polled/reprimed (except qmask in the case of legacy line interrupt).
18 : : */
19 : :
20 : : #include <rte_common.h>
21 : : #include <rte_interrupts.h>
22 : :
23 : : #include "efx.h"
24 : :
25 : : #include "sfc.h"
26 : : #include "sfc_log.h"
27 : : #include "sfc_ev.h"
28 : :
29 : : static void
30 : 0 : sfc_intr_handle_mgmt_evq(struct sfc_adapter *sa)
31 : : {
32 : : struct sfc_evq *evq;
33 : :
34 : 0 : rte_spinlock_lock(&sa->mgmt_evq_lock);
35 : :
36 : 0 : evq = sa->mgmt_evq;
37 : :
38 [ # # ]: 0 : if (!sa->mgmt_evq_running) {
39 : 0 : sfc_log_init(sa, "interrupt on not running management EVQ %u",
40 : : evq->evq_index);
41 : : } else {
42 : 0 : sfc_ev_qpoll(evq);
43 : :
44 [ # # ]: 0 : if (sfc_ev_qprime(evq) != 0)
45 : 0 : sfc_err(sa, "cannot prime EVQ %u", evq->evq_index);
46 : : }
47 : :
48 : : rte_spinlock_unlock(&sa->mgmt_evq_lock);
49 : 0 : }
50 : :
51 : : static void
52 : 0 : sfc_intr_line_handler(void *cb_arg)
53 : : {
54 : : struct sfc_adapter *sa = (struct sfc_adapter *)cb_arg;
55 : 0 : efx_nic_t *enp = sa->nic;
56 : : boolean_t fatal;
57 : : uint32_t qmask;
58 : 0 : unsigned int lsc_seq = sa->port.lsc_seq;
59 : 0 : struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(sa->eth_dev);
60 : :
61 : 0 : sfc_log_init(sa, "entry");
62 : :
63 : 0 : if (sa->state != SFC_ETHDEV_STARTED &&
64 [ # # ]: 0 : sa->state != SFC_ETHDEV_STARTING &&
65 : : sa->state != SFC_ETHDEV_STOPPING) {
66 : 0 : sfc_log_init(sa,
67 : : "interrupt on stopped adapter, don't reenable");
68 : 0 : goto exit;
69 : : }
70 : :
71 : 0 : efx_intr_status_line(enp, &fatal, &qmask);
72 [ # # ]: 0 : if (fatal) {
73 : 0 : (void)efx_intr_disable(enp);
74 : 0 : (void)efx_intr_fatal(enp);
75 : 0 : sfc_err(sa, "fatal, interrupts disabled");
76 : 0 : goto exit;
77 : : }
78 : :
79 [ # # ]: 0 : if (qmask & (1 << sa->mgmt_evq_index))
80 : 0 : sfc_intr_handle_mgmt_evq(sa);
81 : :
82 [ # # ]: 0 : if (rte_intr_ack(pci_dev->intr_handle) != 0)
83 : 0 : sfc_err(sa, "cannot reenable interrupts");
84 : :
85 : 0 : sfc_log_init(sa, "done");
86 : :
87 : 0 : exit:
88 [ # # ]: 0 : if (lsc_seq != sa->port.lsc_seq) {
89 [ # # ]: 0 : sfc_notice(sa, "link status change event: link %s",
90 : : sa->eth_dev->data->dev_link.link_status ?
91 : : "UP" : "DOWN");
92 : 0 : rte_eth_dev_callback_process(sa->eth_dev,
93 : : RTE_ETH_EVENT_INTR_LSC,
94 : : NULL);
95 : : }
96 : 0 : }
97 : :
98 : : static void
99 : 0 : sfc_intr_message_handler(void *cb_arg)
100 : : {
101 : : struct sfc_adapter *sa = (struct sfc_adapter *)cb_arg;
102 : 0 : efx_nic_t *enp = sa->nic;
103 : : boolean_t fatal;
104 : 0 : unsigned int lsc_seq = sa->port.lsc_seq;
105 : 0 : struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(sa->eth_dev);
106 : :
107 : 0 : sfc_log_init(sa, "entry");
108 : :
109 : 0 : if (sa->state != SFC_ETHDEV_STARTED &&
110 [ # # ]: 0 : sa->state != SFC_ETHDEV_STARTING &&
111 : : sa->state != SFC_ETHDEV_STOPPING) {
112 : 0 : sfc_log_init(sa, "adapter not-started, don't reenable");
113 : 0 : goto exit;
114 : : }
115 : :
116 : 0 : efx_intr_status_message(enp, sa->mgmt_evq_index, &fatal);
117 [ # # ]: 0 : if (fatal) {
118 : 0 : (void)efx_intr_disable(enp);
119 : 0 : (void)efx_intr_fatal(enp);
120 : 0 : sfc_err(sa, "fatal, interrupts disabled");
121 : 0 : goto exit;
122 : : }
123 : :
124 : 0 : sfc_intr_handle_mgmt_evq(sa);
125 : :
126 [ # # ]: 0 : if (rte_intr_ack(pci_dev->intr_handle) != 0)
127 : 0 : sfc_err(sa, "cannot reenable interrupts");
128 : :
129 : 0 : sfc_log_init(sa, "done");
130 : :
131 : 0 : exit:
132 [ # # ]: 0 : if (lsc_seq != sa->port.lsc_seq) {
133 : 0 : sfc_notice(sa, "link status change event");
134 : 0 : rte_eth_dev_callback_process(sa->eth_dev,
135 : : RTE_ETH_EVENT_INTR_LSC,
136 : : NULL);
137 : : }
138 : 0 : }
139 : :
140 : : int
141 : 0 : sfc_intr_start(struct sfc_adapter *sa)
142 : : {
143 : : struct sfc_intr *intr = &sa->intr;
144 : : struct rte_intr_handle *intr_handle;
145 : : struct rte_pci_device *pci_dev;
146 : : int rc;
147 : :
148 : 0 : sfc_log_init(sa, "entry");
149 : :
150 : : /*
151 : : * The EFX common code event queue module depends on the interrupt
152 : : * module. Ensure that the interrupt module is always initialized
153 : : * (even if interrupts are not used). Status memory is required
154 : : * for Siena only and may be NULL for EF10.
155 : : */
156 : 0 : sfc_log_init(sa, "efx_intr_init");
157 : 0 : rc = efx_intr_init(sa->nic, intr->type, NULL);
158 [ # # ]: 0 : if (rc != 0)
159 : 0 : goto fail_intr_init;
160 : :
161 : 0 : pci_dev = RTE_ETH_DEV_TO_PCI(sa->eth_dev);
162 : 0 : intr_handle = pci_dev->intr_handle;
163 : :
164 [ # # ]: 0 : if (intr->handler != NULL) {
165 [ # # # # ]: 0 : if (intr->rxq_intr && rte_intr_cap_multiple(intr_handle)) {
166 : : uint32_t intr_vector;
167 : :
168 : 0 : intr_vector = sa->eth_dev->data->nb_rx_queues;
169 : 0 : rc = rte_intr_efd_enable(intr_handle, intr_vector);
170 [ # # ]: 0 : if (rc != 0)
171 : 0 : goto fail_rte_intr_efd_enable;
172 : : }
173 [ # # ]: 0 : if (rte_intr_dp_is_en(intr_handle)) {
174 [ # # ]: 0 : if (rte_intr_vec_list_alloc(intr_handle,
175 : : "intr_vec",
176 : 0 : sa->eth_dev->data->nb_rx_queues)) {
177 : 0 : sfc_err(sa,
178 : : "Failed to allocate %d rx_queues intr_vec",
179 : : sa->eth_dev->data->nb_rx_queues);
180 : 0 : goto fail_intr_vector_alloc;
181 : : }
182 : :
183 : : }
184 : :
185 : 0 : sfc_log_init(sa, "rte_intr_callback_register");
186 : 0 : rc = rte_intr_callback_register(intr_handle, intr->handler,
187 : : (void *)sa);
188 [ # # ]: 0 : if (rc != 0) {
189 : 0 : sfc_err(sa,
190 : : "cannot register interrupt handler (rc=%d)",
191 : : rc);
192 : : /*
193 : : * Convert error code from negative returned by RTE API
194 : : * to positive used in the driver.
195 : : */
196 : 0 : rc = -rc;
197 : 0 : goto fail_rte_intr_cb_reg;
198 : : }
199 : :
200 : 0 : sfc_log_init(sa, "rte_intr_enable");
201 : 0 : rc = rte_intr_enable(intr_handle);
202 [ # # ]: 0 : if (rc != 0) {
203 : 0 : sfc_err(sa, "cannot enable interrupts (rc=%d)", rc);
204 : : /*
205 : : * Convert error code from negative returned by RTE API
206 : : * to positive used in the driver.
207 : : */
208 : 0 : rc = -rc;
209 : 0 : goto fail_rte_intr_enable;
210 : : }
211 : :
212 : 0 : sfc_log_init(sa, "efx_intr_enable");
213 : 0 : efx_intr_enable(sa->nic);
214 : : }
215 : :
216 : 0 : sfc_log_init(sa, "done type=%u max_intr=%d nb_efd=%u",
217 : : rte_intr_type_get(intr_handle),
218 : : rte_intr_max_intr_get(intr_handle),
219 : : rte_intr_nb_efd_get(intr_handle));
220 : 0 : return 0;
221 : :
222 : : fail_rte_intr_enable:
223 : 0 : rte_intr_callback_unregister(intr_handle, intr->handler, (void *)sa);
224 : :
225 : 0 : fail_rte_intr_cb_reg:
226 : 0 : rte_intr_vec_list_free(intr_handle);
227 : :
228 : 0 : fail_intr_vector_alloc:
229 : 0 : rte_intr_efd_disable(intr_handle);
230 : :
231 : 0 : fail_rte_intr_efd_enable:
232 : 0 : efx_intr_fini(sa->nic);
233 : :
234 : 0 : fail_intr_init:
235 : 0 : sfc_log_init(sa, "failed %d", rc);
236 : 0 : return rc;
237 : : }
238 : :
239 : : void
240 : 0 : sfc_intr_stop(struct sfc_adapter *sa)
241 : : {
242 : : struct sfc_intr *intr = &sa->intr;
243 : 0 : struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(sa->eth_dev);
244 : :
245 : 0 : sfc_log_init(sa, "entry");
246 : :
247 [ # # ]: 0 : if (intr->handler != NULL) {
248 : : struct rte_intr_handle *intr_handle;
249 : : int rc;
250 : :
251 : 0 : efx_intr_disable(sa->nic);
252 : :
253 : 0 : intr_handle = pci_dev->intr_handle;
254 : :
255 : 0 : rte_intr_vec_list_free(intr_handle);
256 : 0 : rte_intr_efd_disable(intr_handle);
257 : :
258 [ # # ]: 0 : if (rte_intr_disable(intr_handle) != 0)
259 : 0 : sfc_err(sa, "cannot disable interrupts");
260 : :
261 : 0 : while ((rc = rte_intr_callback_unregister(intr_handle,
262 [ # # ]: 0 : intr->handler, (void *)sa)) == -EAGAIN)
263 : : ;
264 [ # # ]: 0 : if (rc != 1)
265 : 0 : sfc_err(sa,
266 : : "cannot unregister interrupt handler %d",
267 : : rc);
268 : : }
269 : :
270 : 0 : efx_intr_fini(sa->nic);
271 : :
272 : 0 : sfc_log_init(sa, "done");
273 : 0 : }
274 : :
275 : : int
276 : 0 : sfc_intr_configure(struct sfc_adapter *sa)
277 : : {
278 : : struct sfc_intr *intr = &sa->intr;
279 : :
280 : 0 : sfc_log_init(sa, "entry");
281 : :
282 : 0 : intr->handler = NULL;
283 : 0 : intr->lsc_intr = (sa->eth_dev->data->dev_conf.intr_conf.lsc != 0);
284 : 0 : intr->rxq_intr = (sa->eth_dev->data->dev_conf.intr_conf.rxq != 0);
285 : :
286 [ # # # # ]: 0 : if (!intr->lsc_intr && !intr->rxq_intr)
287 : 0 : goto done;
288 : :
289 [ # # # # ]: 0 : switch (intr->type) {
290 : 0 : case EFX_INTR_MESSAGE:
291 : 0 : intr->handler = sfc_intr_message_handler;
292 : 0 : break;
293 : 0 : case EFX_INTR_LINE:
294 : 0 : intr->handler = sfc_intr_line_handler;
295 : 0 : break;
296 : 0 : case EFX_INTR_INVALID:
297 : 0 : sfc_warn(sa, "interrupts are not supported");
298 : 0 : break;
299 : 0 : default:
300 : 0 : sfc_panic(sa, "unexpected EFX interrupt type %u\n", intr->type);
301 : : break;
302 : : }
303 : :
304 : 0 : done:
305 : 0 : sfc_log_init(sa, "done");
306 : 0 : return 0;
307 : : }
308 : :
309 : : void
310 : 0 : sfc_intr_close(struct sfc_adapter *sa)
311 : : {
312 : 0 : sfc_log_init(sa, "entry");
313 : :
314 : 0 : sfc_log_init(sa, "done");
315 : 0 : }
316 : :
317 : : int
318 : 0 : sfc_intr_attach(struct sfc_adapter *sa)
319 : : {
320 : : struct sfc_intr *intr = &sa->intr;
321 : 0 : struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(sa->eth_dev);
322 : :
323 : 0 : sfc_log_init(sa, "entry");
324 : :
325 [ # # # ]: 0 : switch (rte_intr_type_get(pci_dev->intr_handle)) {
326 : : #ifdef RTE_EXEC_ENV_LINUX
327 : 0 : case RTE_INTR_HANDLE_UIO_INTX:
328 : : case RTE_INTR_HANDLE_VFIO_LEGACY:
329 : 0 : intr->type = EFX_INTR_LINE;
330 : 0 : break;
331 : 0 : case RTE_INTR_HANDLE_UIO:
332 : : case RTE_INTR_HANDLE_VFIO_MSI:
333 : : case RTE_INTR_HANDLE_VFIO_MSIX:
334 : 0 : intr->type = EFX_INTR_MESSAGE;
335 : 0 : break;
336 : : #endif
337 : 0 : default:
338 : 0 : intr->type = EFX_INTR_INVALID;
339 : 0 : break;
340 : : }
341 : :
342 : 0 : sfc_log_init(sa, "done");
343 : 0 : return 0;
344 : : }
345 : :
346 : : void
347 : 0 : sfc_intr_detach(struct sfc_adapter *sa)
348 : : {
349 : 0 : sfc_log_init(sa, "entry");
350 : :
351 : 0 : sa->intr.type = EFX_INTR_INVALID;
352 : :
353 : 0 : sfc_log_init(sa, "done");
354 : 0 : }
|
