1 /* SPDX-License-Identifier: BSD-3-Clause */
2 /* Copyright (c) 2024, Intel Corporation
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright notice,
9 * this list of conditions and the following disclaimer.
10 *
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * 3. Neither the name of the Intel Corporation nor the names of its
16 * contributors may be used to endorse or promote products derived from
17 * this software without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
20 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
23 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 /**
33 * @file iavf_lib.c
34 * @brief library code common to both legacy and iflib
35 *
36 * Contains functions common to the iflib and legacy drivers. Includes
37 * hardware initialization and control functions, as well as sysctl handlers
38 * for the sysctls which are shared between the legacy and iflib drivers.
39 */
40 #include "iavf_iflib.h"
41 #include "iavf_vc_common.h"
42
43 static void iavf_init_hw(struct iavf_hw *hw, device_t dev);
44 static u_int iavf_mc_filter_apply(void *arg, struct sockaddr_dl *sdl, u_int cnt);
45
46 /**
47 * iavf_msec_pause - Pause for at least the specified number of milliseconds
48 * @msecs: number of milliseconds to pause for
49 *
50 * Pause execution of the current thread for a specified number of
51 * milliseconds. Used to enforce minimum delay times when waiting for various
52 * hardware events.
53 */
54 void
iavf_msec_pause(int msecs)55 iavf_msec_pause(int msecs)
56 {
57 pause("iavf_msec_pause", MSEC_2_TICKS(msecs));
58 }
59
60 /**
61 * iavf_get_default_rss_key - Get the default RSS key for this driver
62 * @key: output parameter to store the key in
63 *
64 * Copies the driver's default RSS key into the provided key variable.
65 *
66 * @pre assumes that key is not NULL and has at least IAVF_RSS_KEY_SIZE
67 * storage space.
68 */
69 void
iavf_get_default_rss_key(u32 * key)70 iavf_get_default_rss_key(u32 *key)
71 {
72 MPASS(key != NULL);
73
74 u32 rss_seed[IAVF_RSS_KEY_SIZE_REG] = {0x41b01687,
75 0x183cfd8c, 0xce880440, 0x580cbc3c,
76 0x35897377, 0x328b25e1, 0x4fa98922,
77 0xb7d90c14, 0xd5bad70d, 0xcd15a2c1,
78 0x0, 0x0, 0x0};
79
80 bcopy(rss_seed, key, IAVF_RSS_KEY_SIZE);
81 }
82
83 /**
84 * iavf_allocate_pci_resources_common - Allocate PCI resources
85 * @sc: the private device softc pointer
86 *
87 * @pre sc->dev is set
88 *
89 * Allocates the common PCI resources used by the driver.
90 *
91 * @returns zero on success, or an error code on failure.
92 */
93 int
iavf_allocate_pci_resources_common(struct iavf_sc * sc)94 iavf_allocate_pci_resources_common(struct iavf_sc *sc)
95 {
96 struct iavf_hw *hw = &sc->hw;
97 device_t dev = sc->dev;
98 int rid;
99
100 /* Map PCI BAR0 */
101 rid = PCIR_BAR(0);
102 sc->pci_mem = bus_alloc_resource_any(dev, SYS_RES_MEMORY,
103 &rid, RF_ACTIVE);
104
105 if (!(sc->pci_mem)) {
106 device_printf(dev, "Unable to allocate bus resource: PCI memory\n");
107 return (ENXIO);
108 }
109
110 iavf_init_hw(hw, dev);
111
112 /* Save off register access information */
113 sc->osdep.mem_bus_space_tag =
114 rman_get_bustag(sc->pci_mem);
115 sc->osdep.mem_bus_space_handle =
116 rman_get_bushandle(sc->pci_mem);
117 sc->osdep.mem_bus_space_size = rman_get_size(sc->pci_mem);
118 sc->osdep.flush_reg = IAVF_VFGEN_RSTAT;
119 sc->osdep.dev = dev;
120
121 sc->hw.hw_addr = (u8 *)&sc->osdep.mem_bus_space_handle;
122 sc->hw.back = &sc->osdep;
123
124 return (0);
125 }
126
127 /**
128 * iavf_init_hw - Initialize the device HW
129 * @hw: device hardware structure
130 * @dev: the stack device_t pointer
131 *
132 * Attach helper function. Gathers information about the (virtual) hardware
133 * for use elsewhere in the driver.
134 */
135 static void
iavf_init_hw(struct iavf_hw * hw,device_t dev)136 iavf_init_hw(struct iavf_hw *hw, device_t dev)
137 {
138 /* Save off the information about this board */
139 hw->vendor_id = pci_get_vendor(dev);
140 hw->device_id = pci_get_device(dev);
141 hw->revision_id = pci_read_config(dev, PCIR_REVID, 1);
142 hw->subsystem_vendor_id =
143 pci_read_config(dev, PCIR_SUBVEND_0, 2);
144 hw->subsystem_device_id =
145 pci_read_config(dev, PCIR_SUBDEV_0, 2);
146
147 hw->bus.device = pci_get_slot(dev);
148 hw->bus.func = pci_get_function(dev);
149 }
150
151 /**
152 * iavf_sysctl_current_speed - Sysctl to display the current device speed
153 * @oidp: syctl oid pointer
154 * @arg1: pointer to the device softc typecasted to void *
155 * @arg2: unused sysctl argument
156 * @req: sysctl request structure
157 *
158 * Reads the current speed reported from the physical device into a string for
159 * display by the current_speed sysctl.
160 *
161 * @returns zero or an error code on failure.
162 */
163 int
iavf_sysctl_current_speed(SYSCTL_HANDLER_ARGS)164 iavf_sysctl_current_speed(SYSCTL_HANDLER_ARGS)
165 {
166 struct iavf_sc *sc = (struct iavf_sc *)arg1;
167 int error = 0;
168
169 UNREFERENCED_PARAMETER(arg2);
170
171 if (iavf_driver_is_detaching(sc))
172 return (ESHUTDOWN);
173
174 if (IAVF_CAP_ADV_LINK_SPEED(sc))
175 error = sysctl_handle_string(oidp,
176 __DECONST(char *, iavf_ext_speed_to_str(iavf_adv_speed_to_ext_speed(sc->link_speed_adv))),
177 8, req);
178 else
179 error = sysctl_handle_string(oidp,
180 __DECONST(char *, iavf_vc_speed_to_string(sc->link_speed)),
181 8, req);
182
183 return (error);
184 }
185
186 /**
187 * iavf_reset_complete - Wait for a device reset to complete
188 * @hw: pointer to the hardware structure
189 *
190 * Reads the reset registers and waits until they indicate that a device reset
191 * is complete.
192 *
193 * @pre this function may call pause() and must not be called from a context
194 * that cannot sleep.
195 *
196 * @returns zero on success, or EBUSY if it times out waiting for reset.
197 */
198 int
iavf_reset_complete(struct iavf_hw * hw)199 iavf_reset_complete(struct iavf_hw *hw)
200 {
201 u32 reg;
202
203 /* Wait up to ~10 seconds */
204 for (int i = 0; i < 100; i++) {
205 reg = rd32(hw, IAVF_VFGEN_RSTAT) &
206 IAVF_VFGEN_RSTAT_VFR_STATE_MASK;
207
208 if ((reg == VIRTCHNL_VFR_VFACTIVE) ||
209 (reg == VIRTCHNL_VFR_COMPLETED))
210 return (0);
211 iavf_msec_pause(100);
212 }
213
214 return (EBUSY);
215 }
216
217 /**
218 * iavf_setup_vc - Setup virtchnl communication
219 * @sc: device private softc
220 *
221 * iavf_attach() helper function. Initializes the admin queue and attempts to
222 * establish contact with the PF by retrying the initial "API version" message
223 * several times or until the PF responds.
224 *
225 * @returns zero on success, or an error code on failure.
226 */
227 int
iavf_setup_vc(struct iavf_sc * sc)228 iavf_setup_vc(struct iavf_sc *sc)
229 {
230 struct iavf_hw *hw = &sc->hw;
231 device_t dev = sc->dev;
232 int error = 0, ret_error = 0, asq_retries = 0;
233 bool send_api_ver_retried = 0;
234
235 /* Need to set these AQ parameters before initializing AQ */
236 hw->aq.num_arq_entries = IAVF_AQ_LEN;
237 hw->aq.num_asq_entries = IAVF_AQ_LEN;
238 hw->aq.arq_buf_size = IAVF_AQ_BUF_SZ;
239 hw->aq.asq_buf_size = IAVF_AQ_BUF_SZ;
240
241 for (int i = 0; i < IAVF_AQ_MAX_ERR; i++) {
242 /* Initialize admin queue */
243 error = iavf_init_adminq(hw);
244 if (error) {
245 device_printf(dev, "%s: init_adminq failed: %d\n",
246 __func__, error);
247 ret_error = 1;
248 continue;
249 }
250
251 iavf_dbg_init(sc, "Initialized Admin Queue; starting"
252 " send_api_ver attempt %d", i+1);
253
254 retry_send:
255 /* Send VF's API version */
256 error = iavf_send_api_ver(sc);
257 if (error) {
258 iavf_shutdown_adminq(hw);
259 ret_error = 2;
260 device_printf(dev, "%s: unable to send api"
261 " version to PF on attempt %d, error %d\n",
262 __func__, i+1, error);
263 }
264
265 asq_retries = 0;
266 while (!iavf_asq_done(hw)) {
267 if (++asq_retries > IAVF_AQ_MAX_ERR) {
268 iavf_shutdown_adminq(hw);
269 device_printf(dev, "Admin Queue timeout "
270 "(waiting for send_api_ver), %d more tries...\n",
271 IAVF_AQ_MAX_ERR - (i + 1));
272 ret_error = 3;
273 break;
274 }
275 iavf_msec_pause(10);
276 }
277 if (asq_retries > IAVF_AQ_MAX_ERR)
278 continue;
279
280 iavf_dbg_init(sc, "Sent API version message to PF");
281
282 /* Verify that the VF accepts the PF's API version */
283 error = iavf_verify_api_ver(sc);
284 if (error == ETIMEDOUT) {
285 if (!send_api_ver_retried) {
286 /* Resend message, one more time */
287 send_api_ver_retried = true;
288 device_printf(dev,
289 "%s: Timeout while verifying API version on first"
290 " try!\n", __func__);
291 goto retry_send;
292 } else {
293 device_printf(dev,
294 "%s: Timeout while verifying API version on second"
295 " try!\n", __func__);
296 ret_error = 4;
297 break;
298 }
299 }
300 if (error) {
301 device_printf(dev,
302 "%s: Unable to verify API version,"
303 " error %d\n", __func__, error);
304 ret_error = 5;
305 }
306 break;
307 }
308
309 if (ret_error >= 4)
310 iavf_shutdown_adminq(hw);
311 return (ret_error);
312 }
313
314 /**
315 * iavf_reset - Requests a VF reset from the PF.
316 * @sc: device private softc
317 *
318 * @pre Requires the VF's Admin Queue to be initialized.
319 * @returns zero on success, or an error code on failure.
320 */
321 int
iavf_reset(struct iavf_sc * sc)322 iavf_reset(struct iavf_sc *sc)
323 {
324 struct iavf_hw *hw = &sc->hw;
325 device_t dev = sc->dev;
326 int error = 0;
327
328 /* Ask the PF to reset us if we are initiating */
329 if (!iavf_test_state(&sc->state, IAVF_STATE_RESET_PENDING))
330 iavf_request_reset(sc);
331
332 iavf_msec_pause(100);
333 error = iavf_reset_complete(hw);
334 if (error) {
335 device_printf(dev, "%s: VF reset failed\n",
336 __func__);
337 return (error);
338 }
339 pci_enable_busmaster(dev);
340
341 error = iavf_shutdown_adminq(hw);
342 if (error) {
343 device_printf(dev, "%s: shutdown_adminq failed: %d\n",
344 __func__, error);
345 return (error);
346 }
347
348 error = iavf_init_adminq(hw);
349 if (error) {
350 device_printf(dev, "%s: init_adminq failed: %d\n",
351 __func__, error);
352 return (error);
353 }
354
355 /* IFLIB: This is called only in the iflib driver */
356 iavf_enable_adminq_irq(hw);
357 return (0);
358 }
359
360 /**
361 * iavf_enable_admin_irq - Enable the administrative interrupt
362 * @hw: pointer to the hardware structure
363 *
364 * Writes to registers to enable the administrative interrupt cause, in order
365 * to handle non-queue related interrupt events.
366 */
367 void
iavf_enable_adminq_irq(struct iavf_hw * hw)368 iavf_enable_adminq_irq(struct iavf_hw *hw)
369 {
370 wr32(hw, IAVF_VFINT_DYN_CTL01,
371 IAVF_VFINT_DYN_CTL01_INTENA_MASK |
372 IAVF_VFINT_DYN_CTL01_CLEARPBA_MASK |
373 IAVF_VFINT_DYN_CTL01_ITR_INDX_MASK);
374 wr32(hw, IAVF_VFINT_ICR0_ENA1, IAVF_VFINT_ICR0_ENA1_ADMINQ_MASK);
375 /* flush */
376 rd32(hw, IAVF_VFGEN_RSTAT);
377 }
378
379 /**
380 * iavf_disable_admin_irq - Disable the administrative interrupt cause
381 * @hw: pointer to the hardware structure
382 *
383 * Writes to registers to disable the administrative interrupt cause.
384 */
385 void
iavf_disable_adminq_irq(struct iavf_hw * hw)386 iavf_disable_adminq_irq(struct iavf_hw *hw)
387 {
388 wr32(hw, IAVF_VFINT_DYN_CTL01, 0);
389 wr32(hw, IAVF_VFINT_ICR0_ENA1, 0);
390 iavf_flush(hw);
391 }
392
393 /**
394 * iavf_vf_config - Configure this VF over the virtchnl
395 * @sc: device private softc
396 *
397 * iavf_attach() helper function. Asks the PF for this VF's configuration, and
398 * saves the information if it receives it.
399 *
400 * @returns zero on success, or an error code on failure.
401 */
402 int
iavf_vf_config(struct iavf_sc * sc)403 iavf_vf_config(struct iavf_sc *sc)
404 {
405 struct iavf_hw *hw = &sc->hw;
406 device_t dev = sc->dev;
407 int bufsz, error = 0, ret_error = 0;
408 int asq_retries, retried = 0;
409
410 retry_config:
411 error = iavf_send_vf_config_msg(sc);
412 if (error) {
413 device_printf(dev,
414 "%s: Unable to send VF config request, attempt %d,"
415 " error %d\n", __func__, retried + 1, error);
416 ret_error = 2;
417 }
418
419 asq_retries = 0;
420 while (!iavf_asq_done(hw)) {
421 if (++asq_retries > IAVF_AQ_MAX_ERR) {
422 device_printf(dev, "%s: Admin Queue timeout "
423 "(waiting for send_vf_config_msg), attempt %d\n",
424 __func__, retried + 1);
425 ret_error = 3;
426 goto fail;
427 }
428 iavf_msec_pause(10);
429 }
430
431 iavf_dbg_init(sc, "Sent VF config message to PF, attempt %d\n",
432 retried + 1);
433
434 if (!sc->vf_res) {
435 bufsz = sizeof(struct virtchnl_vf_resource) +
436 (IAVF_MAX_VF_VSI * sizeof(struct virtchnl_vsi_resource));
437 sc->vf_res = (struct virtchnl_vf_resource *)malloc(bufsz, M_IAVF, M_NOWAIT);
438 if (!sc->vf_res) {
439 device_printf(dev,
440 "%s: Unable to allocate memory for VF configuration"
441 " message from PF on attempt %d\n", __func__, retried + 1);
442 ret_error = 1;
443 goto fail;
444 }
445 }
446
447 /* Check for VF config response */
448 error = iavf_get_vf_config(sc);
449 if (error == ETIMEDOUT) {
450 /* The 1st time we timeout, send the configuration message again */
451 if (!retried) {
452 retried++;
453 goto retry_config;
454 }
455 device_printf(dev,
456 "%s: iavf_get_vf_config() timed out waiting for a response\n",
457 __func__);
458 }
459 if (error) {
460 device_printf(dev,
461 "%s: Unable to get VF configuration from PF after %d tries!\n",
462 __func__, retried + 1);
463 ret_error = 4;
464 }
465 goto done;
466
467 fail:
468 free(sc->vf_res, M_IAVF);
469 done:
470 return (ret_error);
471 }
472
473 /**
474 * iavf_print_device_info - Print some device parameters at attach
475 * @sc: device private softc
476 *
477 * Log a message about this virtual device's capabilities at attach time.
478 */
479 void
iavf_print_device_info(struct iavf_sc * sc)480 iavf_print_device_info(struct iavf_sc *sc)
481 {
482 device_t dev = sc->dev;
483
484 device_printf(dev,
485 "VSIs %d, QPs %d, MSI-X %d, RSS sizes: key %d lut %d\n",
486 sc->vf_res->num_vsis,
487 sc->vf_res->num_queue_pairs,
488 sc->vf_res->max_vectors,
489 sc->vf_res->rss_key_size,
490 sc->vf_res->rss_lut_size);
491 iavf_dbg_info(sc, "Capabilities=%b\n",
492 sc->vf_res->vf_cap_flags, IAVF_PRINTF_VF_OFFLOAD_FLAGS);
493 }
494
495 /**
496 * iavf_get_vsi_res_from_vf_res - Get VSI parameters and info for this VF
497 * @sc: device private softc
498 *
499 * Get the VSI parameters and information from the general VF resource info
500 * received by the physical device.
501 *
502 * @returns zero on success, or an error code on failure.
503 */
504 int
iavf_get_vsi_res_from_vf_res(struct iavf_sc * sc)505 iavf_get_vsi_res_from_vf_res(struct iavf_sc *sc)
506 {
507 struct iavf_vsi *vsi = &sc->vsi;
508 device_t dev = sc->dev;
509
510 sc->vsi_res = NULL;
511
512 for (int i = 0; i < sc->vf_res->num_vsis; i++) {
513 /* XXX: We only use the first VSI we find */
514 if (sc->vf_res->vsi_res[i].vsi_type == VIRTCHNL_VSI_SRIOV)
515 sc->vsi_res = &sc->vf_res->vsi_res[i];
516 }
517 if (!sc->vsi_res) {
518 device_printf(dev, "%s: no LAN VSI found\n", __func__);
519 return (EIO);
520 }
521
522 vsi->id = sc->vsi_res->vsi_id;
523 return (0);
524 }
525
526 /**
527 * iavf_set_mac_addresses - Set the MAC address for this interface
528 * @sc: device private softc
529 *
530 * Set the permanent MAC address field in the HW structure. If a MAC address
531 * has not yet been set for this device by the physical function, generate one
532 * randomly.
533 */
534 void
iavf_set_mac_addresses(struct iavf_sc * sc)535 iavf_set_mac_addresses(struct iavf_sc *sc)
536 {
537 struct iavf_hw *hw = &sc->hw;
538 device_t dev = sc->dev;
539 u8 addr[ETHER_ADDR_LEN];
540
541 /* If no mac address was assigned just make a random one */
542 if (ETHER_IS_ZERO(hw->mac.addr)) {
543 arc4rand(&addr, sizeof(addr), 0);
544 addr[0] &= 0xFE;
545 addr[0] |= 0x02;
546 memcpy(hw->mac.addr, addr, sizeof(addr));
547 device_printf(dev, "Generated random MAC address\n");
548 }
549 memcpy(hw->mac.perm_addr, hw->mac.addr, ETHER_ADDR_LEN);
550 }
551
552 /**
553 * iavf_init_filters - Initialize filter structures
554 * @sc: device private softc
555 *
556 * Initialize the MAC and VLAN filter list heads.
557 *
558 * @remark this is intended to be called only once during the device attach
559 * process.
560 *
561 * @pre Because it uses M_WAITOK, this function should only be called in
562 * a context that is safe to sleep.
563 */
564 void
iavf_init_filters(struct iavf_sc * sc)565 iavf_init_filters(struct iavf_sc *sc)
566 {
567 sc->mac_filters = (struct mac_list *)malloc(sizeof(struct iavf_mac_filter),
568 M_IAVF, M_WAITOK | M_ZERO);
569 SLIST_INIT(sc->mac_filters);
570 sc->vlan_filters = (struct vlan_list *)malloc(sizeof(struct iavf_vlan_filter),
571 M_IAVF, M_WAITOK | M_ZERO);
572 SLIST_INIT(sc->vlan_filters);
573 }
574
575 /**
576 * iavf_free_filters - Release filter lists
577 * @sc: device private softc
578 *
579 * Free the MAC and VLAN filter lists.
580 *
581 * @remark this is intended to be called only once during the device detach
582 * process.
583 */
584 void
iavf_free_filters(struct iavf_sc * sc)585 iavf_free_filters(struct iavf_sc *sc)
586 {
587 struct iavf_mac_filter *f;
588 struct iavf_vlan_filter *v;
589
590 while (!SLIST_EMPTY(sc->mac_filters)) {
591 f = SLIST_FIRST(sc->mac_filters);
592 SLIST_REMOVE_HEAD(sc->mac_filters, next);
593 free(f, M_IAVF);
594 }
595 free(sc->mac_filters, M_IAVF);
596 while (!SLIST_EMPTY(sc->vlan_filters)) {
597 v = SLIST_FIRST(sc->vlan_filters);
598 SLIST_REMOVE_HEAD(sc->vlan_filters, next);
599 free(v, M_IAVF);
600 }
601 free(sc->vlan_filters, M_IAVF);
602 }
603
604 /**
605 * iavf_add_device_sysctls_common - Initialize common device sysctls
606 * @sc: device private softc
607 *
608 * Setup sysctls common to both the iflib and legacy drivers.
609 */
610 void
iavf_add_device_sysctls_common(struct iavf_sc * sc)611 iavf_add_device_sysctls_common(struct iavf_sc *sc)
612 {
613 device_t dev = sc->dev;
614 struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(dev);
615 struct sysctl_oid_list *ctx_list =
616 SYSCTL_CHILDREN(device_get_sysctl_tree(dev));
617
618 SYSCTL_ADD_PROC(ctx, ctx_list,
619 OID_AUTO, "current_speed", CTLTYPE_STRING | CTLFLAG_RD,
620 sc, 0, iavf_sysctl_current_speed, "A", "Current Port Speed");
621
622 SYSCTL_ADD_PROC(ctx, ctx_list,
623 OID_AUTO, "tx_itr", CTLTYPE_INT | CTLFLAG_RW,
624 sc, 0, iavf_sysctl_tx_itr, "I",
625 "Immediately set TX ITR value for all queues");
626
627 SYSCTL_ADD_PROC(ctx, ctx_list,
628 OID_AUTO, "rx_itr", CTLTYPE_INT | CTLFLAG_RW,
629 sc, 0, iavf_sysctl_rx_itr, "I",
630 "Immediately set RX ITR value for all queues");
631
632 SYSCTL_ADD_UQUAD(ctx, ctx_list,
633 OID_AUTO, "admin_irq", CTLFLAG_RD,
634 &sc->admin_irq, "Admin Queue IRQ Handled");
635 }
636
637 /**
638 * iavf_add_debug_sysctls_common - Initialize common debug sysctls
639 * @sc: device private softc
640 * @debug_list: pionter to debug sysctl node
641 *
642 * Setup sysctls used for debugging the device driver into the debug sysctl
643 * node.
644 */
645 void
iavf_add_debug_sysctls_common(struct iavf_sc * sc,struct sysctl_oid_list * debug_list)646 iavf_add_debug_sysctls_common(struct iavf_sc *sc, struct sysctl_oid_list *debug_list)
647 {
648 device_t dev = sc->dev;
649 struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(dev);
650
651 SYSCTL_ADD_UINT(ctx, debug_list,
652 OID_AUTO, "shared_debug_mask", CTLFLAG_RW,
653 &sc->hw.debug_mask, 0, "Shared code debug message level");
654
655 SYSCTL_ADD_UINT(ctx, debug_list,
656 OID_AUTO, "core_debug_mask", CTLFLAG_RW,
657 (unsigned int *)&sc->dbg_mask, 0, "Non-shared code debug message level");
658
659 SYSCTL_ADD_PROC(ctx, debug_list,
660 OID_AUTO, "filter_list", CTLTYPE_STRING | CTLFLAG_RD,
661 sc, 0, iavf_sysctl_sw_filter_list, "A", "SW Filter List");
662 }
663
664 /**
665 * iavf_sysctl_tx_itr - Sysctl to set the Tx ITR value
666 * @oidp: sysctl oid pointer
667 * @arg1: pointer to the device softc
668 * @arg2: unused sysctl argument
669 * @req: sysctl req pointer
670 *
671 * On read, returns the Tx ITR value for all of the VF queues. On write,
672 * update the Tx ITR registers with the new Tx ITR value.
673 *
674 * @returns zero on success, or an error code on failure.
675 */
676 int
iavf_sysctl_tx_itr(SYSCTL_HANDLER_ARGS)677 iavf_sysctl_tx_itr(SYSCTL_HANDLER_ARGS)
678 {
679 struct iavf_sc *sc = (struct iavf_sc *)arg1;
680 device_t dev = sc->dev;
681 int requested_tx_itr;
682 int error = 0;
683
684 UNREFERENCED_PARAMETER(arg2);
685
686 if (iavf_driver_is_detaching(sc))
687 return (ESHUTDOWN);
688
689 requested_tx_itr = sc->tx_itr;
690 error = sysctl_handle_int(oidp, &requested_tx_itr, 0, req);
691 if ((error) || (req->newptr == NULL))
692 return (error);
693 if (requested_tx_itr < 0 || requested_tx_itr > IAVF_MAX_ITR) {
694 device_printf(dev,
695 "Invalid TX itr value; value must be between 0 and %d\n",
696 IAVF_MAX_ITR);
697 return (EINVAL);
698 }
699
700 sc->tx_itr = requested_tx_itr;
701 iavf_configure_tx_itr(sc);
702
703 return (error);
704 }
705
706 /**
707 * iavf_sysctl_rx_itr - Sysctl to set the Rx ITR value
708 * @oidp: sysctl oid pointer
709 * @arg1: pointer to the device softc
710 * @arg2: unused sysctl argument
711 * @req: sysctl req pointer
712 *
713 * On read, returns the Rx ITR value for all of the VF queues. On write,
714 * update the ITR registers with the new Rx ITR value.
715 *
716 * @returns zero on success, or an error code on failure.
717 */
718 int
iavf_sysctl_rx_itr(SYSCTL_HANDLER_ARGS)719 iavf_sysctl_rx_itr(SYSCTL_HANDLER_ARGS)
720 {
721 struct iavf_sc *sc = (struct iavf_sc *)arg1;
722 device_t dev = sc->dev;
723 int requested_rx_itr;
724 int error = 0;
725
726 UNREFERENCED_PARAMETER(arg2);
727
728 if (iavf_driver_is_detaching(sc))
729 return (ESHUTDOWN);
730
731 requested_rx_itr = sc->rx_itr;
732 error = sysctl_handle_int(oidp, &requested_rx_itr, 0, req);
733 if ((error) || (req->newptr == NULL))
734 return (error);
735 if (requested_rx_itr < 0 || requested_rx_itr > IAVF_MAX_ITR) {
736 device_printf(dev,
737 "Invalid RX itr value; value must be between 0 and %d\n",
738 IAVF_MAX_ITR);
739 return (EINVAL);
740 }
741
742 sc->rx_itr = requested_rx_itr;
743 iavf_configure_rx_itr(sc);
744
745 return (error);
746 }
747
748 /**
749 * iavf_configure_tx_itr - Configure the Tx ITR
750 * @sc: device private softc
751 *
752 * Updates the ITR registers with a new Tx ITR setting.
753 */
754 void
iavf_configure_tx_itr(struct iavf_sc * sc)755 iavf_configure_tx_itr(struct iavf_sc *sc)
756 {
757 struct iavf_hw *hw = &sc->hw;
758 struct iavf_vsi *vsi = &sc->vsi;
759 struct iavf_tx_queue *que = vsi->tx_queues;
760
761 vsi->tx_itr_setting = sc->tx_itr;
762
763 for (int i = 0; i < IAVF_NTXQS(vsi); i++, que++) {
764 struct tx_ring *txr = &que->txr;
765
766 wr32(hw, IAVF_VFINT_ITRN1(IAVF_TX_ITR, i),
767 vsi->tx_itr_setting);
768 txr->itr = vsi->tx_itr_setting;
769 txr->latency = IAVF_AVE_LATENCY;
770 }
771 }
772
773 /**
774 * iavf_configure_rx_itr - Configure the Rx ITR
775 * @sc: device private softc
776 *
777 * Updates the ITR registers with a new Rx ITR setting.
778 */
779 void
iavf_configure_rx_itr(struct iavf_sc * sc)780 iavf_configure_rx_itr(struct iavf_sc *sc)
781 {
782 struct iavf_hw *hw = &sc->hw;
783 struct iavf_vsi *vsi = &sc->vsi;
784 struct iavf_rx_queue *que = vsi->rx_queues;
785
786 vsi->rx_itr_setting = sc->rx_itr;
787
788 for (int i = 0; i < IAVF_NRXQS(vsi); i++, que++) {
789 struct rx_ring *rxr = &que->rxr;
790
791 wr32(hw, IAVF_VFINT_ITRN1(IAVF_RX_ITR, i),
792 vsi->rx_itr_setting);
793 rxr->itr = vsi->rx_itr_setting;
794 rxr->latency = IAVF_AVE_LATENCY;
795 }
796 }
797
798 /**
799 * iavf_create_debug_sysctl_tree - Create a debug sysctl node
800 * @sc: device private softc
801 *
802 * Create a sysctl node meant to hold sysctls used to print debug information.
803 * Mark it as CTLFLAG_SKIP so that these sysctls do not show up in the
804 * "sysctl -a" output.
805 *
806 * @returns a pointer to the created sysctl node.
807 */
808 struct sysctl_oid_list *
iavf_create_debug_sysctl_tree(struct iavf_sc * sc)809 iavf_create_debug_sysctl_tree(struct iavf_sc *sc)
810 {
811 device_t dev = sc->dev;
812 struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(dev);
813 struct sysctl_oid_list *ctx_list =
814 SYSCTL_CHILDREN(device_get_sysctl_tree(dev));
815 struct sysctl_oid *debug_node;
816
817 debug_node = SYSCTL_ADD_NODE(ctx, ctx_list,
818 OID_AUTO, "debug", CTLFLAG_RD | CTLFLAG_SKIP, NULL, "Debug Sysctls");
819
820 return (SYSCTL_CHILDREN(debug_node));
821 }
822
823 /**
824 * iavf_add_vsi_sysctls - Add sysctls for a given VSI
825 * @dev: device pointer
826 * @vsi: pointer to the VSI
827 * @ctx: sysctl context to add to
828 * @sysctl_name: name of the sysctl node (containing the VSI number)
829 *
830 * Adds a new sysctl node for holding specific sysctls for the given VSI.
831 */
832 void
iavf_add_vsi_sysctls(device_t dev,struct iavf_vsi * vsi,struct sysctl_ctx_list * ctx,const char * sysctl_name)833 iavf_add_vsi_sysctls(device_t dev, struct iavf_vsi *vsi,
834 struct sysctl_ctx_list *ctx, const char *sysctl_name)
835 {
836 struct sysctl_oid *tree;
837 struct sysctl_oid_list *child;
838 struct sysctl_oid_list *vsi_list;
839
840 tree = device_get_sysctl_tree(dev);
841 child = SYSCTL_CHILDREN(tree);
842 vsi->vsi_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, sysctl_name,
843 CTLFLAG_RD, NULL, "VSI Number");
844 vsi_list = SYSCTL_CHILDREN(vsi->vsi_node);
845
846 iavf_add_sysctls_eth_stats(ctx, vsi_list, &vsi->eth_stats);
847 }
848
849 /**
850 * iavf_sysctl_sw_filter_list - Dump software filters
851 * @oidp: sysctl oid pointer
852 * @arg1: pointer to the device softc
853 * @arg2: unused sysctl argument
854 * @req: sysctl req pointer
855 *
856 * On read, generates a string which lists the MAC and VLAN filters added to
857 * this virtual device. Useful for debugging to see whether or not the
858 * expected filters have been configured by software.
859 *
860 * @returns zero on success, or an error code on failure.
861 */
862 int
iavf_sysctl_sw_filter_list(SYSCTL_HANDLER_ARGS)863 iavf_sysctl_sw_filter_list(SYSCTL_HANDLER_ARGS)
864 {
865 struct iavf_sc *sc = (struct iavf_sc *)arg1;
866 struct iavf_mac_filter *f;
867 struct iavf_vlan_filter *v;
868 device_t dev = sc->dev;
869 int ftl_len, ftl_counter = 0, error = 0;
870 struct sbuf *buf;
871
872 UNREFERENCED_2PARAMETER(arg2, oidp);
873
874 if (iavf_driver_is_detaching(sc))
875 return (ESHUTDOWN);
876
877 buf = sbuf_new_for_sysctl(NULL, NULL, 128, req);
878 if (!buf) {
879 device_printf(dev, "Could not allocate sbuf for output.\n");
880 return (ENOMEM);
881 }
882
883 sbuf_printf(buf, "\n");
884
885 /* Print MAC filters */
886 sbuf_printf(buf, "MAC Filters:\n");
887 ftl_len = 0;
888 SLIST_FOREACH(f, sc->mac_filters, next)
889 ftl_len++;
890 if (ftl_len < 1)
891 sbuf_printf(buf, "(none)\n");
892 else {
893 SLIST_FOREACH(f, sc->mac_filters, next) {
894 sbuf_printf(buf,
895 MAC_FORMAT ", flags %#06x\n",
896 MAC_FORMAT_ARGS(f->macaddr), f->flags);
897 }
898 }
899
900 /* Print VLAN filters */
901 sbuf_printf(buf, "VLAN Filters:\n");
902 ftl_len = 0;
903 SLIST_FOREACH(v, sc->vlan_filters, next)
904 ftl_len++;
905 if (ftl_len < 1)
906 sbuf_printf(buf, "(none)");
907 else {
908 SLIST_FOREACH(v, sc->vlan_filters, next) {
909 sbuf_printf(buf,
910 "%d, flags %#06x",
911 v->vlan, v->flags);
912 /* don't print '\n' for last entry */
913 if (++ftl_counter != ftl_len)
914 sbuf_printf(buf, "\n");
915 }
916 }
917
918 error = sbuf_finish(buf);
919 if (error)
920 device_printf(dev, "Error finishing sbuf: %d\n", error);
921
922 sbuf_delete(buf);
923 return (error);
924 }
925
926 /**
927 * iavf_media_status_common - Get media status for this device
928 * @sc: device softc pointer
929 * @ifmr: ifmedia request structure
930 *
931 * Report the media status for this device into the given ifmr structure.
932 */
933 void
iavf_media_status_common(struct iavf_sc * sc,struct ifmediareq * ifmr)934 iavf_media_status_common(struct iavf_sc *sc, struct ifmediareq *ifmr)
935 {
936 enum iavf_ext_link_speed ext_speed;
937
938 iavf_update_link_status(sc);
939
940 ifmr->ifm_status = IFM_AVALID;
941 ifmr->ifm_active = IFM_ETHER;
942
943 if (!sc->link_up)
944 return;
945
946 ifmr->ifm_status |= IFM_ACTIVE;
947 /* Hardware is always full-duplex */
948 ifmr->ifm_active |= IFM_FDX;
949
950 /* Based on the link speed reported by the PF over the AdminQ, choose a
951 * PHY type to report. This isn't 100% correct since we don't really
952 * know the underlying PHY type of the PF, but at least we can report
953 * a valid link speed...
954 */
955 if (IAVF_CAP_ADV_LINK_SPEED(sc))
956 ext_speed = iavf_adv_speed_to_ext_speed(sc->link_speed_adv);
957 else
958 ext_speed = iavf_vc_speed_to_ext_speed(sc->link_speed);
959
960 ifmr->ifm_active |= iavf_ext_speed_to_ifmedia(ext_speed);
961 }
962
963 /**
964 * iavf_media_change_common - Change the media type for this device
965 * @ifp: ifnet structure
966 *
967 * @returns ENODEV because changing the media and speed is not supported.
968 */
969 int
iavf_media_change_common(if_t ifp)970 iavf_media_change_common(if_t ifp)
971 {
972 if_printf(ifp, "Changing speed is not supported\n");
973
974 return (ENODEV);
975 }
976
977 /**
978 * iavf_set_initial_baudrate - Set the initial device baudrate
979 * @ifp: ifnet structure
980 *
981 * Set the baudrate for this ifnet structure to the expected initial value of
982 * 40Gbps. This maybe updated to a lower baudrate after the physical function
983 * reports speed to us over the virtchnl interface.
984 */
985 void
iavf_set_initial_baudrate(if_t ifp)986 iavf_set_initial_baudrate(if_t ifp)
987 {
988 if_setbaudrate(ifp, IF_Gbps(40));
989 }
990
991 /**
992 * iavf_add_sysctls_eth_stats - Add ethernet statistics sysctls
993 * @ctx: the sysctl ctx to add to
994 * @child: the node to add the sysctls to
995 * @eth_stats: ethernet stats structure
996 *
997 * Creates sysctls that report the values of the provided ethernet stats
998 * structure.
999 */
1000 void
iavf_add_sysctls_eth_stats(struct sysctl_ctx_list * ctx,struct sysctl_oid_list * child,struct iavf_eth_stats * eth_stats)1001 iavf_add_sysctls_eth_stats(struct sysctl_ctx_list *ctx,
1002 struct sysctl_oid_list *child,
1003 struct iavf_eth_stats *eth_stats)
1004 {
1005 struct iavf_sysctl_info ctls[] =
1006 {
1007 {ð_stats->rx_bytes, "good_octets_rcvd", "Good Octets Received"},
1008 {ð_stats->rx_unicast, "ucast_pkts_rcvd",
1009 "Unicast Packets Received"},
1010 {ð_stats->rx_multicast, "mcast_pkts_rcvd",
1011 "Multicast Packets Received"},
1012 {ð_stats->rx_broadcast, "bcast_pkts_rcvd",
1013 "Broadcast Packets Received"},
1014 {ð_stats->rx_discards, "rx_discards", "Discarded RX packets"},
1015 {ð_stats->rx_unknown_protocol, "rx_unknown_proto",
1016 "RX unknown protocol packets"},
1017 {ð_stats->tx_bytes, "good_octets_txd", "Good Octets Transmitted"},
1018 {ð_stats->tx_unicast, "ucast_pkts_txd", "Unicast Packets Transmitted"},
1019 {ð_stats->tx_multicast, "mcast_pkts_txd",
1020 "Multicast Packets Transmitted"},
1021 {ð_stats->tx_broadcast, "bcast_pkts_txd",
1022 "Broadcast Packets Transmitted"},
1023 {ð_stats->tx_errors, "tx_errors", "TX packet errors"},
1024 // end
1025 {0,0,0}
1026 };
1027
1028 struct iavf_sysctl_info *entry = ctls;
1029
1030 while (entry->stat != 0)
1031 {
1032 SYSCTL_ADD_UQUAD(ctx, child, OID_AUTO, entry->name,
1033 CTLFLAG_RD, entry->stat,
1034 entry->description);
1035 entry++;
1036 }
1037 }
1038
1039 /**
1040 * iavf_max_vc_speed_to_value - Convert link speed to IF speed value
1041 * @link_speeds: bitmap of supported link speeds
1042 *
1043 * @returns the link speed value for the highest speed reported in the
1044 * link_speeds bitmap.
1045 */
1046 u64
iavf_max_vc_speed_to_value(u8 link_speeds)1047 iavf_max_vc_speed_to_value(u8 link_speeds)
1048 {
1049 if (link_speeds & VIRTCHNL_LINK_SPEED_40GB)
1050 return IF_Gbps(40);
1051 if (link_speeds & VIRTCHNL_LINK_SPEED_25GB)
1052 return IF_Gbps(25);
1053 if (link_speeds & VIRTCHNL_LINK_SPEED_20GB)
1054 return IF_Gbps(20);
1055 if (link_speeds & VIRTCHNL_LINK_SPEED_10GB)
1056 return IF_Gbps(10);
1057 if (link_speeds & VIRTCHNL_LINK_SPEED_1GB)
1058 return IF_Gbps(1);
1059 if (link_speeds & VIRTCHNL_LINK_SPEED_100MB)
1060 return IF_Mbps(100);
1061 else
1062 /* Minimum supported link speed */
1063 return IF_Mbps(100);
1064 }
1065
1066 /**
1067 * iavf_config_rss_reg - Configure RSS using registers
1068 * @sc: device private softc
1069 *
1070 * Configures RSS for this function using the device registers. Called if the
1071 * PF does not support configuring RSS over the virtchnl interface.
1072 */
1073 void
iavf_config_rss_reg(struct iavf_sc * sc)1074 iavf_config_rss_reg(struct iavf_sc *sc)
1075 {
1076 struct iavf_hw *hw = &sc->hw;
1077 struct iavf_vsi *vsi = &sc->vsi;
1078 u32 lut = 0;
1079 u64 set_hena = 0, hena;
1080 int i, j, que_id;
1081 u32 rss_seed[IAVF_RSS_KEY_SIZE_REG];
1082 u32 rss_hash_config;
1083
1084 /* Don't set up RSS if using a single queue */
1085 if (IAVF_NRXQS(vsi) == 1) {
1086 wr32(hw, IAVF_VFQF_HENA(0), 0);
1087 wr32(hw, IAVF_VFQF_HENA(1), 0);
1088 iavf_flush(hw);
1089 return;
1090 }
1091
1092 /* Fetch the configured RSS key */
1093 rss_getkey((uint8_t *) &rss_seed);
1094
1095 /* Fill out hash function seed */
1096 for (i = 0; i < IAVF_RSS_KEY_SIZE_REG; i++)
1097 wr32(hw, IAVF_VFQF_HKEY(i), rss_seed[i]);
1098
1099 /* Enable PCTYPES for RSS: */
1100 rss_hash_config = rss_gethashconfig();
1101 if (rss_hash_config & RSS_HASHTYPE_RSS_IPV4)
1102 set_hena |= ((u64)1 << IAVF_FILTER_PCTYPE_NONF_IPV4_OTHER);
1103 if (rss_hash_config & RSS_HASHTYPE_RSS_TCP_IPV4)
1104 set_hena |= ((u64)1 << IAVF_FILTER_PCTYPE_NONF_IPV4_TCP);
1105 if (rss_hash_config & RSS_HASHTYPE_RSS_UDP_IPV4)
1106 set_hena |= ((u64)1 << IAVF_FILTER_PCTYPE_NONF_IPV4_UDP);
1107 if (rss_hash_config & RSS_HASHTYPE_RSS_IPV6)
1108 set_hena |= ((u64)1 << IAVF_FILTER_PCTYPE_NONF_IPV6_OTHER);
1109 if (rss_hash_config & RSS_HASHTYPE_RSS_IPV6_EX)
1110 set_hena |= ((u64)1 << IAVF_FILTER_PCTYPE_FRAG_IPV6);
1111 if (rss_hash_config & RSS_HASHTYPE_RSS_TCP_IPV6)
1112 set_hena |= ((u64)1 << IAVF_FILTER_PCTYPE_NONF_IPV6_TCP);
1113 if (rss_hash_config & RSS_HASHTYPE_RSS_UDP_IPV6)
1114 set_hena |= ((u64)1 << IAVF_FILTER_PCTYPE_NONF_IPV6_UDP);
1115 hena = (u64)rd32(hw, IAVF_VFQF_HENA(0)) |
1116 ((u64)rd32(hw, IAVF_VFQF_HENA(1)) << 32);
1117 hena |= set_hena;
1118 wr32(hw, IAVF_VFQF_HENA(0), (u32)hena);
1119 wr32(hw, IAVF_VFQF_HENA(1), (u32)(hena >> 32));
1120
1121 /* Populate the LUT with max no. of queues in round robin fashion */
1122 for (i = 0, j = 0; i < IAVF_RSS_VSI_LUT_SIZE; i++, j++) {
1123 if (j == IAVF_NRXQS(vsi))
1124 j = 0;
1125 #ifdef RSS
1126 /*
1127 * Fetch the RSS bucket id for the given indirection entry.
1128 * Cap it at the number of configured buckets (which is
1129 * num_rx_queues.)
1130 */
1131 que_id = rss_get_indirection_to_bucket(i);
1132 que_id = que_id % IAVF_NRXQS(vsi);
1133 #else
1134 que_id = j;
1135 #endif
1136 /* lut = 4-byte sliding window of 4 lut entries */
1137 lut = (lut << 8) | (que_id & IAVF_RSS_VF_LUT_ENTRY_MASK);
1138 /* On i = 3, we have 4 entries in lut; write to the register */
1139 if ((i & 3) == 3) {
1140 wr32(hw, IAVF_VFQF_HLUT(i >> 2), lut);
1141 iavf_dbg_rss(sc, "%s: HLUT(%2d): %#010x", __func__,
1142 i, lut);
1143 }
1144 }
1145 iavf_flush(hw);
1146 }
1147
1148 /**
1149 * iavf_config_rss_pf - Configure RSS using PF virtchnl messages
1150 * @sc: device private softc
1151 *
1152 * Configure RSS by sending virtchnl messages to the PF.
1153 */
1154 void
iavf_config_rss_pf(struct iavf_sc * sc)1155 iavf_config_rss_pf(struct iavf_sc *sc)
1156 {
1157 iavf_send_vc_msg(sc, IAVF_FLAG_AQ_CONFIG_RSS_KEY);
1158
1159 iavf_send_vc_msg(sc, IAVF_FLAG_AQ_SET_RSS_HENA);
1160
1161 iavf_send_vc_msg(sc, IAVF_FLAG_AQ_CONFIG_RSS_LUT);
1162 }
1163
1164 /**
1165 * iavf_config_rss - setup RSS
1166 * @sc: device private softc
1167 *
1168 * Configures RSS using the method determined by capability flags in the VF
1169 * resources structure sent from the PF over the virtchnl interface.
1170 *
1171 * @remark RSS keys and table are cleared on VF reset.
1172 */
1173 void
iavf_config_rss(struct iavf_sc * sc)1174 iavf_config_rss(struct iavf_sc *sc)
1175 {
1176 if (sc->vf_res->vf_cap_flags & VIRTCHNL_VF_OFFLOAD_RSS_REG) {
1177 iavf_dbg_info(sc, "Setting up RSS using VF registers...\n");
1178 iavf_config_rss_reg(sc);
1179 } else if (sc->vf_res->vf_cap_flags & VIRTCHNL_VF_OFFLOAD_RSS_PF) {
1180 iavf_dbg_info(sc, "Setting up RSS using messages to PF...\n");
1181 iavf_config_rss_pf(sc);
1182 } else
1183 device_printf(sc->dev, "VF does not support RSS capability sent by PF.\n");
1184 }
1185
1186 /**
1187 * iavf_config_promisc - setup promiscuous mode
1188 * @sc: device private softc
1189 * @flags: promiscuous flags to configure
1190 *
1191 * Request that promiscuous modes be enabled from the PF
1192 *
1193 * @returns zero on success, or an error code on failure.
1194 */
1195 int
iavf_config_promisc(struct iavf_sc * sc,int flags)1196 iavf_config_promisc(struct iavf_sc *sc, int flags)
1197 {
1198 if_t ifp = sc->vsi.ifp;
1199
1200 sc->promisc_flags = 0;
1201
1202 if (flags & IFF_ALLMULTI ||
1203 if_llmaddr_count(ifp) == MAX_MULTICAST_ADDR)
1204 sc->promisc_flags |= FLAG_VF_MULTICAST_PROMISC;
1205 if (flags & IFF_PROMISC)
1206 sc->promisc_flags |= FLAG_VF_UNICAST_PROMISC;
1207
1208 iavf_send_vc_msg(sc, IAVF_FLAG_AQ_CONFIGURE_PROMISC);
1209
1210 return (0);
1211 }
1212
1213 /**
1214 * iavf_mc_filter_apply - Program a MAC filter for this VF
1215 * @arg: pointer to the device softc
1216 * @sdl: MAC multicast address
1217 * @cnt: unused parameter
1218 *
1219 * Program a MAC address multicast filter for this device. Intended
1220 * to be used with the map-like function if_foreach_llmaddr().
1221 *
1222 * @returns 1 on success, or 0 on failure
1223 */
1224 static u_int
iavf_mc_filter_apply(void * arg,struct sockaddr_dl * sdl,u_int cnt __unused)1225 iavf_mc_filter_apply(void *arg, struct sockaddr_dl *sdl, u_int cnt __unused)
1226 {
1227 struct iavf_sc *sc = (struct iavf_sc *)arg;
1228 int error;
1229
1230 error = iavf_add_mac_filter(sc, (u8*)LLADDR(sdl), IAVF_FILTER_MC);
1231
1232 return (!error);
1233 }
1234
1235 /**
1236 * iavf_init_multi - Initialize multicast address filters
1237 * @sc: device private softc
1238 *
1239 * Called during initialization to reset multicast address filters to a known
1240 * fresh state by deleting all currently active filters.
1241 */
1242 void
iavf_init_multi(struct iavf_sc * sc)1243 iavf_init_multi(struct iavf_sc *sc)
1244 {
1245 struct iavf_mac_filter *f;
1246 int mcnt = 0;
1247
1248 /* First clear any multicast filters */
1249 SLIST_FOREACH(f, sc->mac_filters, next) {
1250 if ((f->flags & IAVF_FILTER_USED)
1251 && (f->flags & IAVF_FILTER_MC)) {
1252 f->flags |= IAVF_FILTER_DEL;
1253 mcnt++;
1254 }
1255 }
1256 if (mcnt > 0)
1257 iavf_send_vc_msg(sc, IAVF_FLAG_AQ_DEL_MAC_FILTER);
1258 }
1259
1260 /**
1261 * iavf_multi_set - Set multicast filters
1262 * @sc: device private softc
1263 *
1264 * Set multicast MAC filters for this device. If there are too many filters,
1265 * this will request the device to go into multicast promiscuous mode instead.
1266 */
1267 void
iavf_multi_set(struct iavf_sc * sc)1268 iavf_multi_set(struct iavf_sc *sc)
1269 {
1270 if_t ifp = sc->vsi.ifp;
1271 int mcnt = 0;
1272
1273 IOCTL_DEBUGOUT("iavf_multi_set: begin");
1274
1275 mcnt = if_llmaddr_count(ifp);
1276 if (__predict_false(mcnt == MAX_MULTICAST_ADDR)) {
1277 /* Delete MC filters and enable mulitcast promisc instead */
1278 iavf_init_multi(sc);
1279 sc->promisc_flags |= FLAG_VF_MULTICAST_PROMISC;
1280 iavf_send_vc_msg(sc, IAVF_FLAG_AQ_CONFIGURE_PROMISC);
1281 return;
1282 }
1283
1284 /* If there aren't too many filters, delete existing MC filters */
1285 iavf_init_multi(sc);
1286
1287 /* And (re-)install filters for all mcast addresses */
1288 mcnt = if_foreach_llmaddr(ifp, iavf_mc_filter_apply, sc);
1289
1290 if (mcnt > 0)
1291 iavf_send_vc_msg(sc, IAVF_FLAG_AQ_ADD_MAC_FILTER);
1292 }
1293
1294 /**
1295 * iavf_add_mac_filter - Add a MAC filter to the sc MAC list
1296 * @sc: device private softc
1297 * @macaddr: MAC address to add
1298 * @flags: filter flags
1299 *
1300 * Add a new MAC filter to the softc MAC filter list. These will later be sent
1301 * to the physical function (and ultimately hardware) via the virtchnl
1302 * interface.
1303 *
1304 * @returns zero on success, EEXIST if the filter already exists, and ENOMEM
1305 * if we ran out of memory allocating the filter structure.
1306 */
1307 int
iavf_add_mac_filter(struct iavf_sc * sc,u8 * macaddr,u16 flags)1308 iavf_add_mac_filter(struct iavf_sc *sc, u8 *macaddr, u16 flags)
1309 {
1310 struct iavf_mac_filter *f;
1311
1312 /* Does one already exist? */
1313 f = iavf_find_mac_filter(sc, macaddr);
1314 if (f != NULL) {
1315 iavf_dbg_filter(sc, "exists: " MAC_FORMAT "\n",
1316 MAC_FORMAT_ARGS(macaddr));
1317 return (EEXIST);
1318 }
1319
1320 /* If not, get a new empty filter */
1321 f = iavf_get_mac_filter(sc);
1322 if (f == NULL) {
1323 device_printf(sc->dev, "%s: no filters available!!\n",
1324 __func__);
1325 return (ENOMEM);
1326 }
1327
1328 iavf_dbg_filter(sc, "marked: " MAC_FORMAT "\n",
1329 MAC_FORMAT_ARGS(macaddr));
1330
1331 bcopy(macaddr, f->macaddr, ETHER_ADDR_LEN);
1332 f->flags |= (IAVF_FILTER_ADD | IAVF_FILTER_USED);
1333 f->flags |= flags;
1334 return (0);
1335 }
1336
1337 /**
1338 * iavf_find_mac_filter - Find a MAC filter with the given address
1339 * @sc: device private softc
1340 * @macaddr: the MAC address to find
1341 *
1342 * Finds the filter structure in the MAC filter list with the corresponding
1343 * MAC address.
1344 *
1345 * @returns a pointer to the filter structure, or NULL if no such filter
1346 * exists in the list yet.
1347 */
1348 struct iavf_mac_filter *
iavf_find_mac_filter(struct iavf_sc * sc,u8 * macaddr)1349 iavf_find_mac_filter(struct iavf_sc *sc, u8 *macaddr)
1350 {
1351 struct iavf_mac_filter *f;
1352 bool match = FALSE;
1353
1354 SLIST_FOREACH(f, sc->mac_filters, next) {
1355 if (cmp_etheraddr(f->macaddr, macaddr)) {
1356 match = TRUE;
1357 break;
1358 }
1359 }
1360
1361 if (!match)
1362 f = NULL;
1363 return (f);
1364 }
1365
1366 /**
1367 * iavf_get_mac_filter - Get a new MAC address filter
1368 * @sc: device private softc
1369 *
1370 * Allocates a new filter structure and inserts it into the MAC filter list.
1371 *
1372 * @post the caller must fill in the structure details after calling this
1373 * function, but does not need to insert it into the linked list.
1374 *
1375 * @returns a pointer to the new filter structure, or NULL of we failed to
1376 * allocate it.
1377 */
1378 struct iavf_mac_filter *
iavf_get_mac_filter(struct iavf_sc * sc)1379 iavf_get_mac_filter(struct iavf_sc *sc)
1380 {
1381 struct iavf_mac_filter *f;
1382
1383 f = (struct iavf_mac_filter *)malloc(sizeof(struct iavf_mac_filter),
1384 M_IAVF, M_NOWAIT | M_ZERO);
1385 if (f)
1386 SLIST_INSERT_HEAD(sc->mac_filters, f, next);
1387
1388 return (f);
1389 }
1390
1391 /**
1392 * iavf_baudrate_from_link_speed - Convert link speed to baudrate
1393 * @sc: device private softc
1394 *
1395 * @post The link_speed_adv field is in Mbps, so it is multipled by
1396 * 1,000,000 before it's returned.
1397 *
1398 * @returns the adapter link speed in bits/sec
1399 */
1400 u64
iavf_baudrate_from_link_speed(struct iavf_sc * sc)1401 iavf_baudrate_from_link_speed(struct iavf_sc *sc)
1402 {
1403 if (sc->vf_res->vf_cap_flags & VIRTCHNL_VF_CAP_ADV_LINK_SPEED)
1404 return (sc->link_speed_adv * IAVF_ADV_LINK_SPEED_SCALE);
1405 else
1406 return iavf_max_vc_speed_to_value(sc->link_speed);
1407 }
1408
1409 /**
1410 * iavf_add_vlan_filter - Add a VLAN filter to the softc VLAN list
1411 * @sc: device private softc
1412 * @vtag: the VLAN id to filter
1413 *
1414 * Allocate a new VLAN filter structure and insert it into the VLAN list.
1415 */
1416 void
iavf_add_vlan_filter(struct iavf_sc * sc,u16 vtag)1417 iavf_add_vlan_filter(struct iavf_sc *sc, u16 vtag)
1418 {
1419 struct iavf_vlan_filter *v;
1420
1421 v = (struct iavf_vlan_filter *)malloc(sizeof(struct iavf_vlan_filter),
1422 M_IAVF, M_WAITOK | M_ZERO);
1423 SLIST_INSERT_HEAD(sc->vlan_filters, v, next);
1424 v->vlan = vtag;
1425 v->flags = IAVF_FILTER_ADD;
1426 }
1427
1428 /**
1429 * iavf_mark_del_vlan_filter - Mark a given VLAN id for deletion
1430 * @sc: device private softc
1431 * @vtag: the VLAN id to delete
1432 *
1433 * Marks all VLAN filters matching the given vtag for deletion.
1434 *
1435 * @returns the number of filters marked for deletion.
1436 *
1437 * @remark the filters are not removed immediately, but will be removed from
1438 * the list by another function that synchronizes over the virtchnl interface.
1439 */
1440 int
iavf_mark_del_vlan_filter(struct iavf_sc * sc,u16 vtag)1441 iavf_mark_del_vlan_filter(struct iavf_sc *sc, u16 vtag)
1442 {
1443 struct iavf_vlan_filter *v;
1444 int i = 0;
1445
1446 SLIST_FOREACH(v, sc->vlan_filters, next) {
1447 if (v->vlan == vtag) {
1448 v->flags = IAVF_FILTER_DEL;
1449 ++i;
1450 }
1451 }
1452
1453 return (i);
1454 }
1455
1456 /**
1457 * iavf_disable_queues_with_retries - Send PF multiple DISABLE_QUEUES messages
1458 * @sc: device softc
1459 *
1460 * Send a virtual channel message to the PF to DISABLE_QUEUES, but resend it up
1461 * to IAVF_MAX_DIS_Q_RETRY times if the response says that it wasn't
1462 * successful. This is intended to workaround a bug that can appear on the PF.
1463 */
1464 void
iavf_disable_queues_with_retries(struct iavf_sc * sc)1465 iavf_disable_queues_with_retries(struct iavf_sc *sc)
1466 {
1467 bool in_detach = iavf_driver_is_detaching(sc);
1468 int max_attempts = IAVF_MAX_DIS_Q_RETRY;
1469 int msg_count = 0;
1470
1471 /* While the driver is detaching, it doesn't care if the queue
1472 * disable finishes successfully or not. Just send one message
1473 * to just notify the PF driver.
1474 */
1475 if (in_detach)
1476 max_attempts = 1;
1477
1478 while ((msg_count < max_attempts) &&
1479 atomic_load_acq_32(&sc->queues_enabled)) {
1480 msg_count++;
1481 iavf_send_vc_msg_sleep(sc, IAVF_FLAG_AQ_DISABLE_QUEUES);
1482 }
1483
1484 /* Possibly print messages about retry attempts and issues */
1485 if (msg_count > 1)
1486 iavf_dbg_vc(sc, "DISABLE_QUEUES messages sent: %d\n",
1487 msg_count);
1488
1489 if (!in_detach && msg_count >= max_attempts)
1490 device_printf(sc->dev, "%s: DISABLE_QUEUES may have failed\n",
1491 __func__);
1492 }
1493