1 /******************************************************************************
2
3 Copyright (c) 2013-2018, Intel Corporation
4 All rights reserved.
5
6 Redistribution and use in source and binary forms, with or without
7 modification, are permitted provided that the following conditions are met:
8
9 1. Redistributions of source code must retain the above copyright notice,
10 this list of conditions and the following disclaimer.
11
12 2. Redistributions in binary form must reproduce the above copyright
13 notice, this list of conditions and the following disclaimer in the
14 documentation and/or other materials provided with the distribution.
15
16 3. Neither the name of the Intel Corporation nor the names of its
17 contributors may be used to endorse or promote products derived from
18 this software without specific prior written permission.
19
20 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
24 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 POSSIBILITY OF SUCH DAMAGE.
31
32 ******************************************************************************/
33
34 #include "ixl.h"
35 #include "ixl_pf.h"
36
37 #include <net/if_vf_status.h>
38
39 #ifdef IXL_IW
40 #include "ixl_iw.h"
41 #include "ixl_iw_int.h"
42 #endif
43
44 #ifdef PCI_IOV
45 #include "ixl_pf_iov.h"
46 #endif
47
48 /*********************************************************************
49 * Driver version
50 *********************************************************************/
51 #define IXL_DRIVER_VERSION_MAJOR 2
52 #define IXL_DRIVER_VERSION_MINOR 3
53 #define IXL_DRIVER_VERSION_BUILD 3
54
55 #define IXL_DRIVER_VERSION_STRING \
56 __XSTRING(IXL_DRIVER_VERSION_MAJOR) "." \
57 __XSTRING(IXL_DRIVER_VERSION_MINOR) "." \
58 __XSTRING(IXL_DRIVER_VERSION_BUILD) "-k"
59
60 /* Version 1 driver.ixl extension schema; documented in ixl(4). */
61 #define IXL_VF_STATUS_NAMESPACE "driver.ixl"
62 #define IXL_VF_STATUS_VERSION 1
63 #define IXL_VF_STATUS_MDD_BLOCKED "mdd-blocked"
64 #define IXL_VF_STATUS_MDD_TX_EVENTS "mdd-tx-events"
65 #define IXL_VF_STATUS_MDD_RX_EVENTS "mdd-rx-events"
66
67 enum ixl_vf_status_field {
68 IXL_VF_STATUS_FIELD_MDD_BLOCKED,
69 IXL_VF_STATUS_FIELD_MDD_TX_EVENTS,
70 IXL_VF_STATUS_FIELD_MDD_RX_EVENTS,
71 IXL_VF_STATUS_NUM_FIELDS
72 };
73
74 /*********************************************************************
75 * PCI Device ID Table
76 *
77 * Used by probe to select devices to load on
78 *
79 * ( Vendor ID, Device ID, Branding String )
80 *********************************************************************/
81
82 static const pci_vendor_info_t ixl_vendor_info_array[] =
83 {
84 PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_SFP_XL710, "Intel(R) Ethernet Controller X710 for 10GbE SFP+"),
85 PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_KX_B, "Intel(R) Ethernet Controller XL710 for 40GbE backplane"),
86 PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_KX_C, "Intel(R) Ethernet Controller X710 for 10GbE backplane"),
87 PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_QSFP_A, "Intel(R) Ethernet Controller XL710 for 40GbE QSFP+"),
88 PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_QSFP_B, "Intel(R) Ethernet Controller XL710 for 40GbE QSFP+"),
89 PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_QSFP_C, "Intel(R) Ethernet Controller X710 for 10GbE QSFP+"),
90 PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_10G_BASE_T, "Intel(R) Ethernet Controller X710 for 10GBASE-T"),
91 PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_10G_BASE_T4, "Intel(R) Ethernet Controller X710/X557-AT 10GBASE-T"),
92 PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_KX_X722, "Intel(R) Ethernet Connection X722 for 10GbE backplane"),
93 PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_QSFP_X722, "Intel(R) Ethernet Connection X722 for 10GbE QSFP+"),
94 PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_SFP_X722, "Intel(R) Ethernet Connection X722 for 10GbE SFP+"),
95 PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_1G_BASE_T_X722, "Intel(R) Ethernet Connection X722 for 1GbE"),
96 PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_10G_BASE_T_X722, "Intel(R) Ethernet Connection X722 for 10GBASE-T"),
97 PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_SFP_I_X722, "Intel(R) Ethernet Connection X722 for 10GbE SFP+"),
98 PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_25G_B, "Intel(R) Ethernet Controller XXV710 for 25GbE backplane"),
99 PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_25G_SFP28, "Intel(R) Ethernet Controller XXV710 for 25GbE SFP28"),
100 PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_10G_BASE_T_BC, "Intel(R) Ethernet Controller X710 for 10GBASE-T"),
101 PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_10G_SFP, "Intel(R) Ethernet Controller X710 for 10GbE SFP+"),
102 PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_10G_B, "Intel(R) Ethernet Controller X710 for 10GbE backplane"),
103 PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_5G_BASE_T_BC, "Intel(R) Ethernet Controller V710 for 5GBASE-T"),
104 PVIDV(I40E_INTEL_VENDOR_ID, I40E_DEV_ID_1G_BASE_T_BC, "Intel(R) Ethernet Controller I710 for 1GBASE-T"),
105 /* required last entry */
106 PVID_END
107 };
108
109 /*********************************************************************
110 * Function prototypes
111 *********************************************************************/
112 /*** IFLIB interface ***/
113 static void *ixl_register(device_t dev);
114 static int ixl_if_attach_pre(if_ctx_t ctx);
115 static int ixl_if_attach_post(if_ctx_t ctx);
116 static int ixl_if_detach(if_ctx_t ctx);
117 static int ixl_if_shutdown(if_ctx_t ctx);
118 static int ixl_if_suspend(if_ctx_t ctx);
119 static int ixl_if_resume(if_ctx_t ctx);
120 static int ixl_if_msix_intr_assign(if_ctx_t ctx, int msix);
121 static void ixl_if_enable_intr(if_ctx_t ctx);
122 static void ixl_if_disable_intr(if_ctx_t ctx);
123 static int ixl_if_rx_queue_intr_enable(if_ctx_t ctx, uint16_t rxqid);
124 static int ixl_if_tx_queue_intr_enable(if_ctx_t ctx, uint16_t txqid);
125 static int ixl_if_tx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs, uint64_t *paddrs, int ntxqs, int ntxqsets);
126 static int ixl_if_rx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs, uint64_t *paddrs, int nqs, int nqsets);
127 static void ixl_if_queues_free(if_ctx_t ctx);
128 static void ixl_if_update_admin_status(if_ctx_t ctx);
129 static void ixl_if_multi_set(if_ctx_t ctx);
130 static int ixl_if_mtu_set(if_ctx_t ctx, uint32_t mtu);
131 static void ixl_if_media_status(if_ctx_t ctx, struct ifmediareq *ifmr);
132 static int ixl_if_media_change(if_ctx_t ctx);
133 static int ixl_if_promisc_set(if_ctx_t ctx, int flags);
134 static void ixl_if_timer(if_ctx_t ctx, uint16_t qid);
135 static void ixl_if_vlan_register(if_ctx_t ctx, u16 vtag);
136 static void ixl_if_vlan_unregister(if_ctx_t ctx, u16 vtag);
137 static uint64_t ixl_if_get_counter(if_ctx_t ctx, ift_counter cnt);
138 static int ixl_if_i2c_req(if_ctx_t ctx, struct ifi2creq *req);
139 static int ixl_if_priv_ioctl(if_ctx_t ctx, u_long command, caddr_t data);
140 static bool ixl_if_needs_restart(if_ctx_t ctx, enum iflib_restart_event event);
141 static void ixl_if_led_func(if_ctx_t ctx, int onoff);
142 static int ixl_if_vf_status(if_ctx_t ctx,
143 struct if_vf_status **statusp);
144 #ifdef PCI_IOV
145 static void ixl_if_vflr_handle(if_ctx_t ctx);
146 #endif
147
148 /*** Other ***/
149 static void ixl_save_pf_tunables(struct ixl_pf *);
150 static int ixl_allocate_pci_resources(struct ixl_pf *);
151 static void ixl_setup_ssctx(struct ixl_pf *pf);
152 static void ixl_admin_timer(void *arg);
153
154 /*********************************************************************
155 * FreeBSD Device Interface Entry Points
156 *********************************************************************/
157
158 static device_method_t ixl_methods[] = {
159 /* Device interface */
160 DEVMETHOD(device_register, ixl_register),
161 DEVMETHOD(device_probe, iflib_device_probe),
162 DEVMETHOD(device_attach, iflib_device_attach),
163 DEVMETHOD(device_detach, iflib_device_detach),
164 DEVMETHOD(device_shutdown, iflib_device_shutdown),
165 DEVMETHOD(device_suspend, iflib_device_suspend),
166 DEVMETHOD(device_resume, iflib_device_resume),
167 #ifdef PCI_IOV
168 DEVMETHOD(pci_iov_init, iflib_device_iov_init),
169 DEVMETHOD(pci_iov_uninit, iflib_device_iov_uninit),
170 DEVMETHOD(pci_iov_add_vf, iflib_device_iov_add_vf),
171 #endif
172 DEVMETHOD_END
173 };
174
175 static driver_t ixl_driver = {
176 "ixl", ixl_methods, sizeof(struct ixl_pf),
177 };
178
179 DRIVER_MODULE(ixl, pci, ixl_driver, 0, 0);
180 IFLIB_PNP_INFO(pci, ixl, ixl_vendor_info_array);
181 MODULE_VERSION(ixl, 3);
182
183 MODULE_DEPEND(ixl, pci, 1, 1, 1);
184 MODULE_DEPEND(ixl, ether, 1, 1, 1);
185 MODULE_DEPEND(ixl, iflib, 1, 1, 1);
186
187 static device_method_t ixl_if_methods[] = {
188 DEVMETHOD(ifdi_attach_pre, ixl_if_attach_pre),
189 DEVMETHOD(ifdi_attach_post, ixl_if_attach_post),
190 DEVMETHOD(ifdi_detach, ixl_if_detach),
191 DEVMETHOD(ifdi_shutdown, ixl_if_shutdown),
192 DEVMETHOD(ifdi_suspend, ixl_if_suspend),
193 DEVMETHOD(ifdi_resume, ixl_if_resume),
194 DEVMETHOD(ifdi_init, ixl_if_init),
195 DEVMETHOD(ifdi_stop, ixl_if_stop),
196 DEVMETHOD(ifdi_msix_intr_assign, ixl_if_msix_intr_assign),
197 DEVMETHOD(ifdi_intr_enable, ixl_if_enable_intr),
198 DEVMETHOD(ifdi_intr_disable, ixl_if_disable_intr),
199 DEVMETHOD(ifdi_rx_queue_intr_enable, ixl_if_rx_queue_intr_enable),
200 DEVMETHOD(ifdi_tx_queue_intr_enable, ixl_if_tx_queue_intr_enable),
201 DEVMETHOD(ifdi_tx_queues_alloc, ixl_if_tx_queues_alloc),
202 DEVMETHOD(ifdi_rx_queues_alloc, ixl_if_rx_queues_alloc),
203 DEVMETHOD(ifdi_queues_free, ixl_if_queues_free),
204 DEVMETHOD(ifdi_update_admin_status, ixl_if_update_admin_status),
205 DEVMETHOD(ifdi_multi_set, ixl_if_multi_set),
206 DEVMETHOD(ifdi_mtu_set, ixl_if_mtu_set),
207 DEVMETHOD(ifdi_media_status, ixl_if_media_status),
208 DEVMETHOD(ifdi_media_change, ixl_if_media_change),
209 DEVMETHOD(ifdi_promisc_set, ixl_if_promisc_set),
210 DEVMETHOD(ifdi_timer, ixl_if_timer),
211 DEVMETHOD(ifdi_vlan_register, ixl_if_vlan_register),
212 DEVMETHOD(ifdi_vlan_unregister, ixl_if_vlan_unregister),
213 DEVMETHOD(ifdi_get_counter, ixl_if_get_counter),
214 DEVMETHOD(ifdi_i2c_req, ixl_if_i2c_req),
215 DEVMETHOD(ifdi_priv_ioctl, ixl_if_priv_ioctl),
216 DEVMETHOD(ifdi_needs_restart, ixl_if_needs_restart),
217 DEVMETHOD(ifdi_led_func, ixl_if_led_func),
218 DEVMETHOD(ifdi_vf_status, ixl_if_vf_status),
219 #ifdef PCI_IOV
220 DEVMETHOD(ifdi_iov_init, ixl_if_iov_init),
221 DEVMETHOD(ifdi_iov_uninit, ixl_if_iov_uninit),
222 DEVMETHOD(ifdi_iov_vf_add, ixl_if_iov_vf_add),
223 DEVMETHOD(ifdi_vflr_handle, ixl_if_vflr_handle),
224 #endif
225 // ifdi_debug
226 DEVMETHOD_END
227 };
228
229 static driver_t ixl_if_driver = {
230 "ixl_if", ixl_if_methods, sizeof(struct ixl_pf)
231 };
232
233 /*
234 ** TUNEABLE PARAMETERS:
235 */
236
237 static SYSCTL_NODE(_hw, OID_AUTO, ixl, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
238 "ixl driver parameters");
239
240 #ifdef IXL_DEBUG_FC
241 /*
242 * Leave this on unless you need to send flow control
243 * frames (or other control frames) from software
244 */
245 static int ixl_enable_tx_fc_filter = 1;
246 TUNABLE_INT("hw.ixl.enable_tx_fc_filter",
247 &ixl_enable_tx_fc_filter);
248 SYSCTL_INT(_hw_ixl, OID_AUTO, enable_tx_fc_filter, CTLFLAG_RDTUN,
249 &ixl_enable_tx_fc_filter, 0,
250 "Filter out packets with Ethertype 0x8808 from being sent out by non-HW sources");
251 #endif
252
253 #ifdef IXL_DEBUG
254 static int ixl_debug_recovery_mode = 0;
255 TUNABLE_INT("hw.ixl.debug_recovery_mode",
256 &ixl_debug_recovery_mode);
257 SYSCTL_INT(_hw_ixl, OID_AUTO, debug_recovery_mode, CTLFLAG_RDTUN,
258 &ixl_debug_recovery_mode, 0,
259 "Act like when FW entered recovery mode (for debugging)");
260 #endif
261
262 static int ixl_i2c_access_method = 0;
263 TUNABLE_INT("hw.ixl.i2c_access_method",
264 &ixl_i2c_access_method);
265 SYSCTL_INT(_hw_ixl, OID_AUTO, i2c_access_method, CTLFLAG_RDTUN,
266 &ixl_i2c_access_method, 0,
267 IXL_SYSCTL_HELP_I2C_METHOD);
268
269 static int ixl_enable_vf_loopback = 1;
270 TUNABLE_INT("hw.ixl.enable_vf_loopback",
271 &ixl_enable_vf_loopback);
272 SYSCTL_INT(_hw_ixl, OID_AUTO, enable_vf_loopback, CTLFLAG_RDTUN,
273 &ixl_enable_vf_loopback, 0,
274 IXL_SYSCTL_HELP_VF_LOOPBACK);
275
276 static int ixl_mdd_auto_reset_vf;
277 TUNABLE_INT("hw.ixl.mdd_auto_reset_vf", &ixl_mdd_auto_reset_vf);
278 SYSCTL_INT(_hw_ixl, OID_AUTO, mdd_auto_reset_vf, CTLFLAG_RDTUN,
279 &ixl_mdd_auto_reset_vf, 0,
280 "Automatically reset VFs blocked by malicious-driver detection");
281
282 /*
283 * Different method for processing TX descriptor
284 * completion.
285 */
286 static int ixl_enable_head_writeback = 1;
287 TUNABLE_INT("hw.ixl.enable_head_writeback",
288 &ixl_enable_head_writeback);
289 SYSCTL_INT(_hw_ixl, OID_AUTO, enable_head_writeback, CTLFLAG_RDTUN,
290 &ixl_enable_head_writeback, 0,
291 "For detecting last completed TX descriptor by hardware, use value written by HW instead of checking descriptors");
292
293 static int ixl_core_debug_mask = 0;
294 TUNABLE_INT("hw.ixl.core_debug_mask",
295 &ixl_core_debug_mask);
296 SYSCTL_INT(_hw_ixl, OID_AUTO, core_debug_mask, CTLFLAG_RDTUN,
297 &ixl_core_debug_mask, 0,
298 "Display debug statements that are printed in non-shared code");
299
300 static int ixl_shared_debug_mask = 0;
301 TUNABLE_INT("hw.ixl.shared_debug_mask",
302 &ixl_shared_debug_mask);
303 SYSCTL_INT(_hw_ixl, OID_AUTO, shared_debug_mask, CTLFLAG_RDTUN,
304 &ixl_shared_debug_mask, 0,
305 "Display debug statements that are printed in shared code");
306
307 #if 0
308 /*
309 ** Controls for Interrupt Throttling
310 ** - true/false for dynamic adjustment
311 ** - default values for static ITR
312 */
313 static int ixl_dynamic_rx_itr = 0;
314 TUNABLE_INT("hw.ixl.dynamic_rx_itr", &ixl_dynamic_rx_itr);
315 SYSCTL_INT(_hw_ixl, OID_AUTO, dynamic_rx_itr, CTLFLAG_RDTUN,
316 &ixl_dynamic_rx_itr, 0, "Dynamic RX Interrupt Rate");
317
318 static int ixl_dynamic_tx_itr = 0;
319 TUNABLE_INT("hw.ixl.dynamic_tx_itr", &ixl_dynamic_tx_itr);
320 SYSCTL_INT(_hw_ixl, OID_AUTO, dynamic_tx_itr, CTLFLAG_RDTUN,
321 &ixl_dynamic_tx_itr, 0, "Dynamic TX Interrupt Rate");
322 #endif
323
324 static int ixl_rx_itr = IXL_ITR_8K;
325 TUNABLE_INT("hw.ixl.rx_itr", &ixl_rx_itr);
326 SYSCTL_INT(_hw_ixl, OID_AUTO, rx_itr, CTLFLAG_RDTUN,
327 &ixl_rx_itr, 0, "RX Interrupt Rate");
328
329 static int ixl_tx_itr = IXL_ITR_4K;
330 TUNABLE_INT("hw.ixl.tx_itr", &ixl_tx_itr);
331 SYSCTL_INT(_hw_ixl, OID_AUTO, tx_itr, CTLFLAG_RDTUN,
332 &ixl_tx_itr, 0, "TX Interrupt Rate");
333
334 static int ixl_flow_control = -1;
335 SYSCTL_INT(_hw_ixl, OID_AUTO, flow_control, CTLFLAG_RDTUN,
336 &ixl_flow_control, 0, "Initial Flow Control setting");
337
338 #ifdef IXL_IW
339 int ixl_enable_iwarp = 0;
340 TUNABLE_INT("hw.ixl.enable_iwarp", &ixl_enable_iwarp);
341 SYSCTL_INT(_hw_ixl, OID_AUTO, enable_iwarp, CTLFLAG_RDTUN,
342 &ixl_enable_iwarp, 0, "iWARP enabled");
343
344 int ixl_limit_iwarp_msix = IXL_IW_MAX_MSIX;
345 TUNABLE_INT("hw.ixl.limit_iwarp_msix", &ixl_limit_iwarp_msix);
346 SYSCTL_INT(_hw_ixl, OID_AUTO, limit_iwarp_msix, CTLFLAG_RDTUN,
347 &ixl_limit_iwarp_msix, 0, "Limit MSI-X vectors assigned to iWARP");
348 #endif
349
350 extern struct if_txrx ixl_txrx_hwb;
351 extern struct if_txrx ixl_txrx_dwb;
352
353 static struct if_shared_ctx ixl_sctx_init = {
354 .isc_magic = IFLIB_MAGIC,
355 .isc_q_align = PAGE_SIZE,
356 .isc_tx_maxsize = IXL_TSO_SIZE + sizeof(struct ether_vlan_header),
357 .isc_tx_maxsegsize = IXL_MAX_DMA_SEG_SIZE,
358 .isc_tso_maxsize = IXL_TSO_SIZE + sizeof(struct ether_vlan_header),
359 .isc_tso_maxsegsize = IXL_MAX_DMA_SEG_SIZE,
360 .isc_rx_maxsize = 16384,
361 .isc_rx_nsegments = IXL_MAX_RX_SEGS,
362 .isc_rx_maxsegsize = IXL_MAX_DMA_SEG_SIZE,
363 .isc_nfl = 1,
364 .isc_ntxqs = 1,
365 .isc_nrxqs = 1,
366
367 .isc_admin_intrcnt = 1,
368 .isc_vendor_info = ixl_vendor_info_array,
369 .isc_driver_version = IXL_DRIVER_VERSION_STRING,
370 .isc_driver = &ixl_if_driver,
371 .isc_flags = IFLIB_NEED_SCRATCH | IFLIB_NEED_ZERO_CSUM | IFLIB_TSO_INIT_IP | IFLIB_ADMIN_ALWAYS_RUN,
372
373 .isc_nrxd_min = {IXL_MIN_RING},
374 .isc_ntxd_min = {IXL_MIN_RING},
375 .isc_nrxd_max = {IXL_MAX_RING},
376 .isc_ntxd_max = {IXL_MAX_RING},
377 .isc_nrxd_default = {IXL_DEFAULT_RING},
378 .isc_ntxd_default = {IXL_DEFAULT_RING},
379 };
380
381 /*** Functions ***/
382 static void *
ixl_register(device_t dev)383 ixl_register(device_t dev)
384 {
385 return (&ixl_sctx_init);
386 }
387 static int
ixl_allocate_pci_resources(struct ixl_pf * pf)388 ixl_allocate_pci_resources(struct ixl_pf *pf)
389 {
390 device_t dev = iflib_get_dev(pf->vsi.ctx);
391 struct i40e_hw *hw = &pf->hw;
392 int rid;
393
394 /* Map BAR0 */
395 rid = PCIR_BAR(0);
396 pf->pci_mem = bus_alloc_resource_any(dev, SYS_RES_MEMORY,
397 &rid, RF_ACTIVE);
398
399 if (!(pf->pci_mem)) {
400 device_printf(dev, "Unable to allocate bus resource: PCI memory\n");
401 return (ENXIO);
402 }
403
404 /* Save off the PCI information */
405 hw->vendor_id = pci_get_vendor(dev);
406 hw->device_id = pci_get_device(dev);
407 hw->revision_id = pci_read_config(dev, PCIR_REVID, 1);
408 hw->subsystem_vendor_id =
409 pci_read_config(dev, PCIR_SUBVEND_0, 2);
410 hw->subsystem_device_id =
411 pci_read_config(dev, PCIR_SUBDEV_0, 2);
412
413 hw->bus.device = pci_get_slot(dev);
414 hw->bus.func = pci_get_function(dev);
415
416 /* Save off register access information */
417 pf->osdep.mem_bus_space_tag =
418 rman_get_bustag(pf->pci_mem);
419 pf->osdep.mem_bus_space_handle =
420 rman_get_bushandle(pf->pci_mem);
421 pf->osdep.mem_bus_space_size = rman_get_size(pf->pci_mem);
422 pf->osdep.flush_reg = I40E_GLGEN_STAT;
423 pf->osdep.dev = dev;
424
425 pf->hw.hw_addr = (u8 *) &pf->osdep.mem_bus_space_handle;
426 pf->hw.back = &pf->osdep;
427
428 return (0);
429 }
430
431 static void
ixl_setup_ssctx(struct ixl_pf * pf)432 ixl_setup_ssctx(struct ixl_pf *pf)
433 {
434 if_softc_ctx_t scctx = pf->vsi.shared;
435 struct i40e_hw *hw = &pf->hw;
436
437 if (IXL_PF_IN_RECOVERY_MODE(pf)) {
438 scctx->isc_ntxqsets_max = scctx->isc_nrxqsets_max = 1;
439 scctx->isc_ntxqsets = scctx->isc_nrxqsets = 1;
440 } else if (hw->mac.type == I40E_MAC_X722)
441 scctx->isc_ntxqsets_max = scctx->isc_nrxqsets_max = 128;
442 else
443 scctx->isc_ntxqsets_max = scctx->isc_nrxqsets_max = 64;
444
445 if (pf->vsi.enable_head_writeback) {
446 scctx->isc_txqsizes[0] = roundup2(scctx->isc_ntxd[0]
447 * sizeof(struct i40e_tx_desc) + sizeof(u32), DBA_ALIGN);
448 scctx->isc_txrx = &ixl_txrx_hwb;
449 } else {
450 scctx->isc_txqsizes[0] = roundup2(scctx->isc_ntxd[0]
451 * sizeof(struct i40e_tx_desc), DBA_ALIGN);
452 scctx->isc_txrx = &ixl_txrx_dwb;
453 }
454
455 scctx->isc_txrx->ift_legacy_intr = ixl_intr;
456 scctx->isc_rxqsizes[0] = roundup2(scctx->isc_nrxd[0]
457 * sizeof(union i40e_32byte_rx_desc), DBA_ALIGN);
458 scctx->isc_msix_bar = PCIR_BAR(IXL_MSIX_BAR);
459 scctx->isc_tx_nsegments = IXL_MAX_TX_SEGS;
460 scctx->isc_tx_tso_segments_max = IXL_MAX_TSO_SEGS;
461 scctx->isc_tx_tso_size_max = IXL_TSO_SIZE;
462 scctx->isc_tx_tso_segsize_max = IXL_MAX_DMA_SEG_SIZE;
463 scctx->isc_rss_table_size = pf->hw.func_caps.rss_table_size;
464 scctx->isc_tx_csum_flags = CSUM_OFFLOAD;
465 scctx->isc_capabilities = scctx->isc_capenable = IXL_CAPS;
466 }
467
468 static void
ixl_admin_timer(void * arg)469 ixl_admin_timer(void *arg)
470 {
471 struct ixl_pf *pf = (struct ixl_pf *)arg;
472
473 if (ixl_test_state(&pf->state, IXL_STATE_LINK_POLLING)) {
474 struct i40e_hw *hw = &pf->hw;
475 sbintime_t stime;
476 enum i40e_status_code status;
477
478 hw->phy.get_link_info = TRUE;
479 status = i40e_get_link_status(hw, &pf->link_up);
480 if (status == I40E_SUCCESS) {
481 ixl_clear_state(&pf->state, IXL_STATE_LINK_POLLING);
482 /* OS link info is updated in the admin task */
483 } else {
484 device_printf(pf->dev,
485 "%s: i40e_get_link_status status %s, aq error %s\n",
486 __func__, i40e_stat_str(hw, status),
487 i40e_aq_str(hw, hw->aq.asq_last_status));
488 stime = getsbinuptime();
489 if (stime - pf->link_poll_start > IXL_PF_MAX_LINK_POLL) {
490 device_printf(pf->dev, "Polling link status failed\n");
491 ixl_clear_state(&pf->state, IXL_STATE_LINK_POLLING);
492 }
493 }
494 }
495
496 /* Fire off the admin task */
497 iflib_admin_intr_deferred(pf->vsi.ctx);
498
499 /* Reschedule the admin timer */
500 callout_schedule(&pf->admin_timer, hz/2);
501 }
502
503 static int
ixl_attach_pre_recovery_mode(struct ixl_pf * pf)504 ixl_attach_pre_recovery_mode(struct ixl_pf *pf)
505 {
506 struct ixl_vsi *vsi = &pf->vsi;
507 struct i40e_hw *hw = &pf->hw;
508 device_t dev = pf->dev;
509
510 device_printf(dev, "Firmware recovery mode detected. Limiting functionality. Refer to Intel(R) Ethernet Adapters and Devices User Guide for details on firmware recovery mode.\n");
511
512 i40e_get_mac_addr(hw, hw->mac.addr);
513
514 if (vsi->shared->isc_intr == IFLIB_INTR_MSIX) {
515 ixl_configure_intr0_msix(pf);
516 ixl_enable_intr0(hw);
517 }
518
519 ixl_setup_ssctx(pf);
520
521 return (0);
522 }
523
524 static int
ixl_if_attach_pre(if_ctx_t ctx)525 ixl_if_attach_pre(if_ctx_t ctx)
526 {
527 device_t dev;
528 struct ixl_pf *pf;
529 struct i40e_hw *hw;
530 struct ixl_vsi *vsi;
531 enum i40e_get_fw_lldp_status_resp lldp_status;
532 struct i40e_filter_control_settings filter;
533 enum i40e_status_code status;
534 int error = 0;
535
536 dev = iflib_get_dev(ctx);
537 pf = iflib_get_softc(ctx);
538
539 INIT_DBG_DEV(dev, "begin");
540
541 vsi = &pf->vsi;
542 vsi->back = pf;
543 pf->dev = dev;
544 hw = &pf->hw;
545
546 vsi->dev = dev;
547 vsi->hw = &pf->hw;
548 vsi->id = 0;
549 vsi->num_vlans = 0;
550 vsi->ctx = ctx;
551 vsi->media = iflib_get_media(ctx);
552 vsi->shared = iflib_get_softc_ctx(ctx);
553
554 snprintf(pf->admin_mtx_name, sizeof(pf->admin_mtx_name),
555 "%s:admin", device_get_nameunit(dev));
556 mtx_init(&pf->admin_mtx, pf->admin_mtx_name, NULL, MTX_DEF);
557 callout_init_mtx(&pf->admin_timer, &pf->admin_mtx, 0);
558
559 /* Save tunable values */
560 ixl_save_pf_tunables(pf);
561
562 /* Do PCI setup - map BAR0, etc */
563 if (ixl_allocate_pci_resources(pf)) {
564 device_printf(dev, "Allocation of PCI resources failed\n");
565 error = ENXIO;
566 goto err_pci_res;
567 }
568
569 /* Establish a clean starting point */
570 i40e_clear_hw(hw);
571 i40e_set_mac_type(hw);
572
573 error = ixl_pf_reset(pf);
574 if (error)
575 goto err_out;
576
577 /* Initialize the shared code */
578 status = i40e_init_shared_code(hw);
579 if (status) {
580 device_printf(dev, "Unable to initialize shared code, error %s\n",
581 i40e_stat_str(hw, status));
582 error = EIO;
583 goto err_out;
584 }
585
586 /* Set up the admin queue */
587 hw->aq.num_arq_entries = IXL_AQ_LEN;
588 hw->aq.num_asq_entries = IXL_AQ_LEN;
589 hw->aq.arq_buf_size = IXL_AQ_BUF_SZ;
590 hw->aq.asq_buf_size = IXL_AQ_BUF_SZ;
591
592 status = i40e_init_adminq(hw);
593 if (status != 0 && status != I40E_ERR_FIRMWARE_API_VERSION) {
594 device_printf(dev, "Unable to initialize Admin Queue, error %s\n",
595 i40e_stat_str(hw, status));
596 error = EIO;
597 goto err_out;
598 }
599 ixl_print_nvm_version(pf);
600
601 if (status == I40E_ERR_FIRMWARE_API_VERSION) {
602 device_printf(dev, "The driver for the device stopped "
603 "because the NVM image is newer than expected.\n");
604 device_printf(dev, "You must install the most recent version of "
605 "the network driver.\n");
606 error = EIO;
607 goto err_out;
608 }
609
610 if (hw->aq.api_maj_ver == I40E_FW_API_VERSION_MAJOR &&
611 hw->aq.api_min_ver > I40E_FW_MINOR_VERSION(hw)) {
612 device_printf(dev, "The driver for the device detected "
613 "a newer version of the NVM image than expected.\n");
614 device_printf(dev, "Please install the most recent version "
615 "of the network driver.\n");
616 } else if (hw->aq.api_maj_ver == 1 && hw->aq.api_min_ver < 4) {
617 device_printf(dev, "The driver for the device detected "
618 "an older version of the NVM image than expected.\n");
619 device_printf(dev, "Please update the NVM image.\n");
620 }
621
622 if (IXL_PF_IN_RECOVERY_MODE(pf)) {
623 error = ixl_attach_pre_recovery_mode(pf);
624 if (error)
625 goto err_out;
626 return (error);
627 }
628
629 /* Clear PXE mode */
630 i40e_clear_pxe_mode(hw);
631
632 /* Get capabilities from the device */
633 error = ixl_get_hw_capabilities(pf);
634 if (error) {
635 device_printf(dev, "get_hw_capabilities failed: %d\n",
636 error);
637 goto err_get_cap;
638 }
639
640 /* Set up host memory cache */
641 error = ixl_setup_hmc(pf);
642 if (error)
643 goto err_mac_hmc;
644
645 /* Disable LLDP from the firmware for certain NVM versions */
646 if (((pf->hw.aq.fw_maj_ver == 4) && (pf->hw.aq.fw_min_ver < 3)) ||
647 (pf->hw.aq.fw_maj_ver < 4)) {
648 i40e_aq_stop_lldp(hw, true, false, NULL);
649 ixl_set_state(&pf->state, IXL_STATE_FW_LLDP_DISABLED);
650 }
651
652 /* Try enabling Energy Efficient Ethernet (EEE) mode */
653 if (i40e_enable_eee(hw, true) == I40E_SUCCESS)
654 ixl_set_state(&pf->state, IXL_STATE_EEE_ENABLED);
655 else
656 ixl_clear_state(&pf->state, IXL_STATE_EEE_ENABLED);
657
658 /* Get MAC addresses from hardware */
659 i40e_get_mac_addr(hw, hw->mac.addr);
660 error = i40e_validate_mac_addr(hw->mac.addr);
661 if (error) {
662 device_printf(dev, "validate_mac_addr failed: %d\n", error);
663 goto err_mac_hmc;
664 }
665 bcopy(hw->mac.addr, hw->mac.perm_addr, ETHER_ADDR_LEN);
666 iflib_set_mac(ctx, hw->mac.addr);
667 i40e_get_port_mac_addr(hw, hw->mac.port_addr);
668
669 /* Set up the device filtering */
670 bzero(&filter, sizeof(filter));
671 filter.enable_ethtype = TRUE;
672 filter.enable_macvlan = TRUE;
673 filter.enable_fdir = FALSE;
674 filter.hash_lut_size = I40E_HASH_LUT_SIZE_512;
675 if (i40e_set_filter_control(hw, &filter))
676 device_printf(dev, "i40e_set_filter_control() failed\n");
677
678 /* Query device FW LLDP status */
679 if (i40e_get_fw_lldp_status(hw, &lldp_status) == I40E_SUCCESS) {
680 if (lldp_status == I40E_GET_FW_LLDP_STATUS_DISABLED) {
681 ixl_set_state(&pf->state,
682 IXL_STATE_FW_LLDP_DISABLED);
683 } else {
684 ixl_clear_state(&pf->state,
685 IXL_STATE_FW_LLDP_DISABLED);
686 }
687 }
688
689 /* Tell FW to apply DCB config on link up */
690 i40e_aq_set_dcb_parameters(hw, true, NULL);
691
692 /* Fill out iflib parameters */
693 ixl_setup_ssctx(pf);
694
695 INIT_DBG_DEV(dev, "end");
696 return (0);
697
698 err_mac_hmc:
699 ixl_shutdown_hmc(pf);
700 err_get_cap:
701 i40e_shutdown_adminq(hw);
702 err_out:
703 ixl_free_pci_resources(pf);
704 err_pci_res:
705 mtx_lock(&pf->admin_mtx);
706 callout_stop(&pf->admin_timer);
707 mtx_unlock(&pf->admin_mtx);
708 mtx_destroy(&pf->admin_mtx);
709 return (error);
710 }
711
712 static int
ixl_if_attach_post(if_ctx_t ctx)713 ixl_if_attach_post(if_ctx_t ctx)
714 {
715 device_t dev;
716 struct ixl_pf *pf;
717 struct i40e_hw *hw;
718 struct ixl_vsi *vsi;
719 int error = 0;
720 enum i40e_status_code status;
721
722 dev = iflib_get_dev(ctx);
723 pf = iflib_get_softc(ctx);
724
725 INIT_DBG_DEV(dev, "begin");
726
727 vsi = &pf->vsi;
728 vsi->ifp = iflib_get_ifp(ctx);
729 hw = &pf->hw;
730
731 /* Save off determined number of queues for interface */
732 vsi->num_rx_queues = vsi->shared->isc_nrxqsets;
733 vsi->num_tx_queues = vsi->shared->isc_ntxqsets;
734
735 /* Setup OS network interface / ifnet */
736 if (ixl_setup_interface(dev, pf)) {
737 device_printf(dev, "interface setup failed!\n");
738 error = EIO;
739 goto err;
740 }
741
742 if (IXL_PF_IN_RECOVERY_MODE(pf)) {
743 /* Keep admin queue interrupts active while driver is loaded */
744 if (vsi->shared->isc_intr == IFLIB_INTR_MSIX) {
745 ixl_configure_intr0_msix(pf);
746 ixl_enable_intr0(hw);
747 }
748
749 ixl_add_sysctls_recovery_mode(pf);
750
751 /* Start the admin timer */
752 mtx_lock(&pf->admin_mtx);
753 callout_reset(&pf->admin_timer, hz/2, ixl_admin_timer, pf);
754 mtx_unlock(&pf->admin_mtx);
755 return (0);
756 }
757
758 error = ixl_switch_config(pf);
759 if (error) {
760 device_printf(dev, "Initial ixl_switch_config() failed: %d\n",
761 error);
762 goto err;
763 }
764
765 /* Add protocol filters to list */
766 ixl_init_filters(vsi);
767
768 /* Init queue allocation manager */
769 error = ixl_pf_qmgr_init(&pf->qmgr, hw->func_caps.num_tx_qp);
770 if (error) {
771 device_printf(dev, "Failed to init queue manager for PF queues, error %d\n",
772 error);
773 goto err;
774 }
775 /* reserve a contiguous allocation for the PF's VSI */
776 error = ixl_pf_qmgr_alloc_contiguous(&pf->qmgr,
777 max(vsi->num_rx_queues, vsi->num_tx_queues), &pf->qtag);
778 if (error) {
779 device_printf(dev, "Failed to reserve queues for PF LAN VSI, error %d\n",
780 error);
781 goto err;
782 }
783 device_printf(dev, "Allocating %d queues for PF LAN VSI; %d queues active\n",
784 pf->qtag.num_allocated, pf->qtag.num_active);
785
786 /* Determine link state */
787 error = ixl_attach_get_link_status(pf);
788 if (error == EINVAL)
789 goto err;
790
791 /* Limit PHY interrupts to link, autoneg, and modules failure */
792 status = i40e_aq_set_phy_int_mask(hw, IXL_DEFAULT_PHY_INT_MASK,
793 NULL);
794 if (status) {
795 device_printf(dev, "i40e_aq_set_phy_mask() failed: err %s,"
796 " aq_err %s\n", i40e_stat_str(hw, status),
797 i40e_aq_str(hw, hw->aq.asq_last_status));
798 goto err;
799 }
800
801 /* Get the bus configuration and set the shared code */
802 ixl_get_bus_info(pf);
803
804 /* Keep admin queue interrupts active while driver is loaded */
805 if (vsi->shared->isc_intr == IFLIB_INTR_MSIX) {
806 ixl_configure_intr0_msix(pf);
807 ixl_enable_intr0(hw);
808 }
809
810 /* Set initial advertised speed sysctl value */
811 ixl_set_initial_advertised_speeds(pf);
812
813 /* Initialize statistics & add sysctls */
814 ixl_add_device_sysctls(pf);
815 ixl_pf_reset_stats(pf);
816 ixl_update_stats_counters(pf);
817 ixl_add_hw_stats(pf);
818 ixl_vsi_reset_stats(vsi);
819
820 /*
821 * Driver may have been reloaded. Ensure that the link state
822 * is consistent with current settings.
823 */
824 ixl_set_link(pf, ixl_test_state(&pf->state, IXL_STATE_LINK_ACTIVE_ON_DOWN));
825
826 hw->phy.get_link_info = true;
827 status = i40e_get_link_status(hw, &pf->link_up);
828 if (status != I40E_SUCCESS) {
829 device_printf(dev,
830 "%s get link status, status: %s aq_err=%s\n",
831 __func__, i40e_stat_str(hw, status),
832 i40e_aq_str(hw, hw->aq.asq_last_status));
833 /*
834 * Most probably FW has not finished configuring PHY.
835 * Retry periodically in a timer callback.
836 */
837 ixl_set_state(&pf->state, IXL_STATE_LINK_POLLING);
838 pf->link_poll_start = getsbinuptime();
839 } else
840 ixl_update_link_status(pf);
841
842 #ifdef PCI_IOV
843 ixl_initialize_sriov(pf);
844 #endif
845
846 #ifdef IXL_IW
847 if (hw->func_caps.iwarp && ixl_enable_iwarp) {
848 pf->iw_enabled = (pf->iw_msix > 0) ? true : false;
849 if (pf->iw_enabled) {
850 error = ixl_iw_pf_attach(pf);
851 if (error) {
852 device_printf(dev,
853 "interfacing to iWARP driver failed: %d\n",
854 error);
855 goto err;
856 } else
857 device_printf(dev, "iWARP ready\n");
858 } else
859 device_printf(dev, "iWARP disabled on this device "
860 "(no MSI-X vectors)\n");
861 } else {
862 pf->iw_enabled = false;
863 device_printf(dev, "The device is not iWARP enabled\n");
864 }
865 #endif
866 /* Start the admin timer */
867 mtx_lock(&pf->admin_mtx);
868 callout_reset(&pf->admin_timer, hz/2, ixl_admin_timer, pf);
869 mtx_unlock(&pf->admin_mtx);
870
871 INIT_DBG_DEV(dev, "end");
872 return (0);
873
874 err:
875 INIT_DEBUGOUT("end: error %d", error);
876 /* ixl_if_detach() is called on error from this */
877 return (error);
878 }
879
880 /**
881 * XXX: iflib always ignores the return value of detach()
882 * -> This means that this isn't allowed to fail
883 */
884 static int
ixl_if_detach(if_ctx_t ctx)885 ixl_if_detach(if_ctx_t ctx)
886 {
887 struct ixl_pf *pf = iflib_get_softc(ctx);
888 struct ixl_vsi *vsi = &pf->vsi;
889 struct i40e_hw *hw = &pf->hw;
890 device_t dev = pf->dev;
891 enum i40e_status_code status;
892 #ifdef IXL_IW
893 int error;
894 #endif
895
896 INIT_DBG_DEV(dev, "begin");
897
898 /* Stop the admin timer */
899 mtx_lock(&pf->admin_mtx);
900 callout_stop(&pf->admin_timer);
901 mtx_unlock(&pf->admin_mtx);
902 mtx_destroy(&pf->admin_mtx);
903
904 #ifdef IXL_IW
905 if (ixl_enable_iwarp && pf->iw_enabled) {
906 error = ixl_iw_pf_detach(pf);
907 if (error == EBUSY) {
908 device_printf(dev, "iwarp in use; stop it first.\n");
909 //return (error);
910 }
911 }
912 #endif
913 /* Remove all previously allocated media types */
914 ifmedia_removeall(vsi->media);
915
916 /* Shutdown LAN HMC */
917 ixl_shutdown_hmc(pf);
918
919 /* Shutdown admin queue */
920 ixl_disable_intr0(hw);
921 status = i40e_shutdown_adminq(hw);
922 if (status)
923 device_printf(dev,
924 "i40e_shutdown_adminq() failed with status %s\n",
925 i40e_stat_str(hw, status));
926
927 ixl_pf_qmgr_destroy(&pf->qmgr);
928 ixl_free_pci_resources(pf);
929 ixl_free_filters(&vsi->ftl);
930 INIT_DBG_DEV(dev, "end");
931 return (0);
932 }
933
934 static int
ixl_if_shutdown(if_ctx_t ctx)935 ixl_if_shutdown(if_ctx_t ctx)
936 {
937 int error = 0;
938
939 INIT_DEBUGOUT("ixl_if_shutdown: begin");
940
941 /* TODO: Call ixl_if_stop()? */
942
943 /* TODO: Then setup low power mode */
944
945 return (error);
946 }
947
948 static int
ixl_if_suspend(if_ctx_t ctx)949 ixl_if_suspend(if_ctx_t ctx)
950 {
951 int error = 0;
952
953 INIT_DEBUGOUT("ixl_if_suspend: begin");
954
955 /* TODO: Call ixl_if_stop()? */
956
957 /* TODO: Then setup low power mode */
958
959 return (error);
960 }
961
962 static int
ixl_if_resume(if_ctx_t ctx)963 ixl_if_resume(if_ctx_t ctx)
964 {
965 INIT_DEBUGOUT("ixl_if_resume: begin");
966
967 /* Read & clear wake-up registers */
968
969 return (0);
970 }
971
972 void
ixl_if_init(if_ctx_t ctx)973 ixl_if_init(if_ctx_t ctx)
974 {
975 struct ixl_pf *pf = iflib_get_softc(ctx);
976 struct ixl_vsi *vsi = &pf->vsi;
977 struct i40e_hw *hw = &pf->hw;
978 if_t ifp = iflib_get_ifp(ctx);
979 device_t dev = iflib_get_dev(ctx);
980 u8 tmpaddr[ETHER_ADDR_LEN];
981 int ret;
982
983 if (IXL_PF_IN_RECOVERY_MODE(pf))
984 goto fail;
985 /*
986 * If the aq is dead here, it probably means something outside of the driver
987 * did something to the adapter, like a PF reset.
988 * So, rebuild the driver's state here if that occurs.
989 */
990 if (!i40e_check_asq_alive(&pf->hw)) {
991 device_printf(dev, "Admin Queue is down; resetting...\n");
992 (void)ixl_teardown_hw_structs(pf);
993 ret = ixl_rebuild_hw_structs_after_reset(pf, false);
994 if (ret != 0)
995 goto fail;
996 }
997
998 /* Get the latest mac address... User might use a LAA */
999 bcopy(if_getlladdr(vsi->ifp), tmpaddr, ETH_ALEN);
1000 if (!ixl_ether_is_equal(hw->mac.addr, tmpaddr) &&
1001 (i40e_validate_mac_addr(tmpaddr) == I40E_SUCCESS)) {
1002 ret = i40e_aq_mac_address_write(hw,
1003 I40E_AQC_WRITE_TYPE_LAA_ONLY,
1004 tmpaddr, NULL);
1005 if (ret) {
1006 device_printf(dev, "LLA address change failed!!\n");
1007 goto fail;
1008 }
1009 ixl_del_all_vlan_filters(vsi, hw->mac.addr);
1010 bcopy(tmpaddr, hw->mac.addr, ETH_ALEN);
1011 /*
1012 * New filters are configured by ixl_reconfigure_filters
1013 * at the end of ixl_init_locked.
1014 */
1015 }
1016
1017 iflib_set_mac(ctx, hw->mac.addr);
1018
1019 /* Prepare the VSI: rings, hmc contexts, etc... */
1020 if (ixl_initialize_vsi(vsi)) {
1021 device_printf(dev, "initialize vsi failed!!\n");
1022 goto fail;
1023 }
1024
1025 ixl_set_link(pf, true);
1026
1027 /* Reconfigure multicast filters in HW */
1028 ixl_if_multi_set(ctx);
1029
1030 /* Set up RSS */
1031 ixl_config_rss(pf);
1032
1033 /* Set up MSI-X routing and the ITR settings */
1034 if (vsi->shared->isc_intr == IFLIB_INTR_MSIX) {
1035 ixl_configure_queue_intr_msix(pf);
1036 ixl_configure_itr(pf);
1037 } else
1038 ixl_configure_legacy(pf);
1039
1040 if (vsi->enable_head_writeback)
1041 ixl_init_tx_cidx(vsi);
1042 else
1043 ixl_init_tx_rsqs(vsi);
1044
1045 ret = ixl_enable_rings(vsi);
1046 if (ret != 0) {
1047 device_printf(dev, "enable rings failed: %d\n", ret);
1048 ixl_disable_rings(pf, vsi, &pf->qtag);
1049 goto fail;
1050 }
1051
1052 i40e_aq_set_default_vsi(hw, vsi->seid, NULL);
1053
1054 /* Re-add configure filters to HW */
1055 ixl_reconfigure_filters(vsi);
1056
1057 /* Configure promiscuous mode */
1058 ixl_if_promisc_set(ctx, if_getflags(ifp));
1059
1060 #ifdef IXL_IW
1061 if (ixl_enable_iwarp && pf->iw_enabled) {
1062 ret = ixl_iw_pf_init(pf);
1063 if (ret)
1064 device_printf(dev,
1065 "initialize iwarp failed, code %d\n", ret);
1066 }
1067 #endif
1068 return;
1069
1070 fail:
1071 iflib_init_failed(ctx);
1072 }
1073
1074 void
ixl_if_stop(if_ctx_t ctx)1075 ixl_if_stop(if_ctx_t ctx)
1076 {
1077 struct ixl_pf *pf = iflib_get_softc(ctx);
1078 if_t ifp = iflib_get_ifp(ctx);
1079 struct ixl_vsi *vsi = &pf->vsi;
1080
1081 INIT_DEBUGOUT("ixl_if_stop: begin\n");
1082
1083 ixl_led_restore(pf);
1084 if (IXL_PF_IN_RECOVERY_MODE(pf))
1085 return;
1086
1087 // TODO: This may need to be reworked
1088 #ifdef IXL_IW
1089 /* Stop iWARP device */
1090 if (ixl_enable_iwarp && pf->iw_enabled)
1091 ixl_iw_pf_stop(pf);
1092 #endif
1093
1094 ixl_disable_rings_intr(vsi);
1095 ixl_disable_rings(pf, vsi, &pf->qtag);
1096
1097 /*
1098 * Don't set link state if only reconfiguring
1099 * e.g. on MTU change.
1100 */
1101 if ((if_getflags(ifp) & IFF_UP) == 0 &&
1102 !ixl_test_state(&pf->state, IXL_STATE_LINK_ACTIVE_ON_DOWN))
1103 ixl_set_link(pf, false);
1104 }
1105
1106 #define IXL_PHY_DEBUG_ALL \
1107 (I40E_AQ_PHY_DEBUG_DISABLE_LINK_FW | \
1108 I40E_AQ_PHY_DEBUG_DISABLE_ALL_LINK_FW)
1109
1110 static bool
ixl_phy_controls_leds(const struct i40e_hw * hw)1111 ixl_phy_controls_leds(const struct i40e_hw *hw)
1112 {
1113
1114 /* These external 10GBASE-T PHYs own the identification LED. */
1115 return (hw->device_id == I40E_DEV_ID_10G_BASE_T ||
1116 hw->device_id == I40E_DEV_ID_10G_BASE_T4);
1117 }
1118
1119 static void
ixl_if_led_func(if_ctx_t ctx,int onoff)1120 ixl_if_led_func(if_ctx_t ctx, int onoff)
1121 {
1122 struct ixl_pf *pf;
1123 struct i40e_hw *hw;
1124 enum i40e_status_code status;
1125 u16 phy_status;
1126
1127 pf = iflib_get_softc(ctx);
1128 hw = &pf->hw;
1129 if (!onoff) {
1130 ixl_led_restore(pf);
1131 return;
1132 }
1133 if (pf->led_active)
1134 return;
1135
1136 pf->led_phy_controlled = ixl_phy_controls_leds(hw);
1137 if (!pf->led_phy_controlled) {
1138 pf->led_status = i40e_led_get(hw);
1139 pf->led_active = true;
1140 i40e_led_set(hw, 0xf, false);
1141 return;
1142 }
1143
1144 if ((hw->flags & I40E_HW_FLAG_AQ_PHY_ACCESS_CAPABLE) == 0)
1145 (void)i40e_aq_set_phy_debug(hw, IXL_PHY_DEBUG_ALL, NULL);
1146 pf->led_phy_addr = I40E_PHY_LED_PROV_REG_1;
1147 status = i40e_led_get_phy(hw, &pf->led_phy_addr, &phy_status);
1148 if (status != I40E_SUCCESS) {
1149 if ((hw->flags & I40E_HW_FLAG_AQ_PHY_ACCESS_CAPABLE) == 0)
1150 (void)i40e_aq_set_phy_debug(hw, 0, NULL);
1151 return;
1152 }
1153 pf->led_status = phy_status;
1154 pf->led_active = true;
1155 status = i40e_led_set_phy(hw, true, pf->led_phy_addr, 0);
1156 if (status != I40E_SUCCESS)
1157 ixl_led_restore(pf);
1158 }
1159
1160 void
ixl_led_restore(struct ixl_pf * pf)1161 ixl_led_restore(struct ixl_pf *pf)
1162 {
1163 struct i40e_hw *hw;
1164
1165 if (!pf->led_active)
1166 return;
1167
1168 hw = &pf->hw;
1169 if (pf->led_phy_controlled) {
1170 (void)i40e_led_set_phy(hw, false, pf->led_phy_addr,
1171 pf->led_status | I40E_PHY_LED_MODE_ORIG);
1172 if ((hw->flags & I40E_HW_FLAG_AQ_PHY_ACCESS_CAPABLE) == 0)
1173 (void)i40e_aq_set_phy_debug(hw, 0, NULL);
1174 } else {
1175 i40e_led_set(hw, pf->led_status, false);
1176 }
1177 pf->led_active = false;
1178 }
1179
1180 static int
ixl_if_msix_intr_assign(if_ctx_t ctx,int msix)1181 ixl_if_msix_intr_assign(if_ctx_t ctx, int msix)
1182 {
1183 struct ixl_pf *pf = iflib_get_softc(ctx);
1184 struct ixl_vsi *vsi = &pf->vsi;
1185 struct ixl_rx_queue *rx_que = vsi->rx_queues;
1186 struct ixl_tx_queue *tx_que = vsi->tx_queues;
1187 int err, i, rid, vector = 0;
1188 char buf[16];
1189
1190 MPASS(vsi->shared->isc_nrxqsets > 0);
1191 MPASS(vsi->shared->isc_ntxqsets > 0);
1192
1193 /* Admin Que must use vector 0*/
1194 rid = vector + 1;
1195 err = iflib_irq_alloc_generic(ctx, &vsi->irq, rid, IFLIB_INTR_ADMIN,
1196 ixl_msix_adminq, pf, 0, "aq");
1197 if (err) {
1198 iflib_irq_free(ctx, &vsi->irq);
1199 device_printf(iflib_get_dev(ctx),
1200 "Failed to register Admin Que handler");
1201 return (err);
1202 }
1203
1204 #ifdef PCI_IOV
1205 /* Create soft IRQ for handling VFLRs */
1206 iflib_softirq_alloc_generic(ctx, NULL, IFLIB_INTR_IOV, pf, 0, "iov");
1207 #endif
1208
1209 /* Now set up the stations */
1210 for (i = 0, vector = 1; i < vsi->shared->isc_nrxqsets; i++, vector++, rx_que++) {
1211 rid = vector + 1;
1212
1213 snprintf(buf, sizeof(buf), "rxq%d", i);
1214 err = iflib_irq_alloc_generic(ctx, &rx_que->que_irq, rid,
1215 IFLIB_INTR_RXTX, ixl_msix_que, rx_que, rx_que->rxr.me, buf);
1216 /* XXX: Does the driver work as expected if there are fewer num_rx_queues than
1217 * what's expected in the iflib context? */
1218 if (err) {
1219 device_printf(iflib_get_dev(ctx),
1220 "Failed to allocate queue RX int vector %d, err: %d\n", i, err);
1221 vsi->num_rx_queues = i + 1;
1222 goto fail;
1223 }
1224 rx_que->msix = vector;
1225 }
1226
1227 bzero(buf, sizeof(buf));
1228
1229 for (i = 0; i < vsi->shared->isc_ntxqsets; i++, tx_que++) {
1230 snprintf(buf, sizeof(buf), "txq%d", i);
1231 iflib_softirq_alloc_generic(ctx,
1232 &vsi->rx_queues[i % vsi->shared->isc_nrxqsets].que_irq,
1233 IFLIB_INTR_TX, tx_que, tx_que->txr.me, buf);
1234
1235 /* TODO: Maybe call a strategy function for this to figure out which
1236 * interrupts to map Tx queues to. I don't know if there's an immediately
1237 * better way than this other than a user-supplied map, though. */
1238 tx_que->msix = (i % vsi->shared->isc_nrxqsets) + 1;
1239 }
1240
1241 return (0);
1242 fail:
1243 iflib_irq_free(ctx, &vsi->irq);
1244 rx_que = vsi->rx_queues;
1245 for (int i = 0; i < vsi->num_rx_queues; i++, rx_que++)
1246 iflib_irq_free(ctx, &rx_que->que_irq);
1247 return (err);
1248 }
1249
1250 /*
1251 * Enable all interrupts
1252 *
1253 * Called in:
1254 * iflib_init_locked, after ixl_if_init()
1255 */
1256 static void
ixl_if_enable_intr(if_ctx_t ctx)1257 ixl_if_enable_intr(if_ctx_t ctx)
1258 {
1259 struct ixl_pf *pf = iflib_get_softc(ctx);
1260 struct ixl_vsi *vsi = &pf->vsi;
1261 struct i40e_hw *hw = vsi->hw;
1262 struct ixl_rx_queue *rx_que = vsi->rx_queues;
1263
1264 ixl_enable_intr0(hw);
1265 /* Enable queue interrupts */
1266 if (vsi->shared->isc_intr == IFLIB_INTR_MSIX) {
1267 for (int i = 0; i < vsi->num_rx_queues; i++, rx_que++)
1268 ixl_enable_queue(hw, rx_que->rxr.me);
1269 } else {
1270 /*
1271 * Set PFINT_LNKLST0 FIRSTQ_INDX to 0x0 to enable
1272 * triggering interrupts by queues.
1273 */
1274 wr32(hw, I40E_PFINT_LNKLST0, 0x0);
1275 }
1276 }
1277
1278 /*
1279 * Disable queue interrupts
1280 *
1281 * Other interrupt causes need to remain active.
1282 */
1283 static void
ixl_if_disable_intr(if_ctx_t ctx)1284 ixl_if_disable_intr(if_ctx_t ctx)
1285 {
1286 struct ixl_pf *pf = iflib_get_softc(ctx);
1287 struct ixl_vsi *vsi = &pf->vsi;
1288 struct i40e_hw *hw = vsi->hw;
1289 struct ixl_rx_queue *rx_que = vsi->rx_queues;
1290
1291 if (vsi->shared->isc_intr == IFLIB_INTR_MSIX) {
1292 for (int i = 0; i < vsi->num_rx_queues; i++, rx_que++)
1293 ixl_disable_queue(hw, rx_que->rxr.me);
1294 } else {
1295 /*
1296 * Set PFINT_LNKLST0 FIRSTQ_INDX to End of List (0x7FF)
1297 * to stop queues from triggering interrupts.
1298 */
1299 wr32(hw, I40E_PFINT_LNKLST0, IXL_QUEUE_EOL);
1300 }
1301 }
1302
1303 static int
ixl_if_rx_queue_intr_enable(if_ctx_t ctx,uint16_t rxqid)1304 ixl_if_rx_queue_intr_enable(if_ctx_t ctx, uint16_t rxqid)
1305 {
1306 struct ixl_pf *pf = iflib_get_softc(ctx);
1307 struct ixl_vsi *vsi = &pf->vsi;
1308 struct i40e_hw *hw = vsi->hw;
1309 struct ixl_rx_queue *rx_que = &vsi->rx_queues[rxqid];
1310
1311 ixl_enable_queue(hw, rx_que->msix - 1);
1312 return (0);
1313 }
1314
1315 static int
ixl_if_tx_queue_intr_enable(if_ctx_t ctx,uint16_t txqid)1316 ixl_if_tx_queue_intr_enable(if_ctx_t ctx, uint16_t txqid)
1317 {
1318 struct ixl_pf *pf = iflib_get_softc(ctx);
1319 struct ixl_vsi *vsi = &pf->vsi;
1320 struct i40e_hw *hw = vsi->hw;
1321 struct ixl_tx_queue *tx_que = &vsi->tx_queues[txqid];
1322
1323 ixl_enable_queue(hw, tx_que->msix - 1);
1324 return (0);
1325 }
1326
1327 static int
ixl_if_tx_queues_alloc(if_ctx_t ctx,caddr_t * vaddrs,uint64_t * paddrs,int ntxqs,int ntxqsets)1328 ixl_if_tx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs, uint64_t *paddrs, int ntxqs, int ntxqsets)
1329 {
1330 struct ixl_pf *pf = iflib_get_softc(ctx);
1331 struct ixl_vsi *vsi = &pf->vsi;
1332 if_softc_ctx_t scctx = vsi->shared;
1333 struct ixl_tx_queue *que;
1334 int i, j, error = 0;
1335
1336 MPASS(scctx->isc_ntxqsets > 0);
1337 MPASS(ntxqs == 1);
1338 MPASS(scctx->isc_ntxqsets == ntxqsets);
1339
1340 /* Allocate queue structure memory */
1341 if (!(vsi->tx_queues =
1342 (struct ixl_tx_queue *) malloc(sizeof(struct ixl_tx_queue) *ntxqsets, M_IXL, M_NOWAIT | M_ZERO))) {
1343 device_printf(iflib_get_dev(ctx), "Unable to allocate TX ring memory\n");
1344 return (ENOMEM);
1345 }
1346
1347 for (i = 0, que = vsi->tx_queues; i < ntxqsets; i++, que++) {
1348 struct tx_ring *txr = &que->txr;
1349
1350 txr->me = i;
1351 que->vsi = vsi;
1352
1353 if (!vsi->enable_head_writeback) {
1354 /* Allocate report status array */
1355 if (!(txr->tx_rsq = malloc(sizeof(qidx_t) * scctx->isc_ntxd[0], M_IXL, M_NOWAIT))) {
1356 device_printf(iflib_get_dev(ctx), "failed to allocate tx_rsq memory\n");
1357 error = ENOMEM;
1358 goto fail;
1359 }
1360 /* Init report status array */
1361 for (j = 0; j < scctx->isc_ntxd[0]; j++)
1362 txr->tx_rsq[j] = QIDX_INVALID;
1363 }
1364 /* get the virtual and physical address of the hardware queues */
1365 txr->tail = I40E_QTX_TAIL(txr->me);
1366 txr->tx_base = (struct i40e_tx_desc *)vaddrs[i * ntxqs];
1367 txr->tx_paddr = paddrs[i * ntxqs];
1368 txr->que = que;
1369 }
1370
1371 return (0);
1372 fail:
1373 ixl_if_queues_free(ctx);
1374 return (error);
1375 }
1376
1377 static int
ixl_if_rx_queues_alloc(if_ctx_t ctx,caddr_t * vaddrs,uint64_t * paddrs,int nrxqs,int nrxqsets)1378 ixl_if_rx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs, uint64_t *paddrs, int nrxqs, int nrxqsets)
1379 {
1380 struct ixl_pf *pf = iflib_get_softc(ctx);
1381 struct ixl_vsi *vsi = &pf->vsi;
1382 struct ixl_rx_queue *que;
1383 int i, error = 0;
1384
1385 #ifdef INVARIANTS
1386 if_softc_ctx_t scctx = vsi->shared;
1387 MPASS(scctx->isc_nrxqsets > 0);
1388 MPASS(nrxqs == 1);
1389 MPASS(scctx->isc_nrxqsets == nrxqsets);
1390 #endif
1391
1392 /* Allocate queue structure memory */
1393 if (!(vsi->rx_queues =
1394 (struct ixl_rx_queue *) malloc(sizeof(struct ixl_rx_queue) *
1395 nrxqsets, M_IXL, M_NOWAIT | M_ZERO))) {
1396 device_printf(iflib_get_dev(ctx), "Unable to allocate RX ring memory\n");
1397 error = ENOMEM;
1398 goto fail;
1399 }
1400
1401 for (i = 0, que = vsi->rx_queues; i < nrxqsets; i++, que++) {
1402 struct rx_ring *rxr = &que->rxr;
1403
1404 rxr->me = i;
1405 que->vsi = vsi;
1406
1407 /* get the virtual and physical address of the hardware queues */
1408 rxr->tail = I40E_QRX_TAIL(rxr->me);
1409 rxr->rx_base = (union i40e_rx_desc *)vaddrs[i * nrxqs];
1410 rxr->rx_paddr = paddrs[i * nrxqs];
1411 rxr->que = que;
1412 }
1413
1414 return (0);
1415 fail:
1416 ixl_if_queues_free(ctx);
1417 return (error);
1418 }
1419
1420 static void
ixl_if_queues_free(if_ctx_t ctx)1421 ixl_if_queues_free(if_ctx_t ctx)
1422 {
1423 struct ixl_pf *pf = iflib_get_softc(ctx);
1424 struct ixl_vsi *vsi = &pf->vsi;
1425
1426 if (vsi->tx_queues != NULL && !vsi->enable_head_writeback) {
1427 struct ixl_tx_queue *que;
1428 int i = 0;
1429
1430 for (i = 0, que = vsi->tx_queues; i < vsi->num_tx_queues; i++, que++) {
1431 struct tx_ring *txr = &que->txr;
1432 if (txr->tx_rsq != NULL) {
1433 free(txr->tx_rsq, M_IXL);
1434 txr->tx_rsq = NULL;
1435 }
1436 }
1437 }
1438
1439 if (vsi->tx_queues != NULL) {
1440 free(vsi->tx_queues, M_IXL);
1441 vsi->tx_queues = NULL;
1442 }
1443 if (vsi->rx_queues != NULL) {
1444 free(vsi->rx_queues, M_IXL);
1445 vsi->rx_queues = NULL;
1446 }
1447
1448 if (!IXL_PF_IN_RECOVERY_MODE(pf))
1449 sysctl_ctx_free(&vsi->sysctl_ctx);
1450 }
1451
1452 void
ixl_update_link_status(struct ixl_pf * pf)1453 ixl_update_link_status(struct ixl_pf *pf)
1454 {
1455 struct ixl_vsi *vsi = &pf->vsi;
1456 struct i40e_hw *hw = &pf->hw;
1457 u64 baudrate;
1458
1459 if (pf->link_up) {
1460 if (vsi->link_active == FALSE) {
1461 vsi->link_active = TRUE;
1462 baudrate = ixl_max_aq_speed_to_value(hw->phy.link_info.link_speed);
1463 iflib_link_state_change(vsi->ctx, LINK_STATE_UP, baudrate);
1464 ixl_link_up_msg(pf);
1465 #ifdef PCI_IOV
1466 ixl_broadcast_link_state(pf);
1467 #endif
1468 }
1469 } else { /* Link down */
1470 if (vsi->link_active == TRUE) {
1471 vsi->link_active = FALSE;
1472 iflib_link_state_change(vsi->ctx, LINK_STATE_DOWN, 0);
1473 #ifdef PCI_IOV
1474 ixl_broadcast_link_state(pf);
1475 #endif
1476 }
1477 }
1478 }
1479
1480 static void
ixl_handle_lan_overflow_event(struct ixl_pf * pf,struct i40e_arq_event_info * e)1481 ixl_handle_lan_overflow_event(struct ixl_pf *pf, struct i40e_arq_event_info *e)
1482 {
1483 device_t dev = pf->dev;
1484 u32 rxq_idx, qtx_ctl;
1485
1486 rxq_idx = (e->desc.params.external.param0 & I40E_PRTDCB_RUPTQ_RXQNUM_MASK) >>
1487 I40E_PRTDCB_RUPTQ_RXQNUM_SHIFT;
1488 qtx_ctl = e->desc.params.external.param1;
1489
1490 device_printf(dev, "LAN overflow event: global rxq_idx %d\n", rxq_idx);
1491 device_printf(dev, "LAN overflow event: QTX_CTL 0x%08x\n", qtx_ctl);
1492 }
1493
1494 static int
ixl_process_adminq(struct ixl_pf * pf,u16 * pending)1495 ixl_process_adminq(struct ixl_pf *pf, u16 *pending)
1496 {
1497 enum i40e_status_code status = I40E_SUCCESS;
1498 struct i40e_arq_event_info event;
1499 struct i40e_hw *hw = &pf->hw;
1500 device_t dev = pf->dev;
1501 u16 opcode;
1502 u32 loop = 0, reg;
1503
1504 event.buf_len = IXL_AQ_BUF_SZ;
1505 event.msg_buf = malloc(event.buf_len, M_IXL, M_NOWAIT | M_ZERO);
1506 if (!event.msg_buf) {
1507 device_printf(dev, "%s: Unable to allocate memory for Admin"
1508 " Queue event!\n", __func__);
1509 return (ENOMEM);
1510 }
1511
1512 /* clean and process any events */
1513 do {
1514 status = i40e_clean_arq_element(hw, &event, pending);
1515 if (status)
1516 break;
1517 opcode = LE16_TO_CPU(event.desc.opcode);
1518 ixl_dbg(pf, IXL_DBG_AQ,
1519 "Admin Queue event: %#06x\n", opcode);
1520 switch (opcode) {
1521 case i40e_aqc_opc_get_link_status:
1522 ixl_link_event(pf, &event);
1523 break;
1524 case i40e_aqc_opc_send_msg_to_pf:
1525 #ifdef PCI_IOV
1526 ixl_handle_vf_msg(pf, &event);
1527 #endif
1528 break;
1529 /*
1530 * This should only occur on no-drop queues, which
1531 * aren't currently configured.
1532 */
1533 case i40e_aqc_opc_event_lan_overflow:
1534 ixl_handle_lan_overflow_event(pf, &event);
1535 break;
1536 default:
1537 break;
1538 }
1539 } while (*pending && (loop++ < IXL_ADM_LIMIT));
1540
1541 free(event.msg_buf, M_IXL);
1542
1543 /* Re-enable admin queue interrupt cause */
1544 reg = rd32(hw, I40E_PFINT_ICR0_ENA);
1545 reg |= I40E_PFINT_ICR0_ENA_ADMINQ_MASK;
1546 wr32(hw, I40E_PFINT_ICR0_ENA, reg);
1547
1548 return (status);
1549 }
1550
1551 static void
ixl_if_update_admin_status(if_ctx_t ctx)1552 ixl_if_update_admin_status(if_ctx_t ctx)
1553 {
1554 struct ixl_pf *pf = iflib_get_softc(ctx);
1555 struct i40e_hw *hw = &pf->hw;
1556 u16 pending;
1557
1558 if (IXL_PF_IS_RESETTING(pf))
1559 ixl_handle_empr_reset(pf);
1560
1561 /*
1562 * Admin Queue is shut down while handling reset.
1563 * Don't proceed if it hasn't been re-initialized
1564 * e.g due to an issue with new FW.
1565 */
1566 if (!i40e_check_asq_alive(&pf->hw))
1567 return;
1568
1569 if (ixl_test_state(&pf->state, IXL_STATE_MDD_PENDING))
1570 ixl_handle_mdd_event(pf);
1571
1572 ixl_process_adminq(pf, &pending);
1573 ixl_update_link_status(pf);
1574
1575 /*
1576 * If there are still messages to process, reschedule ourselves.
1577 * Otherwise, re-enable our interrupt and go to sleep.
1578 */
1579 if (pending > 0)
1580 iflib_admin_intr_deferred(ctx);
1581 else
1582 ixl_enable_intr0(hw);
1583 }
1584
1585 static void
ixl_if_multi_set(if_ctx_t ctx)1586 ixl_if_multi_set(if_ctx_t ctx)
1587 {
1588 struct ixl_pf *pf = iflib_get_softc(ctx);
1589 struct ixl_vsi *vsi = &pf->vsi;
1590 struct i40e_hw *hw = vsi->hw;
1591 enum i40e_status_code status;
1592 int mcnt;
1593 if_t ifp = iflib_get_ifp(ctx);
1594
1595 IOCTL_DEBUGOUT("ixl_if_multi_set: begin");
1596
1597 /* Delete filters for removed multicast addresses */
1598 ixl_del_multi(vsi, false);
1599
1600 mcnt = min(if_llmaddr_count(ifp), MAX_MULTICAST_ADDR);
1601 if (__predict_false(mcnt == MAX_MULTICAST_ADDR)) {
1602 /* Check if promisc mode is already enabled, if yes return */
1603 if (vsi->flags & IXL_FLAGS_MC_PROMISC)
1604 return;
1605
1606 status = i40e_aq_set_vsi_multicast_promiscuous(hw,
1607 vsi->seid, TRUE, NULL);
1608 if (status != I40E_SUCCESS)
1609 if_printf(ifp, "Failed to enable multicast promiscuous "
1610 "mode, status: %s\n", i40e_stat_str(hw, status));
1611 else {
1612 if_printf(ifp, "Enabled multicast promiscuous mode\n");
1613
1614 /* Set the flag to track promiscuous mode */
1615 vsi->flags |= IXL_FLAGS_MC_PROMISC;
1616 }
1617 /* Delete all existing MC filters */
1618 ixl_del_multi(vsi, true);
1619 return;
1620 }
1621
1622 ixl_add_multi(vsi);
1623 IOCTL_DEBUGOUT("ixl_if_multi_set: end");
1624 }
1625
1626 static int
ixl_if_mtu_set(if_ctx_t ctx,uint32_t mtu)1627 ixl_if_mtu_set(if_ctx_t ctx, uint32_t mtu)
1628 {
1629 struct ixl_pf *pf = iflib_get_softc(ctx);
1630 struct ixl_vsi *vsi = &pf->vsi;
1631
1632 IOCTL_DEBUGOUT("ioctl: SIOCSIFMTU (Set Interface MTU)");
1633 if (mtu > IXL_MAX_FRAME - ETHER_HDR_LEN - ETHER_CRC_LEN -
1634 ETHER_VLAN_ENCAP_LEN)
1635 return (EINVAL);
1636
1637 vsi->shared->isc_max_frame_size = mtu + ETHER_HDR_LEN + ETHER_CRC_LEN +
1638 ETHER_VLAN_ENCAP_LEN;
1639
1640 return (0);
1641 }
1642
1643 static void
ixl_if_media_status(if_ctx_t ctx,struct ifmediareq * ifmr)1644 ixl_if_media_status(if_ctx_t ctx, struct ifmediareq *ifmr)
1645 {
1646 struct ixl_pf *pf = iflib_get_softc(ctx);
1647 struct i40e_hw *hw = &pf->hw;
1648
1649 INIT_DEBUGOUT("ixl_media_status: begin");
1650
1651 ifmr->ifm_status = IFM_AVALID;
1652 ifmr->ifm_active = IFM_ETHER;
1653
1654 if (!pf->link_up) {
1655 return;
1656 }
1657
1658 ifmr->ifm_status |= IFM_ACTIVE;
1659 /* Hardware is always full-duplex */
1660 ifmr->ifm_active |= IFM_FDX;
1661
1662 switch (hw->phy.link_info.phy_type) {
1663 /* 100 M */
1664 case I40E_PHY_TYPE_100BASE_TX:
1665 ifmr->ifm_active |= IFM_100_TX;
1666 break;
1667 /* 1 G */
1668 case I40E_PHY_TYPE_1000BASE_T:
1669 ifmr->ifm_active |= IFM_1000_T;
1670 break;
1671 case I40E_PHY_TYPE_1000BASE_SX:
1672 ifmr->ifm_active |= IFM_1000_SX;
1673 break;
1674 case I40E_PHY_TYPE_1000BASE_LX:
1675 ifmr->ifm_active |= IFM_1000_LX;
1676 break;
1677 case I40E_PHY_TYPE_1000BASE_T_OPTICAL:
1678 ifmr->ifm_active |= IFM_1000_T;
1679 break;
1680 /* 2.5 G */
1681 case I40E_PHY_TYPE_2_5GBASE_T_LINK_STATUS:
1682 ifmr->ifm_active |= IFM_2500_T;
1683 break;
1684 /* 5 G */
1685 case I40E_PHY_TYPE_5GBASE_T_LINK_STATUS:
1686 ifmr->ifm_active |= IFM_5000_T;
1687 break;
1688 /* 10 G */
1689 case I40E_PHY_TYPE_10GBASE_SFPP_CU:
1690 ifmr->ifm_active |= IFM_10G_TWINAX;
1691 break;
1692 case I40E_PHY_TYPE_10GBASE_SR:
1693 ifmr->ifm_active |= IFM_10G_SR;
1694 break;
1695 case I40E_PHY_TYPE_10GBASE_LR:
1696 ifmr->ifm_active |= IFM_10G_LR;
1697 break;
1698 case I40E_PHY_TYPE_10GBASE_T:
1699 ifmr->ifm_active |= IFM_10G_T;
1700 break;
1701 case I40E_PHY_TYPE_XAUI:
1702 case I40E_PHY_TYPE_XFI:
1703 ifmr->ifm_active |= IFM_10G_TWINAX;
1704 break;
1705 case I40E_PHY_TYPE_10GBASE_AOC:
1706 ifmr->ifm_active |= IFM_10G_AOC;
1707 break;
1708 /* 25 G */
1709 case I40E_PHY_TYPE_25GBASE_KR:
1710 ifmr->ifm_active |= IFM_25G_KR;
1711 break;
1712 case I40E_PHY_TYPE_25GBASE_CR:
1713 ifmr->ifm_active |= IFM_25G_CR;
1714 break;
1715 case I40E_PHY_TYPE_25GBASE_SR:
1716 ifmr->ifm_active |= IFM_25G_SR;
1717 break;
1718 case I40E_PHY_TYPE_25GBASE_LR:
1719 ifmr->ifm_active |= IFM_25G_LR;
1720 break;
1721 case I40E_PHY_TYPE_25GBASE_AOC:
1722 ifmr->ifm_active |= IFM_25G_AOC;
1723 break;
1724 case I40E_PHY_TYPE_25GBASE_ACC:
1725 ifmr->ifm_active |= IFM_25G_ACC;
1726 break;
1727 /* 40 G */
1728 case I40E_PHY_TYPE_40GBASE_CR4:
1729 case I40E_PHY_TYPE_40GBASE_CR4_CU:
1730 ifmr->ifm_active |= IFM_40G_CR4;
1731 break;
1732 case I40E_PHY_TYPE_40GBASE_SR4:
1733 ifmr->ifm_active |= IFM_40G_SR4;
1734 break;
1735 case I40E_PHY_TYPE_40GBASE_LR4:
1736 ifmr->ifm_active |= IFM_40G_LR4;
1737 break;
1738 case I40E_PHY_TYPE_XLAUI:
1739 ifmr->ifm_active |= IFM_OTHER;
1740 break;
1741 case I40E_PHY_TYPE_1000BASE_KX:
1742 ifmr->ifm_active |= IFM_1000_KX;
1743 break;
1744 case I40E_PHY_TYPE_SGMII:
1745 ifmr->ifm_active |= IFM_1000_SGMII;
1746 break;
1747 /* ERJ: What's the difference between these? */
1748 case I40E_PHY_TYPE_10GBASE_CR1_CU:
1749 case I40E_PHY_TYPE_10GBASE_CR1:
1750 ifmr->ifm_active |= IFM_10G_CR1;
1751 break;
1752 case I40E_PHY_TYPE_10GBASE_KX4:
1753 ifmr->ifm_active |= IFM_10G_KX4;
1754 break;
1755 case I40E_PHY_TYPE_10GBASE_KR:
1756 ifmr->ifm_active |= IFM_10G_KR;
1757 break;
1758 case I40E_PHY_TYPE_SFI:
1759 ifmr->ifm_active |= IFM_10G_SFI;
1760 break;
1761 /* Our single 20G media type */
1762 case I40E_PHY_TYPE_20GBASE_KR2:
1763 ifmr->ifm_active |= IFM_20G_KR2;
1764 break;
1765 case I40E_PHY_TYPE_40GBASE_KR4:
1766 ifmr->ifm_active |= IFM_40G_KR4;
1767 break;
1768 case I40E_PHY_TYPE_XLPPI:
1769 case I40E_PHY_TYPE_40GBASE_AOC:
1770 ifmr->ifm_active |= IFM_40G_XLPPI;
1771 break;
1772 /* Unknown to driver */
1773 default:
1774 ifmr->ifm_active |= IFM_UNKNOWN;
1775 break;
1776 }
1777 /* Report flow control status as well */
1778 if (hw->phy.link_info.an_info & I40E_AQ_LINK_PAUSE_TX)
1779 ifmr->ifm_active |= IFM_ETH_TXPAUSE;
1780 if (hw->phy.link_info.an_info & I40E_AQ_LINK_PAUSE_RX)
1781 ifmr->ifm_active |= IFM_ETH_RXPAUSE;
1782 }
1783
1784 static int
ixl_if_media_change(if_ctx_t ctx)1785 ixl_if_media_change(if_ctx_t ctx)
1786 {
1787 struct ifmedia *ifm = iflib_get_media(ctx);
1788
1789 INIT_DEBUGOUT("ixl_media_change: begin");
1790
1791 if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER)
1792 return (EINVAL);
1793
1794 if_printf(iflib_get_ifp(ctx), "Media change is not supported.\n");
1795 return (ENODEV);
1796 }
1797
1798 static int
ixl_if_promisc_set(if_ctx_t ctx,int flags)1799 ixl_if_promisc_set(if_ctx_t ctx, int flags)
1800 {
1801 struct ixl_pf *pf = iflib_get_softc(ctx);
1802 struct ixl_vsi *vsi = &pf->vsi;
1803 if_t ifp = iflib_get_ifp(ctx);
1804 struct i40e_hw *hw = vsi->hw;
1805 int err;
1806 bool uni = FALSE, multi = FALSE;
1807
1808 if (flags & IFF_PROMISC)
1809 uni = multi = TRUE;
1810 else if (flags & IFF_ALLMULTI || if_llmaddr_count(ifp) >=
1811 MAX_MULTICAST_ADDR)
1812 multi = TRUE;
1813
1814 err = i40e_aq_set_vsi_unicast_promiscuous(hw,
1815 vsi->seid, uni, NULL, true);
1816 if (err)
1817 return (err);
1818 err = i40e_aq_set_vsi_multicast_promiscuous(hw,
1819 vsi->seid, multi, NULL);
1820
1821 /* Update the multicast promiscuous flag based on the new state */
1822 if (multi)
1823 vsi->flags |= IXL_FLAGS_MC_PROMISC;
1824 else
1825 vsi->flags &= ~IXL_FLAGS_MC_PROMISC;
1826
1827 return (err);
1828 }
1829
1830 static void
ixl_if_timer(if_ctx_t ctx,uint16_t qid)1831 ixl_if_timer(if_ctx_t ctx, uint16_t qid)
1832 {
1833 struct ixl_pf *pf = iflib_get_softc(ctx);
1834
1835 if (qid != 0)
1836 return;
1837
1838 ixl_update_stats_counters(pf);
1839 }
1840
1841 static void
ixl_if_vlan_register(if_ctx_t ctx,u16 vtag)1842 ixl_if_vlan_register(if_ctx_t ctx, u16 vtag)
1843 {
1844 struct ixl_pf *pf = iflib_get_softc(ctx);
1845 struct ixl_vsi *vsi = &pf->vsi;
1846 struct i40e_hw *hw = vsi->hw;
1847 if_t ifp = iflib_get_ifp(ctx);
1848
1849 if ((vtag == 0) || (vtag > 4095)) /* Invalid */
1850 return;
1851
1852 /*
1853 * Keep track of registered VLANS to know what
1854 * filters have to be configured when VLAN_HWFILTER
1855 * capability is enabled.
1856 */
1857 ++vsi->num_vlans;
1858 bit_set(vsi->vlans_map, vtag);
1859
1860 if ((if_getcapenable(ifp) & IFCAP_VLAN_HWFILTER) == 0)
1861 return;
1862
1863 if (vsi->num_vlans < IXL_MAX_VLAN_FILTERS)
1864 ixl_add_filter(vsi, hw->mac.addr, vtag);
1865 else if (vsi->num_vlans == IXL_MAX_VLAN_FILTERS) {
1866 /*
1867 * There is not enough HW resources to add filters
1868 * for all registered VLANs. Re-configure filtering
1869 * to allow reception of all expected traffic.
1870 */
1871 device_printf(vsi->dev,
1872 "Not enough HW filters for all VLANs. VLAN HW filtering disabled");
1873 ixl_del_all_vlan_filters(vsi, hw->mac.addr);
1874 ixl_add_filter(vsi, hw->mac.addr, IXL_VLAN_ANY);
1875 }
1876 }
1877
1878 static void
ixl_if_vlan_unregister(if_ctx_t ctx,u16 vtag)1879 ixl_if_vlan_unregister(if_ctx_t ctx, u16 vtag)
1880 {
1881 struct ixl_pf *pf = iflib_get_softc(ctx);
1882 struct ixl_vsi *vsi = &pf->vsi;
1883 struct i40e_hw *hw = vsi->hw;
1884 if_t ifp = iflib_get_ifp(ctx);
1885
1886 if ((vtag == 0) || (vtag > 4095)) /* Invalid */
1887 return;
1888
1889 --vsi->num_vlans;
1890 bit_clear(vsi->vlans_map, vtag);
1891
1892 if ((if_getcapenable(ifp) & IFCAP_VLAN_HWFILTER) == 0)
1893 return;
1894
1895 /* One filter is used for untagged frames */
1896 if (vsi->num_vlans < IXL_MAX_VLAN_FILTERS - 1)
1897 ixl_del_filter(vsi, hw->mac.addr, vtag);
1898 else if (vsi->num_vlans == IXL_MAX_VLAN_FILTERS - 1) {
1899 ixl_del_filter(vsi, hw->mac.addr, IXL_VLAN_ANY);
1900 ixl_add_vlan_filters(vsi, hw->mac.addr);
1901 }
1902 }
1903
1904 static uint64_t
ixl_if_get_counter(if_ctx_t ctx,ift_counter cnt)1905 ixl_if_get_counter(if_ctx_t ctx, ift_counter cnt)
1906 {
1907 struct ixl_pf *pf = iflib_get_softc(ctx);
1908 struct ixl_vsi *vsi = &pf->vsi;
1909 if_t ifp = iflib_get_ifp(ctx);
1910
1911 switch (cnt) {
1912 case IFCOUNTER_IPACKETS:
1913 return (vsi->ipackets);
1914 case IFCOUNTER_IERRORS:
1915 return (vsi->ierrors);
1916 case IFCOUNTER_OPACKETS:
1917 return (vsi->opackets);
1918 case IFCOUNTER_OERRORS:
1919 return (if_get_counter_default(ifp, cnt) + vsi->oerrors);
1920 case IFCOUNTER_COLLISIONS:
1921 /* Collisions are by standard impossible in 40G/10G Ethernet */
1922 return (0);
1923 case IFCOUNTER_IBYTES:
1924 return (vsi->ibytes);
1925 case IFCOUNTER_OBYTES:
1926 return (vsi->obytes);
1927 case IFCOUNTER_IMCASTS:
1928 return (vsi->imcasts);
1929 case IFCOUNTER_OMCASTS:
1930 return (vsi->omcasts);
1931 case IFCOUNTER_IQDROPS:
1932 return (vsi->iqdrops);
1933 case IFCOUNTER_OQDROPS:
1934 return (if_get_counter_default(ifp, cnt) + vsi->oqdrops);
1935 case IFCOUNTER_NOPROTO:
1936 return (vsi->noproto);
1937 default:
1938 return (if_get_counter_default(ifp, cnt));
1939 }
1940 }
1941
1942 #ifdef PCI_IOV
1943 static void
ixl_if_vflr_handle(if_ctx_t ctx)1944 ixl_if_vflr_handle(if_ctx_t ctx)
1945 {
1946 struct ixl_pf *pf = iflib_get_softc(ctx);
1947
1948 ixl_handle_vflr(pf);
1949 }
1950 #endif
1951
1952 static int
ixl_if_i2c_req(if_ctx_t ctx,struct ifi2creq * req)1953 ixl_if_i2c_req(if_ctx_t ctx, struct ifi2creq *req)
1954 {
1955 struct ixl_pf *pf = iflib_get_softc(ctx);
1956
1957 if (pf->read_i2c_byte == NULL)
1958 return (EINVAL);
1959
1960 for (int i = 0; i < req->len; i++)
1961 if (pf->read_i2c_byte(pf, req->offset + i,
1962 req->dev_addr, &req->data[i]))
1963 return (EIO);
1964 return (0);
1965 }
1966
1967 static int
ixl_if_priv_ioctl(if_ctx_t ctx,u_long command,caddr_t data)1968 ixl_if_priv_ioctl(if_ctx_t ctx, u_long command, caddr_t data)
1969 {
1970 struct ixl_pf *pf = iflib_get_softc(ctx);
1971 struct ifdrv *ifd = (struct ifdrv *)data;
1972 int error = 0;
1973
1974 /*
1975 * The iflib_if_ioctl forwards SIOCxDRVSPEC and SIOGPRIVATE_0 without
1976 * performing privilege checks. It is important that this function
1977 * perform the necessary checks for commands which should only be
1978 * executed by privileged threads.
1979 */
1980
1981 switch(command) {
1982 case SIOCGDRVSPEC:
1983 case SIOCSDRVSPEC:
1984 /* NVM update command */
1985 if (ifd->ifd_cmd == I40E_NVM_ACCESS) {
1986 error = priv_check(curthread, PRIV_DRIVER);
1987 if (error)
1988 break;
1989 error = ixl_handle_nvmupd_cmd(pf, ifd);
1990 } else {
1991 error = EINVAL;
1992 }
1993 break;
1994 default:
1995 error = EOPNOTSUPP;
1996 }
1997
1998 return (error);
1999 }
2000
2001 /* ixl_if_needs_restart - Tell iflib when the driver needs to be reinitialized
2002 * @ctx: iflib context
2003 * @event: event code to check
2004 *
2005 * Defaults to returning false for every event.
2006 *
2007 * @returns true if iflib needs to reinit the interface, false otherwise
2008 */
2009 static bool
ixl_if_needs_restart(if_ctx_t ctx __unused,enum iflib_restart_event event)2010 ixl_if_needs_restart(if_ctx_t ctx __unused, enum iflib_restart_event event)
2011 {
2012 switch (event) {
2013 case IFLIB_RESTART_VLAN_CONFIG:
2014 default:
2015 return (false);
2016 }
2017 }
2018
2019 static int
ixl_if_vf_status(if_ctx_t ctx,struct if_vf_status ** statusp)2020 ixl_if_vf_status(if_ctx_t ctx, struct if_vf_status **statusp)
2021 {
2022 struct ixl_pf *pf;
2023 struct if_vf_extension *extension;
2024 struct if_vf_info *info;
2025 struct if_vf_status *status;
2026 struct ixl_vf *vf;
2027
2028 pf = iflib_get_softc(ctx);
2029 if (!pf->iov_attached)
2030 return (EOPNOTSUPP);
2031
2032 status = if_vf_status_alloc(pf->num_vfs);
2033 if (status == NULL)
2034 return (ENOMEM);
2035 for (int i = 0; i < pf->num_vfs; i++) {
2036 vf = &pf->vfs[i];
2037 info = &status->vfs[i];
2038 info->fields = IFVF_F_CONFIGURED | IFVF_F_INITIALIZED |
2039 IFVF_F_VLAN_MODE | IFVF_F_VLAN_COUNT |
2040 IFVF_F_NUM_TX_QUEUES | IFVF_F_NUM_RX_QUEUES |
2041 IFVF_F_ALLOW_SET_MAC |
2042 IFVF_F_ALLOW_SET_VLAN | IFVF_F_MAC_ANTI_SPOOF |
2043 IFVF_F_ALLOW_PROMISC | IFVF_F_TRAFFIC_ALLOWED |
2044 IFVF_F_FAULT_BLOCKED;
2045 info->index = i;
2046 info->configured = (vf->vf_flags & VF_FLAG_ENABLED) != 0;
2047 info->initialized = (vf->vf_flags & VF_FLAG_INITIALIZED) != 0;
2048 if (info->initialized) {
2049 snprintf(info->api_version, sizeof(info->api_version),
2050 "%u.%u", vf->version.major, vf->version.minor);
2051 info->fields |= IFVF_F_API_VERSION;
2052 }
2053 if (!ETHER_IS_ZERO(vf->mac)) {
2054 memcpy(info->mac, vf->mac, sizeof(info->mac));
2055 info->fields |= IFVF_F_MAC;
2056 }
2057 if (vf->default_vlan == 0) {
2058 info->vlan_mode = IFVF_VLAN_TRUNK;
2059 info->vlan_count = vf->vsi.num_vlans;
2060 info->vlan_limit = IXL_VF_MAX_VLAN_FILTERS;
2061 info->fields |= IFVF_F_VLAN_LIMIT;
2062 } else {
2063 info->vlan_mode = IFVF_VLAN_ACCESS;
2064 info->vlan = vf->default_vlan;
2065 info->vlan_pcp = 0;
2066 info->vlan_proto = ETHERTYPE_VLAN;
2067 info->vlan_count = 1;
2068 info->fields |= IFVF_F_VLAN | IFVF_F_VLAN_PCP |
2069 IFVF_F_VLAN_PROTO;
2070 }
2071 info->tx_queue_count = vf->qtag.num_active;
2072 info->rx_queue_count = vf->qtag.num_active;
2073 info->allow_set_mac =
2074 (vf->vf_flags & VF_FLAG_SET_MAC_CAP) != 0;
2075 info->allow_set_vlan =
2076 (vf->vf_flags & VF_FLAG_VLAN_CAP) != 0;
2077 info->mac_anti_spoof =
2078 (vf->vf_flags & VF_FLAG_MAC_ANTI_SPOOF) != 0;
2079 info->allow_promisc =
2080 (vf->vf_flags & VF_FLAG_PROMISC_CAP) != 0;
2081 info->traffic_allowed = info->configured && !vf->mdd_blocked;
2082 info->fault_blocked = vf->mdd_blocked;
2083
2084 extension = if_vf_status_add_extension(info,
2085 IXL_VF_STATUS_NAMESPACE, IXL_VF_STATUS_VERSION,
2086 IXL_VF_STATUS_NUM_FIELDS);
2087 if (extension == NULL) {
2088 if_vf_status_free(status);
2089 return (ENOMEM);
2090 }
2091 if_vf_extension_set_bool(extension,
2092 IXL_VF_STATUS_FIELD_MDD_BLOCKED,
2093 IXL_VF_STATUS_MDD_BLOCKED, vf->mdd_blocked);
2094 if_vf_extension_set_number(extension,
2095 IXL_VF_STATUS_FIELD_MDD_TX_EVENTS,
2096 IXL_VF_STATUS_MDD_TX_EVENTS, vf->mdd_tx_events);
2097 if_vf_extension_set_number(extension,
2098 IXL_VF_STATUS_FIELD_MDD_RX_EVENTS,
2099 IXL_VF_STATUS_MDD_RX_EVENTS, vf->mdd_rx_events);
2100 }
2101 *statusp = status;
2102 return (0);
2103 }
2104
2105 /*
2106 * Sanity check and save off tunable values.
2107 */
2108 static void
ixl_save_pf_tunables(struct ixl_pf * pf)2109 ixl_save_pf_tunables(struct ixl_pf *pf)
2110 {
2111 device_t dev = pf->dev;
2112
2113 /* Save tunable information */
2114 #ifdef IXL_DEBUG_FC
2115 pf->enable_tx_fc_filter = ixl_enable_tx_fc_filter;
2116 #endif
2117 #ifdef IXL_DEBUG
2118 pf->recovery_mode = ixl_debug_recovery_mode;
2119 #endif
2120 pf->dbg_mask = ixl_core_debug_mask;
2121 pf->hw.debug_mask = ixl_shared_debug_mask;
2122 pf->vsi.enable_head_writeback = !!(ixl_enable_head_writeback);
2123 pf->enable_vf_loopback = !!(ixl_enable_vf_loopback);
2124 pf->mdd_auto_reset_vf = !!(ixl_mdd_auto_reset_vf);
2125 #if 0
2126 pf->dynamic_rx_itr = ixl_dynamic_rx_itr;
2127 pf->dynamic_tx_itr = ixl_dynamic_tx_itr;
2128 #endif
2129
2130 if (ixl_i2c_access_method > 3 || ixl_i2c_access_method < 0)
2131 pf->i2c_access_method = 0;
2132 else
2133 pf->i2c_access_method = ixl_i2c_access_method;
2134
2135 if (ixl_tx_itr < 0 || ixl_tx_itr > IXL_MAX_ITR) {
2136 device_printf(dev, "Invalid tx_itr value of %d set!\n",
2137 ixl_tx_itr);
2138 device_printf(dev, "tx_itr must be between %d and %d, "
2139 "inclusive\n",
2140 0, IXL_MAX_ITR);
2141 device_printf(dev, "Using default value of %d instead\n",
2142 IXL_ITR_4K);
2143 pf->tx_itr = IXL_ITR_4K;
2144 } else
2145 pf->tx_itr = ixl_tx_itr;
2146
2147 if (ixl_rx_itr < 0 || ixl_rx_itr > IXL_MAX_ITR) {
2148 device_printf(dev, "Invalid rx_itr value of %d set!\n",
2149 ixl_rx_itr);
2150 device_printf(dev, "rx_itr must be between %d and %d, "
2151 "inclusive\n",
2152 0, IXL_MAX_ITR);
2153 device_printf(dev, "Using default value of %d instead\n",
2154 IXL_ITR_8K);
2155 pf->rx_itr = IXL_ITR_8K;
2156 } else
2157 pf->rx_itr = ixl_rx_itr;
2158
2159 pf->fc = -1;
2160 if (ixl_flow_control != -1) {
2161 if (ixl_flow_control < 0 || ixl_flow_control > 3) {
2162 device_printf(dev,
2163 "Invalid flow_control value of %d set!\n",
2164 ixl_flow_control);
2165 device_printf(dev,
2166 "flow_control must be between %d and %d, "
2167 "inclusive\n", 0, 3);
2168 device_printf(dev,
2169 "Using default configuration instead\n");
2170 } else
2171 pf->fc = ixl_flow_control;
2172 }
2173 }
2174