1 /****************************************************************************** 2 3 Copyright (c) 2013-2015, 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 /*$FreeBSD$*/ 34 35 #include "ixl.h" 36 #include "ixl_pf.h" 37 38 #ifdef IXL_IW 39 #include "ixl_iw.h" 40 #include "ixl_iw_int.h" 41 #endif 42 43 #ifdef PCI_IOV 44 #include "ixl_pf_iov.h" 45 #endif 46 47 /********************************************************************* 48 * Driver version 49 *********************************************************************/ 50 char ixl_driver_version[] = "1.7.12-k"; 51 52 /********************************************************************* 53 * PCI Device ID Table 54 * 55 * Used by probe to select devices to load on 56 * Last field stores an index into ixl_strings 57 * Last entry must be all 0s 58 * 59 * { Vendor ID, Device ID, SubVendor ID, SubDevice ID, String Index } 60 *********************************************************************/ 61 62 static ixl_vendor_info_t ixl_vendor_info_array[] = 63 { 64 {I40E_INTEL_VENDOR_ID, I40E_DEV_ID_SFP_XL710, 0, 0, 0}, 65 {I40E_INTEL_VENDOR_ID, I40E_DEV_ID_KX_B, 0, 0, 0}, 66 {I40E_INTEL_VENDOR_ID, I40E_DEV_ID_KX_C, 0, 0, 0}, 67 {I40E_INTEL_VENDOR_ID, I40E_DEV_ID_QSFP_A, 0, 0, 0}, 68 {I40E_INTEL_VENDOR_ID, I40E_DEV_ID_QSFP_B, 0, 0, 0}, 69 {I40E_INTEL_VENDOR_ID, I40E_DEV_ID_QSFP_C, 0, 0, 0}, 70 {I40E_INTEL_VENDOR_ID, I40E_DEV_ID_10G_BASE_T, 0, 0, 0}, 71 {I40E_INTEL_VENDOR_ID, I40E_DEV_ID_10G_BASE_T4, 0, 0, 0}, 72 {I40E_INTEL_VENDOR_ID, I40E_DEV_ID_KX_X722, 0, 0, 0}, 73 {I40E_INTEL_VENDOR_ID, I40E_DEV_ID_QSFP_X722, 0, 0, 0}, 74 {I40E_INTEL_VENDOR_ID, I40E_DEV_ID_SFP_X722, 0, 0, 0}, 75 {I40E_INTEL_VENDOR_ID, I40E_DEV_ID_1G_BASE_T_X722, 0, 0, 0}, 76 {I40E_INTEL_VENDOR_ID, I40E_DEV_ID_10G_BASE_T_X722, 0, 0, 0}, 77 {I40E_INTEL_VENDOR_ID, I40E_DEV_ID_SFP_I_X722, 0, 0, 0}, 78 {I40E_INTEL_VENDOR_ID, I40E_DEV_ID_25G_B, 0, 0, 0}, 79 {I40E_INTEL_VENDOR_ID, I40E_DEV_ID_25G_SFP28, 0, 0, 0}, 80 /* required last entry */ 81 {0, 0, 0, 0, 0} 82 }; 83 84 /********************************************************************* 85 * Table of branding strings 86 *********************************************************************/ 87 88 static char *ixl_strings[] = { 89 "Intel(R) Ethernet Connection XL710/X722 Driver" 90 }; 91 92 93 /********************************************************************* 94 * Function prototypes 95 *********************************************************************/ 96 static int ixl_probe(device_t); 97 static int ixl_attach(device_t); 98 static int ixl_detach(device_t); 99 static int ixl_shutdown(device_t); 100 101 static int ixl_save_pf_tunables(struct ixl_pf *); 102 static int ixl_attach_get_link_status(struct ixl_pf *); 103 104 /********************************************************************* 105 * FreeBSD Device Interface Entry Points 106 *********************************************************************/ 107 108 static device_method_t ixl_methods[] = { 109 /* Device interface */ 110 DEVMETHOD(device_probe, ixl_probe), 111 DEVMETHOD(device_attach, ixl_attach), 112 DEVMETHOD(device_detach, ixl_detach), 113 DEVMETHOD(device_shutdown, ixl_shutdown), 114 #ifdef PCI_IOV 115 DEVMETHOD(pci_iov_init, ixl_iov_init), 116 DEVMETHOD(pci_iov_uninit, ixl_iov_uninit), 117 DEVMETHOD(pci_iov_add_vf, ixl_add_vf), 118 #endif 119 {0, 0} 120 }; 121 122 static driver_t ixl_driver = { 123 "ixl", ixl_methods, sizeof(struct ixl_pf), 124 }; 125 126 devclass_t ixl_devclass; 127 DRIVER_MODULE(ixl, pci, ixl_driver, ixl_devclass, 0, 0); 128 129 MODULE_VERSION(ixl, 1); 130 131 MODULE_DEPEND(ixl, pci, 1, 1, 1); 132 MODULE_DEPEND(ixl, ether, 1, 1, 1); 133 #if defined(DEV_NETMAP) && __FreeBSD_version >= 1100000 134 MODULE_DEPEND(ixl, netmap, 1, 1, 1); 135 #endif /* DEV_NETMAP */ 136 137 /* 138 ** TUNEABLE PARAMETERS: 139 */ 140 141 static SYSCTL_NODE(_hw, OID_AUTO, ixl, CTLFLAG_RD, 0, 142 "IXL driver parameters"); 143 144 /* 145 * MSIX should be the default for best performance, 146 * but this allows it to be forced off for testing. 147 */ 148 static int ixl_enable_msix = 1; 149 TUNABLE_INT("hw.ixl.enable_msix", &ixl_enable_msix); 150 SYSCTL_INT(_hw_ixl, OID_AUTO, enable_msix, CTLFLAG_RDTUN, &ixl_enable_msix, 0, 151 "Enable MSI-X interrupts"); 152 153 /* 154 ** Number of descriptors per ring: 155 ** - TX and RX are the same size 156 */ 157 static int ixl_ring_size = IXL_DEFAULT_RING; 158 TUNABLE_INT("hw.ixl.ring_size", &ixl_ring_size); 159 SYSCTL_INT(_hw_ixl, OID_AUTO, ring_size, CTLFLAG_RDTUN, 160 &ixl_ring_size, 0, "Descriptor Ring Size"); 161 162 /* 163 ** This can be set manually, if left as 0 the 164 ** number of queues will be calculated based 165 ** on cpus and msix vectors available. 166 */ 167 static int ixl_max_queues = 0; 168 TUNABLE_INT("hw.ixl.max_queues", &ixl_max_queues); 169 SYSCTL_INT(_hw_ixl, OID_AUTO, max_queues, CTLFLAG_RDTUN, 170 &ixl_max_queues, 0, "Number of Queues"); 171 172 static int ixl_enable_tx_fc_filter = 1; 173 TUNABLE_INT("hw.ixl.enable_tx_fc_filter", 174 &ixl_enable_tx_fc_filter); 175 SYSCTL_INT(_hw_ixl, OID_AUTO, enable_tx_fc_filter, CTLFLAG_RDTUN, 176 &ixl_enable_tx_fc_filter, 0, 177 "Filter out packets with Ethertype 0x8808 from being sent out by non-HW sources"); 178 179 static int ixl_core_debug_mask = 0; 180 TUNABLE_INT("hw.ixl.core_debug_mask", 181 &ixl_core_debug_mask); 182 SYSCTL_INT(_hw_ixl, OID_AUTO, core_debug_mask, CTLFLAG_RDTUN, 183 &ixl_core_debug_mask, 0, 184 "Display debug statements that are printed in non-shared code"); 185 186 static int ixl_shared_debug_mask = 0; 187 TUNABLE_INT("hw.ixl.shared_debug_mask", 188 &ixl_shared_debug_mask); 189 SYSCTL_INT(_hw_ixl, OID_AUTO, shared_debug_mask, CTLFLAG_RDTUN, 190 &ixl_shared_debug_mask, 0, 191 "Display debug statements that are printed in shared code"); 192 193 /* 194 ** Controls for Interrupt Throttling 195 ** - true/false for dynamic adjustment 196 ** - default values for static ITR 197 */ 198 static int ixl_dynamic_rx_itr = 1; 199 TUNABLE_INT("hw.ixl.dynamic_rx_itr", &ixl_dynamic_rx_itr); 200 SYSCTL_INT(_hw_ixl, OID_AUTO, dynamic_rx_itr, CTLFLAG_RDTUN, 201 &ixl_dynamic_rx_itr, 0, "Dynamic RX Interrupt Rate"); 202 203 static int ixl_dynamic_tx_itr = 1; 204 TUNABLE_INT("hw.ixl.dynamic_tx_itr", &ixl_dynamic_tx_itr); 205 SYSCTL_INT(_hw_ixl, OID_AUTO, dynamic_tx_itr, CTLFLAG_RDTUN, 206 &ixl_dynamic_tx_itr, 0, "Dynamic TX Interrupt Rate"); 207 208 static int ixl_rx_itr = IXL_ITR_8K; 209 TUNABLE_INT("hw.ixl.rx_itr", &ixl_rx_itr); 210 SYSCTL_INT(_hw_ixl, OID_AUTO, rx_itr, CTLFLAG_RDTUN, 211 &ixl_rx_itr, 0, "RX Interrupt Rate"); 212 213 static int ixl_tx_itr = IXL_ITR_4K; 214 TUNABLE_INT("hw.ixl.tx_itr", &ixl_tx_itr); 215 SYSCTL_INT(_hw_ixl, OID_AUTO, tx_itr, CTLFLAG_RDTUN, 216 &ixl_tx_itr, 0, "TX Interrupt Rate"); 217 218 #ifdef IXL_IW 219 int ixl_enable_iwarp = 0; 220 TUNABLE_INT("hw.ixl.enable_iwarp", &ixl_enable_iwarp); 221 #endif 222 223 #ifdef DEV_NETMAP 224 #define NETMAP_IXL_MAIN /* only bring in one part of the netmap code */ 225 #include <dev/netmap/if_ixl_netmap.h> 226 #endif /* DEV_NETMAP */ 227 228 /********************************************************************* 229 * Device identification routine 230 * 231 * ixl_probe determines if the driver should be loaded on 232 * the hardware based on PCI vendor/device id of the device. 233 * 234 * return BUS_PROBE_DEFAULT on success, positive on failure 235 *********************************************************************/ 236 237 static int 238 ixl_probe(device_t dev) 239 { 240 ixl_vendor_info_t *ent; 241 242 u16 pci_vendor_id, pci_device_id; 243 u16 pci_subvendor_id, pci_subdevice_id; 244 char device_name[256]; 245 246 #if 0 247 INIT_DEBUGOUT("ixl_probe: begin"); 248 #endif 249 pci_vendor_id = pci_get_vendor(dev); 250 if (pci_vendor_id != I40E_INTEL_VENDOR_ID) 251 return (ENXIO); 252 253 pci_device_id = pci_get_device(dev); 254 pci_subvendor_id = pci_get_subvendor(dev); 255 pci_subdevice_id = pci_get_subdevice(dev); 256 257 ent = ixl_vendor_info_array; 258 while (ent->vendor_id != 0) { 259 if ((pci_vendor_id == ent->vendor_id) && 260 (pci_device_id == ent->device_id) && 261 262 ((pci_subvendor_id == ent->subvendor_id) || 263 (ent->subvendor_id == 0)) && 264 265 ((pci_subdevice_id == ent->subdevice_id) || 266 (ent->subdevice_id == 0))) { 267 sprintf(device_name, "%s, Version - %s", 268 ixl_strings[ent->index], 269 ixl_driver_version); 270 device_set_desc_copy(dev, device_name); 271 return (BUS_PROBE_DEFAULT); 272 } 273 ent++; 274 } 275 return (ENXIO); 276 } 277 278 static int 279 ixl_attach_get_link_status(struct ixl_pf *pf) 280 { 281 struct i40e_hw *hw = &pf->hw; 282 device_t dev = pf->dev; 283 int error = 0; 284 285 if (((hw->aq.fw_maj_ver == 4) && (hw->aq.fw_min_ver < 33)) || 286 (hw->aq.fw_maj_ver < 4)) { 287 i40e_msec_delay(75); 288 error = i40e_aq_set_link_restart_an(hw, TRUE, NULL); 289 if (error) { 290 device_printf(dev, "link restart failed, aq_err=%d\n", 291 pf->hw.aq.asq_last_status); 292 return error; 293 } 294 } 295 296 /* Determine link state */ 297 hw->phy.get_link_info = TRUE; 298 i40e_get_link_status(hw, &pf->link_up); 299 return (0); 300 } 301 302 /* 303 * Sanity check and save off tunable values. 304 */ 305 static int 306 ixl_save_pf_tunables(struct ixl_pf *pf) 307 { 308 device_t dev = pf->dev; 309 310 /* Save tunable information */ 311 pf->enable_msix = ixl_enable_msix; 312 pf->max_queues = ixl_max_queues; 313 pf->enable_tx_fc_filter = ixl_enable_tx_fc_filter; 314 pf->dynamic_rx_itr = ixl_dynamic_rx_itr; 315 pf->dynamic_tx_itr = ixl_dynamic_tx_itr; 316 pf->dbg_mask = ixl_core_debug_mask; 317 pf->hw.debug_mask = ixl_shared_debug_mask; 318 319 if (ixl_ring_size < IXL_MIN_RING 320 || ixl_ring_size > IXL_MAX_RING 321 || ixl_ring_size % IXL_RING_INCREMENT != 0) { 322 device_printf(dev, "Invalid ring_size value of %d set!\n", 323 ixl_ring_size); 324 device_printf(dev, "ring_size must be between %d and %d, " 325 "inclusive, and must be a multiple of %d\n", 326 IXL_MIN_RING, IXL_MAX_RING, IXL_RING_INCREMENT); 327 device_printf(dev, "Using default value of %d instead\n", 328 IXL_DEFAULT_RING); 329 pf->ringsz = IXL_DEFAULT_RING; 330 } else 331 pf->ringsz = ixl_ring_size; 332 333 if (ixl_tx_itr < 0 || ixl_tx_itr > IXL_MAX_ITR) { 334 device_printf(dev, "Invalid tx_itr value of %d set!\n", 335 ixl_tx_itr); 336 device_printf(dev, "tx_itr must be between %d and %d, " 337 "inclusive\n", 338 0, IXL_MAX_ITR); 339 device_printf(dev, "Using default value of %d instead\n", 340 IXL_ITR_4K); 341 pf->tx_itr = IXL_ITR_4K; 342 } else 343 pf->tx_itr = ixl_tx_itr; 344 345 if (ixl_rx_itr < 0 || ixl_rx_itr > IXL_MAX_ITR) { 346 device_printf(dev, "Invalid rx_itr value of %d set!\n", 347 ixl_rx_itr); 348 device_printf(dev, "rx_itr must be between %d and %d, " 349 "inclusive\n", 350 0, IXL_MAX_ITR); 351 device_printf(dev, "Using default value of %d instead\n", 352 IXL_ITR_8K); 353 pf->rx_itr = IXL_ITR_8K; 354 } else 355 pf->rx_itr = ixl_rx_itr; 356 357 return (0); 358 } 359 360 /********************************************************************* 361 * Device initialization routine 362 * 363 * The attach entry point is called when the driver is being loaded. 364 * This routine identifies the type of hardware, allocates all resources 365 * and initializes the hardware. 366 * 367 * return 0 on success, positive on failure 368 *********************************************************************/ 369 370 static int 371 ixl_attach(device_t dev) 372 { 373 struct ixl_pf *pf; 374 struct i40e_hw *hw; 375 struct ixl_vsi *vsi; 376 enum i40e_status_code status; 377 int error = 0; 378 379 INIT_DEBUGOUT("ixl_attach: begin"); 380 381 /* Allocate, clear, and link in our primary soft structure */ 382 pf = device_get_softc(dev); 383 pf->dev = pf->osdep.dev = dev; 384 hw = &pf->hw; 385 386 /* 387 ** Note this assumes we have a single embedded VSI, 388 ** this could be enhanced later to allocate multiple 389 */ 390 vsi = &pf->vsi; 391 vsi->dev = pf->dev; 392 393 /* Save tunable values */ 394 error = ixl_save_pf_tunables(pf); 395 if (error) 396 return (error); 397 398 /* Core Lock Init*/ 399 IXL_PF_LOCK_INIT(pf, device_get_nameunit(dev)); 400 401 /* Set up the timer callout */ 402 callout_init_mtx(&pf->timer, &pf->pf_mtx, 0); 403 404 /* Do PCI setup - map BAR0, etc */ 405 if (ixl_allocate_pci_resources(pf)) { 406 device_printf(dev, "Allocation of PCI resources failed\n"); 407 error = ENXIO; 408 goto err_out; 409 } 410 411 /* Establish a clean starting point */ 412 i40e_clear_hw(hw); 413 status = i40e_pf_reset(hw); 414 if (status) { 415 device_printf(dev, "PF reset failure %s\n", 416 i40e_stat_str(hw, status)); 417 error = EIO; 418 goto err_out; 419 } 420 421 /* Initialize the shared code */ 422 status = i40e_init_shared_code(hw); 423 if (status) { 424 device_printf(dev, "Unable to initialize shared code, error %s\n", 425 i40e_stat_str(hw, status)); 426 error = EIO; 427 goto err_out; 428 } 429 430 /* 431 * Allocate interrupts and figure out number of queues to use 432 * for PF interface 433 */ 434 pf->msix = ixl_init_msix(pf); 435 436 /* Set up the admin queue */ 437 hw->aq.num_arq_entries = IXL_AQ_LEN; 438 hw->aq.num_asq_entries = IXL_AQ_LEN; 439 hw->aq.arq_buf_size = IXL_AQ_BUF_SZ; 440 hw->aq.asq_buf_size = IXL_AQ_BUF_SZ; 441 442 status = i40e_init_adminq(hw); 443 if (status != 0 && status != I40E_ERR_FIRMWARE_API_VERSION) { 444 device_printf(dev, "Unable to initialize Admin Queue, error %s\n", 445 i40e_stat_str(hw, status)); 446 error = EIO; 447 goto err_out; 448 } 449 ixl_print_nvm_version(pf); 450 451 if (status == I40E_ERR_FIRMWARE_API_VERSION) { 452 device_printf(dev, "The driver for the device stopped " 453 "because the NVM image is newer than expected.\n" 454 "You must install the most recent version of " 455 "the network driver.\n"); 456 error = EIO; 457 goto err_out; 458 } 459 460 if (hw->aq.api_maj_ver == I40E_FW_API_VERSION_MAJOR && 461 hw->aq.api_min_ver > I40E_FW_API_VERSION_MINOR) 462 device_printf(dev, "The driver for the device detected " 463 "a newer version of the NVM image than expected.\n" 464 "Please install the most recent version of the network driver.\n"); 465 else if (hw->aq.api_maj_ver < I40E_FW_API_VERSION_MAJOR || 466 hw->aq.api_min_ver < (I40E_FW_API_VERSION_MINOR - 1)) 467 device_printf(dev, "The driver for the device detected " 468 "an older version of the NVM image than expected.\n" 469 "Please update the NVM image.\n"); 470 471 /* Clear PXE mode */ 472 i40e_clear_pxe_mode(hw); 473 474 /* Get capabilities from the device */ 475 error = ixl_get_hw_capabilities(pf); 476 if (error) { 477 device_printf(dev, "HW capabilities failure!\n"); 478 goto err_get_cap; 479 } 480 481 /* Set up host memory cache */ 482 status = i40e_init_lan_hmc(hw, hw->func_caps.num_tx_qp, 483 hw->func_caps.num_rx_qp, 0, 0); 484 if (status) { 485 device_printf(dev, "init_lan_hmc failed: %s\n", 486 i40e_stat_str(hw, status)); 487 goto err_get_cap; 488 } 489 490 status = i40e_configure_lan_hmc(hw, I40E_HMC_MODEL_DIRECT_ONLY); 491 if (status) { 492 device_printf(dev, "configure_lan_hmc failed: %s\n", 493 i40e_stat_str(hw, status)); 494 goto err_mac_hmc; 495 } 496 497 /* Init queue allocation manager */ 498 error = ixl_pf_qmgr_init(&pf->qmgr, hw->func_caps.num_tx_qp); 499 if (error) { 500 device_printf(dev, "Failed to init queue manager for PF queues, error %d\n", 501 error); 502 goto err_mac_hmc; 503 } 504 /* reserve a contiguous allocation for the PF's VSI */ 505 error = ixl_pf_qmgr_alloc_contiguous(&pf->qmgr, vsi->num_queues, &pf->qtag); 506 if (error) { 507 device_printf(dev, "Failed to reserve queues for PF LAN VSI, error %d\n", 508 error); 509 goto err_mac_hmc; 510 } 511 device_printf(dev, "Allocating %d queues for PF LAN VSI; %d queues active\n", 512 pf->qtag.num_allocated, pf->qtag.num_active); 513 514 /* Disable LLDP from the firmware for certain NVM versions */ 515 if (((pf->hw.aq.fw_maj_ver == 4) && (pf->hw.aq.fw_min_ver < 3)) || 516 (pf->hw.aq.fw_maj_ver < 4)) 517 i40e_aq_stop_lldp(hw, TRUE, NULL); 518 519 /* Get MAC addresses from hardware */ 520 i40e_get_mac_addr(hw, hw->mac.addr); 521 error = i40e_validate_mac_addr(hw->mac.addr); 522 if (error) { 523 device_printf(dev, "validate_mac_addr failed: %d\n", error); 524 goto err_mac_hmc; 525 } 526 bcopy(hw->mac.addr, hw->mac.perm_addr, ETHER_ADDR_LEN); 527 i40e_get_port_mac_addr(hw, hw->mac.port_addr); 528 529 /* Initialize mac filter list for VSI */ 530 SLIST_INIT(&vsi->ftl); 531 532 /* Set up SW VSI and allocate queue memory and rings */ 533 if (ixl_setup_stations(pf)) { 534 device_printf(dev, "setup stations failed!\n"); 535 error = ENOMEM; 536 goto err_mac_hmc; 537 } 538 539 /* Setup OS network interface / ifnet */ 540 if (ixl_setup_interface(dev, vsi)) { 541 device_printf(dev, "interface setup failed!\n"); 542 error = EIO; 543 goto err_late; 544 } 545 546 /* Determine link state */ 547 if (ixl_attach_get_link_status(pf)) { 548 error = EINVAL; 549 goto err_late; 550 } 551 552 error = ixl_switch_config(pf); 553 if (error) { 554 device_printf(dev, "Initial ixl_switch_config() failed: %d\n", 555 error); 556 goto err_late; 557 } 558 559 /* Limit PHY interrupts to link, autoneg, and modules failure */ 560 status = i40e_aq_set_phy_int_mask(hw, IXL_DEFAULT_PHY_INT_MASK, 561 NULL); 562 if (status) { 563 device_printf(dev, "i40e_aq_set_phy_mask() failed: err %s," 564 " aq_err %s\n", i40e_stat_str(hw, status), 565 i40e_aq_str(hw, hw->aq.asq_last_status)); 566 goto err_late; 567 } 568 569 /* Get the bus configuration and set the shared code's config */ 570 ixl_get_bus_info(pf); 571 572 /* 573 * In MSI-X mode, initialize the Admin Queue interrupt, 574 * so userland tools can communicate with the adapter regardless of 575 * the ifnet interface's status. 576 */ 577 if (pf->msix > 1) { 578 error = ixl_setup_adminq_msix(pf); 579 if (error) { 580 device_printf(dev, "ixl_setup_adminq_msix() error: %d\n", 581 error); 582 goto err_late; 583 } 584 error = ixl_setup_adminq_tq(pf); 585 if (error) { 586 device_printf(dev, "ixl_setup_adminq_tq() error: %d\n", 587 error); 588 goto err_late; 589 } 590 ixl_configure_intr0_msix(pf); 591 ixl_enable_intr0(hw); 592 593 error = ixl_setup_queue_msix(vsi); 594 if (error) 595 device_printf(dev, "ixl_setup_queue_msix() error: %d\n", 596 error); 597 error = ixl_setup_queue_tqs(vsi); 598 if (error) 599 device_printf(dev, "ixl_setup_queue_tqs() error: %d\n", 600 error); 601 } else { 602 error = ixl_setup_legacy(pf); 603 604 error = ixl_setup_adminq_tq(pf); 605 if (error) { 606 device_printf(dev, "ixl_setup_adminq_tq() error: %d\n", 607 error); 608 goto err_late; 609 } 610 611 error = ixl_setup_queue_tqs(vsi); 612 if (error) 613 device_printf(dev, "ixl_setup_queue_tqs() error: %d\n", 614 error); 615 } 616 617 if (error) { 618 device_printf(dev, "interrupt setup error: %d\n", error); 619 } 620 621 /* Set initial advertised speed sysctl value */ 622 ixl_get_initial_advertised_speeds(pf); 623 624 /* Initialize statistics & add sysctls */ 625 ixl_add_device_sysctls(pf); 626 627 ixl_pf_reset_stats(pf); 628 ixl_update_stats_counters(pf); 629 ixl_add_hw_stats(pf); 630 631 /* Register for VLAN events */ 632 vsi->vlan_attach = EVENTHANDLER_REGISTER(vlan_config, 633 ixl_register_vlan, vsi, EVENTHANDLER_PRI_FIRST); 634 vsi->vlan_detach = EVENTHANDLER_REGISTER(vlan_unconfig, 635 ixl_unregister_vlan, vsi, EVENTHANDLER_PRI_FIRST); 636 637 #ifdef PCI_IOV 638 ixl_initialize_sriov(pf); 639 #endif 640 641 #ifdef DEV_NETMAP 642 ixl_netmap_attach(vsi); 643 #endif /* DEV_NETMAP */ 644 645 #ifdef IXL_IW 646 if (hw->func_caps.iwarp && ixl_enable_iwarp) { 647 pf->iw_enabled = (pf->iw_msix > 0) ? true : false; 648 if (pf->iw_enabled) { 649 error = ixl_iw_pf_attach(pf); 650 if (error) { 651 device_printf(dev, 652 "interfacing to iwarp driver failed: %d\n", 653 error); 654 goto err_late; 655 } 656 } else 657 device_printf(dev, 658 "iwarp disabled on this device (no msix vectors)\n"); 659 } else { 660 pf->iw_enabled = false; 661 device_printf(dev, "The device is not iWARP enabled\n"); 662 } 663 #endif 664 665 INIT_DEBUGOUT("ixl_attach: end"); 666 return (0); 667 668 err_late: 669 if (vsi->ifp != NULL) { 670 ether_ifdetach(vsi->ifp); 671 if_free(vsi->ifp); 672 } 673 err_mac_hmc: 674 i40e_shutdown_lan_hmc(hw); 675 err_get_cap: 676 i40e_shutdown_adminq(hw); 677 err_out: 678 ixl_free_pci_resources(pf); 679 ixl_free_vsi(vsi); 680 IXL_PF_LOCK_DESTROY(pf); 681 return (error); 682 } 683 684 /********************************************************************* 685 * Device removal routine 686 * 687 * The detach entry point is called when the driver is being removed. 688 * This routine stops the adapter and deallocates all the resources 689 * that were allocated for driver operation. 690 * 691 * return 0 on success, positive on failure 692 *********************************************************************/ 693 694 static int 695 ixl_detach(device_t dev) 696 { 697 struct ixl_pf *pf = device_get_softc(dev); 698 struct i40e_hw *hw = &pf->hw; 699 struct ixl_vsi *vsi = &pf->vsi; 700 enum i40e_status_code status; 701 #if defined(PCI_IOV) || defined(IXL_IW) 702 int error; 703 #endif 704 705 INIT_DEBUGOUT("ixl_detach: begin"); 706 707 /* Make sure VLANS are not using driver */ 708 if (vsi->ifp->if_vlantrunk != NULL) { 709 device_printf(dev, "Vlan in use, detach first\n"); 710 return (EBUSY); 711 } 712 713 #ifdef PCI_IOV 714 error = pci_iov_detach(dev); 715 if (error != 0) { 716 device_printf(dev, "SR-IOV in use; detach first.\n"); 717 return (error); 718 } 719 #endif 720 721 ether_ifdetach(vsi->ifp); 722 if (vsi->ifp->if_drv_flags & IFF_DRV_RUNNING) 723 ixl_stop(pf); 724 725 /* Shutdown LAN HMC */ 726 status = i40e_shutdown_lan_hmc(hw); 727 if (status) 728 device_printf(dev, 729 "Shutdown LAN HMC failed with code %d\n", status); 730 731 /* Teardown LAN queue resources */ 732 ixl_teardown_queue_msix(vsi); 733 ixl_free_queue_tqs(vsi); 734 /* Shutdown admin queue */ 735 ixl_disable_intr0(hw); 736 ixl_teardown_adminq_msix(pf); 737 ixl_free_adminq_tq(pf); 738 status = i40e_shutdown_adminq(hw); 739 if (status) 740 device_printf(dev, 741 "Shutdown Admin queue failed with code %d\n", status); 742 743 /* Unregister VLAN events */ 744 if (vsi->vlan_attach != NULL) 745 EVENTHANDLER_DEREGISTER(vlan_config, vsi->vlan_attach); 746 if (vsi->vlan_detach != NULL) 747 EVENTHANDLER_DEREGISTER(vlan_unconfig, vsi->vlan_detach); 748 749 callout_drain(&pf->timer); 750 751 #ifdef IXL_IW 752 if (ixl_enable_iwarp && pf->iw_enabled) { 753 error = ixl_iw_pf_detach(pf); 754 if (error == EBUSY) { 755 device_printf(dev, "iwarp in use; stop it first.\n"); 756 return (error); 757 } 758 } 759 #endif 760 761 #ifdef DEV_NETMAP 762 netmap_detach(vsi->ifp); 763 #endif /* DEV_NETMAP */ 764 ixl_pf_qmgr_destroy(&pf->qmgr); 765 ixl_free_pci_resources(pf); 766 bus_generic_detach(dev); 767 if_free(vsi->ifp); 768 ixl_free_vsi(vsi); 769 IXL_PF_LOCK_DESTROY(pf); 770 return (0); 771 } 772 773 /********************************************************************* 774 * 775 * Shutdown entry point 776 * 777 **********************************************************************/ 778 779 static int 780 ixl_shutdown(device_t dev) 781 { 782 struct ixl_pf *pf = device_get_softc(dev); 783 ixl_stop(pf); 784 return (0); 785 } 786 787