1// SPDX-License-Identifier: GPL-2.0 2/* Copyright(c) 1999 - 2018 Intel Corporation. */ 3 4#include <linux/pci.h> 5#include <linux/delay.h> 6#include <linux/sched.h> 7 8#include "ixgbe.h" 9#include "ixgbe_phy.h" 10#include "ixgbe_mbx.h" 11 12#define IXGBE_82599_MAX_TX_QUEUES 128 13#define IXGBE_82599_MAX_RX_QUEUES 128 14#define IXGBE_82599_RAR_ENTRIES 128 15#define IXGBE_82599_MC_TBL_SIZE 128 16#define IXGBE_82599_VFT_TBL_SIZE 128 17#define IXGBE_82599_RX_PB_SIZE 512 18 19static void ixgbe_disable_tx_laser_multispeed_fiber(struct ixgbe_hw *hw); 20static void ixgbe_enable_tx_laser_multispeed_fiber(struct ixgbe_hw *hw); 21static void ixgbe_flap_tx_laser_multispeed_fiber(struct ixgbe_hw *hw); 22static void 23ixgbe_set_hard_rate_select_speed(struct ixgbe_hw *, ixgbe_link_speed); 24static int ixgbe_setup_mac_link_smartspeed(struct ixgbe_hw *hw, 25 ixgbe_link_speed speed, 26 bool autoneg_wait_to_complete); 27static void ixgbe_stop_mac_link_on_d3_82599(struct ixgbe_hw *hw); 28static int ixgbe_start_mac_link_82599(struct ixgbe_hw *hw, 29 bool autoneg_wait_to_complete); 30static int ixgbe_setup_mac_link_82599(struct ixgbe_hw *hw, 31 ixgbe_link_speed speed, 32 bool autoneg_wait_to_complete); 33static int ixgbe_setup_copper_link_82599(struct ixgbe_hw *hw, 34 ixgbe_link_speed speed, 35 bool autoneg_wait_to_complete); 36static int ixgbe_verify_fw_version_82599(struct ixgbe_hw *hw); 37static int ixgbe_read_i2c_byte_82599(struct ixgbe_hw *hw, u8 byte_offset, 38 u8 dev_addr, u8 *data); 39static int ixgbe_write_i2c_byte_82599(struct ixgbe_hw *hw, u8 byte_offset, 40 u8 dev_addr, u8 data); 41static int ixgbe_reset_pipeline_82599(struct ixgbe_hw *hw); 42static bool ixgbe_verify_lesm_fw_enabled_82599(struct ixgbe_hw *hw); 43 44bool ixgbe_mng_enabled(struct ixgbe_hw *hw) 45{ 46 u32 fwsm, manc, factps; 47 48 fwsm = IXGBE_READ_REG(hw, IXGBE_FWSM(hw)); 49 if ((fwsm & IXGBE_FWSM_MODE_MASK) != IXGBE_FWSM_FW_MODE_PT) 50 return false; 51 52 manc = IXGBE_READ_REG(hw, IXGBE_MANC); 53 if (!(manc & IXGBE_MANC_RCV_TCO_EN)) 54 return false; 55 56 factps = IXGBE_READ_REG(hw, IXGBE_FACTPS(hw)); 57 if (factps & IXGBE_FACTPS_MNGCG) 58 return false; 59 60 return true; 61} 62 63static void ixgbe_init_mac_link_ops_82599(struct ixgbe_hw *hw) 64{ 65 struct ixgbe_mac_info *mac = &hw->mac; 66 67 /* enable the laser control functions for SFP+ fiber 68 * and MNG not enabled 69 */ 70 if ((mac->ops.get_media_type(hw) == ixgbe_media_type_fiber) && 71 !ixgbe_mng_enabled(hw)) { 72 mac->ops.disable_tx_laser = 73 &ixgbe_disable_tx_laser_multispeed_fiber; 74 mac->ops.enable_tx_laser = 75 &ixgbe_enable_tx_laser_multispeed_fiber; 76 mac->ops.flap_tx_laser = &ixgbe_flap_tx_laser_multispeed_fiber; 77 } else { 78 mac->ops.disable_tx_laser = NULL; 79 mac->ops.enable_tx_laser = NULL; 80 mac->ops.flap_tx_laser = NULL; 81 } 82 83 if (hw->phy.multispeed_fiber) { 84 /* Set up dual speed SFP+ support */ 85 mac->ops.setup_link = &ixgbe_setup_mac_link_multispeed_fiber; 86 mac->ops.setup_mac_link = ixgbe_setup_mac_link_82599; 87 mac->ops.set_rate_select_speed = 88 ixgbe_set_hard_rate_select_speed; 89 } else { 90 if ((mac->ops.get_media_type(hw) == 91 ixgbe_media_type_backplane) && 92 (hw->phy.smart_speed == ixgbe_smart_speed_auto || 93 hw->phy.smart_speed == ixgbe_smart_speed_on) && 94 !ixgbe_verify_lesm_fw_enabled_82599(hw)) 95 mac->ops.setup_link = &ixgbe_setup_mac_link_smartspeed; 96 else 97 mac->ops.setup_link = &ixgbe_setup_mac_link_82599; 98 } 99} 100 101static int ixgbe_setup_sfp_modules_82599(struct ixgbe_hw *hw) 102{ 103 u16 list_offset, data_offset, data_value; 104 int ret_val; 105 106 if (hw->phy.sfp_type != ixgbe_sfp_type_unknown) { 107 ixgbe_init_mac_link_ops_82599(hw); 108 109 hw->phy.ops.reset = NULL; 110 111 ret_val = ixgbe_get_sfp_init_sequence_offsets(hw, &list_offset, 112 &data_offset); 113 if (ret_val) 114 return ret_val; 115 116 /* PHY config will finish before releasing the semaphore */ 117 ret_val = hw->mac.ops.acquire_swfw_sync(hw, 118 IXGBE_GSSR_MAC_CSR_SM); 119 if (ret_val) 120 return -EBUSY; 121 122 if (hw->eeprom.ops.read(hw, ++data_offset, &data_value)) 123 goto setup_sfp_err; 124 while (data_value != 0xffff) { 125 IXGBE_WRITE_REG(hw, IXGBE_CORECTL, data_value); 126 IXGBE_WRITE_FLUSH(hw); 127 if (hw->eeprom.ops.read(hw, ++data_offset, &data_value)) 128 goto setup_sfp_err; 129 } 130 131 /* Release the semaphore */ 132 hw->mac.ops.release_swfw_sync(hw, IXGBE_GSSR_MAC_CSR_SM); 133 /* 134 * Delay obtaining semaphore again to allow FW access, 135 * semaphore_delay is in ms usleep_range needs us. 136 */ 137 usleep_range(hw->eeprom.semaphore_delay * 1000, 138 hw->eeprom.semaphore_delay * 2000); 139 140 /* Restart DSP and set SFI mode */ 141 ret_val = hw->mac.ops.prot_autoc_write(hw, 142 hw->mac.orig_autoc | IXGBE_AUTOC_LMS_10G_SERIAL, 143 false); 144 145 if (ret_val) { 146 hw_dbg(hw, " sfp module setup not complete\n"); 147 return -EIO; 148 } 149 } 150 151 return 0; 152 153setup_sfp_err: 154 /* Release the semaphore */ 155 hw->mac.ops.release_swfw_sync(hw, IXGBE_GSSR_MAC_CSR_SM); 156 /* Delay obtaining semaphore again to allow FW access, 157 * semaphore_delay is in ms usleep_range needs us. 158 */ 159 usleep_range(hw->eeprom.semaphore_delay * 1000, 160 hw->eeprom.semaphore_delay * 2000); 161 hw_err(hw, "eeprom read at offset %d failed\n", data_offset); 162 return -EIO; 163} 164 165/** 166 * prot_autoc_read_82599 - Hides MAC differences needed for AUTOC read 167 * @hw: pointer to hardware structure 168 * @locked: Return the if we locked for this read. 169 * @reg_val: Value we read from AUTOC 170 * 171 * For this part (82599) we need to wrap read-modify-writes with a possible 172 * FW/SW lock. It is assumed this lock will be freed with the next 173 * prot_autoc_write_82599(). Note, that locked can only be true in cases 174 * where this function doesn't return an error. 175 **/ 176static int prot_autoc_read_82599(struct ixgbe_hw *hw, bool *locked, 177 u32 *reg_val) 178{ 179 int ret_val; 180 181 *locked = false; 182 /* If LESM is on then we need to hold the SW/FW semaphore. */ 183 if (ixgbe_verify_lesm_fw_enabled_82599(hw)) { 184 ret_val = hw->mac.ops.acquire_swfw_sync(hw, 185 IXGBE_GSSR_MAC_CSR_SM); 186 if (ret_val) 187 return -EBUSY; 188 189 *locked = true; 190 } 191 192 *reg_val = IXGBE_READ_REG(hw, IXGBE_AUTOC); 193 return 0; 194} 195 196/** 197 * prot_autoc_write_82599 - Hides MAC differences needed for AUTOC write 198 * @hw: pointer to hardware structure 199 * @autoc: value to write to AUTOC 200 * @locked: bool to indicate whether the SW/FW lock was already taken by 201 * previous proc_autoc_read_82599. 202 * 203 * This part (82599) may need to hold a the SW/FW lock around all writes to 204 * AUTOC. Likewise after a write we need to do a pipeline reset. 205 **/ 206static int prot_autoc_write_82599(struct ixgbe_hw *hw, u32 autoc, bool locked) 207{ 208 int ret_val = 0; 209 210 /* Blocked by MNG FW so bail */ 211 if (ixgbe_check_reset_blocked(hw)) 212 goto out; 213 214 /* We only need to get the lock if: 215 * - We didn't do it already (in the read part of a read-modify-write) 216 * - LESM is enabled. 217 */ 218 if (!locked && ixgbe_verify_lesm_fw_enabled_82599(hw)) { 219 ret_val = hw->mac.ops.acquire_swfw_sync(hw, 220 IXGBE_GSSR_MAC_CSR_SM); 221 if (ret_val) 222 return -EBUSY; 223 224 locked = true; 225 } 226 227 IXGBE_WRITE_REG(hw, IXGBE_AUTOC, autoc); 228 ret_val = ixgbe_reset_pipeline_82599(hw); 229 230out: 231 /* Free the SW/FW semaphore as we either grabbed it here or 232 * already had it when this function was called. 233 */ 234 if (locked) 235 hw->mac.ops.release_swfw_sync(hw, IXGBE_GSSR_MAC_CSR_SM); 236 237 return ret_val; 238} 239 240static int ixgbe_get_invariants_82599(struct ixgbe_hw *hw) 241{ 242 struct ixgbe_mac_info *mac = &hw->mac; 243 244 ixgbe_init_mac_link_ops_82599(hw); 245 246 mac->mcft_size = IXGBE_82599_MC_TBL_SIZE; 247 mac->vft_size = IXGBE_82599_VFT_TBL_SIZE; 248 mac->num_rar_entries = IXGBE_82599_RAR_ENTRIES; 249 mac->rx_pb_size = IXGBE_82599_RX_PB_SIZE; 250 mac->max_rx_queues = IXGBE_82599_MAX_RX_QUEUES; 251 mac->max_tx_queues = IXGBE_82599_MAX_TX_QUEUES; 252 mac->max_msix_vectors = ixgbe_get_pcie_msix_count_generic(hw); 253 254 return 0; 255} 256 257/** 258 * ixgbe_init_phy_ops_82599 - PHY/SFP specific init 259 * @hw: pointer to hardware structure 260 * 261 * Initialize any function pointers that were not able to be 262 * set during get_invariants because the PHY/SFP type was 263 * not known. Perform the SFP init if necessary. 264 * 265 **/ 266static int ixgbe_init_phy_ops_82599(struct ixgbe_hw *hw) 267{ 268 struct ixgbe_mac_info *mac = &hw->mac; 269 struct ixgbe_phy_info *phy = &hw->phy; 270 int ret_val; 271 u32 esdp; 272 273 if (hw->device_id == IXGBE_DEV_ID_82599_QSFP_SF_QP) { 274 /* Store flag indicating I2C bus access control unit. */ 275 hw->phy.qsfp_shared_i2c_bus = true; 276 277 /* Initialize access to QSFP+ I2C bus */ 278 esdp = IXGBE_READ_REG(hw, IXGBE_ESDP); 279 esdp |= IXGBE_ESDP_SDP0_DIR; 280 esdp &= ~IXGBE_ESDP_SDP1_DIR; 281 esdp &= ~IXGBE_ESDP_SDP0; 282 esdp &= ~IXGBE_ESDP_SDP0_NATIVE; 283 esdp &= ~IXGBE_ESDP_SDP1_NATIVE; 284 IXGBE_WRITE_REG(hw, IXGBE_ESDP, esdp); 285 IXGBE_WRITE_FLUSH(hw); 286 287 phy->ops.read_i2c_byte = &ixgbe_read_i2c_byte_82599; 288 phy->ops.write_i2c_byte = &ixgbe_write_i2c_byte_82599; 289 } 290 291 /* Identify the PHY or SFP module */ 292 ret_val = phy->ops.identify(hw); 293 294 /* Setup function pointers based on detected SFP module and speeds */ 295 ixgbe_init_mac_link_ops_82599(hw); 296 297 /* If copper media, overwrite with copper function pointers */ 298 if (mac->ops.get_media_type(hw) == ixgbe_media_type_copper) { 299 mac->ops.setup_link = &ixgbe_setup_copper_link_82599; 300 mac->ops.get_link_capabilities = 301 &ixgbe_get_copper_link_capabilities_generic; 302 } 303 304 /* Set necessary function pointers based on phy type */ 305 switch (hw->phy.type) { 306 case ixgbe_phy_tn: 307 phy->ops.check_link = &ixgbe_check_phy_link_tnx; 308 phy->ops.setup_link = &ixgbe_setup_phy_link_tnx; 309 break; 310 default: 311 break; 312 } 313 314 return ret_val; 315} 316 317/** 318 * ixgbe_get_link_capabilities_82599 - Determines link capabilities 319 * @hw: pointer to hardware structure 320 * @speed: pointer to link speed 321 * @autoneg: true when autoneg or autotry is enabled 322 * 323 * Determines the link capabilities by reading the AUTOC register. 324 **/ 325static int ixgbe_get_link_capabilities_82599(struct ixgbe_hw *hw, 326 ixgbe_link_speed *speed, 327 bool *autoneg) 328{ 329 u32 autoc = 0; 330 331 /* Determine 1G link capabilities off of SFP+ type */ 332 if (hw->phy.sfp_type == ixgbe_sfp_type_1g_cu_core0 || 333 hw->phy.sfp_type == ixgbe_sfp_type_1g_cu_core1 || 334 hw->phy.sfp_type == ixgbe_sfp_type_1g_lx_core0 || 335 hw->phy.sfp_type == ixgbe_sfp_type_1g_lx_core1 || 336 hw->phy.sfp_type == ixgbe_sfp_type_1g_sx_core0 || 337 hw->phy.sfp_type == ixgbe_sfp_type_1g_sx_core1 || 338 hw->phy.sfp_type == ixgbe_sfp_type_1g_bx_core0 || 339 hw->phy.sfp_type == ixgbe_sfp_type_1g_bx_core1) { 340 *speed = IXGBE_LINK_SPEED_1GB_FULL; 341 *autoneg = true; 342 return 0; 343 } 344 345 /* 346 * Determine link capabilities based on the stored value of AUTOC, 347 * which represents EEPROM defaults. If AUTOC value has not been 348 * stored, use the current register value. 349 */ 350 if (hw->mac.orig_link_settings_stored) 351 autoc = hw->mac.orig_autoc; 352 else 353 autoc = IXGBE_READ_REG(hw, IXGBE_AUTOC); 354 355 switch (autoc & IXGBE_AUTOC_LMS_MASK) { 356 case IXGBE_AUTOC_LMS_1G_LINK_NO_AN: 357 *speed = IXGBE_LINK_SPEED_1GB_FULL; 358 *autoneg = false; 359 break; 360 361 case IXGBE_AUTOC_LMS_10G_LINK_NO_AN: 362 *speed = IXGBE_LINK_SPEED_10GB_FULL; 363 *autoneg = false; 364 break; 365 366 case IXGBE_AUTOC_LMS_1G_AN: 367 *speed = IXGBE_LINK_SPEED_1GB_FULL; 368 *autoneg = true; 369 break; 370 371 case IXGBE_AUTOC_LMS_10G_SERIAL: 372 *speed = IXGBE_LINK_SPEED_10GB_FULL; 373 *autoneg = false; 374 break; 375 376 case IXGBE_AUTOC_LMS_KX4_KX_KR: 377 case IXGBE_AUTOC_LMS_KX4_KX_KR_1G_AN: 378 *speed = IXGBE_LINK_SPEED_UNKNOWN; 379 if (autoc & IXGBE_AUTOC_KR_SUPP) 380 *speed |= IXGBE_LINK_SPEED_10GB_FULL; 381 if (autoc & IXGBE_AUTOC_KX4_SUPP) 382 *speed |= IXGBE_LINK_SPEED_10GB_FULL; 383 if (autoc & IXGBE_AUTOC_KX_SUPP) 384 *speed |= IXGBE_LINK_SPEED_1GB_FULL; 385 *autoneg = true; 386 break; 387 388 case IXGBE_AUTOC_LMS_KX4_KX_KR_SGMII: 389 *speed = IXGBE_LINK_SPEED_100_FULL; 390 if (autoc & IXGBE_AUTOC_KR_SUPP) 391 *speed |= IXGBE_LINK_SPEED_10GB_FULL; 392 if (autoc & IXGBE_AUTOC_KX4_SUPP) 393 *speed |= IXGBE_LINK_SPEED_10GB_FULL; 394 if (autoc & IXGBE_AUTOC_KX_SUPP) 395 *speed |= IXGBE_LINK_SPEED_1GB_FULL; 396 *autoneg = true; 397 break; 398 399 case IXGBE_AUTOC_LMS_SGMII_1G_100M: 400 *speed = IXGBE_LINK_SPEED_1GB_FULL | IXGBE_LINK_SPEED_100_FULL; 401 *autoneg = false; 402 break; 403 404 default: 405 return -EIO; 406 } 407 408 if (hw->phy.multispeed_fiber) { 409 *speed |= IXGBE_LINK_SPEED_10GB_FULL | 410 IXGBE_LINK_SPEED_1GB_FULL; 411 412 /* QSFP must not enable auto-negotiation */ 413 if (hw->phy.media_type == ixgbe_media_type_fiber_qsfp) 414 *autoneg = false; 415 else 416 *autoneg = true; 417 } 418 419 return 0; 420} 421 422/** 423 * ixgbe_get_media_type_82599 - Get media type 424 * @hw: pointer to hardware structure 425 * 426 * Returns the media type (fiber, copper, backplane) 427 **/ 428static enum ixgbe_media_type ixgbe_get_media_type_82599(struct ixgbe_hw *hw) 429{ 430 /* Detect if there is a copper PHY attached. */ 431 switch (hw->phy.type) { 432 case ixgbe_phy_cu_unknown: 433 case ixgbe_phy_tn: 434 return ixgbe_media_type_copper; 435 436 default: 437 break; 438 } 439 440 switch (hw->device_id) { 441 case IXGBE_DEV_ID_82599_KX4: 442 case IXGBE_DEV_ID_82599_KX4_MEZZ: 443 case IXGBE_DEV_ID_82599_COMBO_BACKPLANE: 444 case IXGBE_DEV_ID_82599_KR: 445 case IXGBE_DEV_ID_82599_BACKPLANE_FCOE: 446 case IXGBE_DEV_ID_82599_XAUI_LOM: 447 /* Default device ID is mezzanine card KX/KX4 */ 448 return ixgbe_media_type_backplane; 449 450 case IXGBE_DEV_ID_82599_SFP: 451 case IXGBE_DEV_ID_82599_SFP_FCOE: 452 case IXGBE_DEV_ID_82599_SFP_EM: 453 case IXGBE_DEV_ID_82599_SFP_SF2: 454 case IXGBE_DEV_ID_82599_SFP_SF_QP: 455 case IXGBE_DEV_ID_82599EN_SFP: 456 return ixgbe_media_type_fiber; 457 458 case IXGBE_DEV_ID_82599_CX4: 459 return ixgbe_media_type_cx4; 460 461 case IXGBE_DEV_ID_82599_T3_LOM: 462 return ixgbe_media_type_copper; 463 464 case IXGBE_DEV_ID_82599_LS: 465 return ixgbe_media_type_fiber_lco; 466 467 case IXGBE_DEV_ID_82599_QSFP_SF_QP: 468 return ixgbe_media_type_fiber_qsfp; 469 470 default: 471 return ixgbe_media_type_unknown; 472 } 473} 474 475/** 476 * ixgbe_stop_mac_link_on_d3_82599 - Disables link on D3 477 * @hw: pointer to hardware structure 478 * 479 * Disables link, should be called during D3 power down sequence. 480 * 481 **/ 482static void ixgbe_stop_mac_link_on_d3_82599(struct ixgbe_hw *hw) 483{ 484 u32 autoc2_reg; 485 u16 ee_ctrl_2 = 0; 486 487 hw->eeprom.ops.read(hw, IXGBE_EEPROM_CTRL_2, &ee_ctrl_2); 488 489 if (!ixgbe_mng_present(hw) && !hw->wol_enabled && 490 ee_ctrl_2 & IXGBE_EEPROM_CCD_BIT) { 491 autoc2_reg = IXGBE_READ_REG(hw, IXGBE_AUTOC2); 492 autoc2_reg |= IXGBE_AUTOC2_LINK_DISABLE_ON_D3_MASK; 493 IXGBE_WRITE_REG(hw, IXGBE_AUTOC2, autoc2_reg); 494 } 495} 496 497/** 498 * ixgbe_start_mac_link_82599 - Setup MAC link settings 499 * @hw: pointer to hardware structure 500 * @autoneg_wait_to_complete: true when waiting for completion is needed 501 * 502 * Configures link settings based on values in the ixgbe_hw struct. 503 * Restarts the link. Performs autonegotiation if needed. 504 **/ 505static int ixgbe_start_mac_link_82599(struct ixgbe_hw *hw, 506 bool autoneg_wait_to_complete) 507{ 508 bool got_lock = false; 509 int status = 0; 510 u32 autoc_reg; 511 u32 links_reg; 512 u32 i; 513 514 if (ixgbe_verify_lesm_fw_enabled_82599(hw)) { 515 status = hw->mac.ops.acquire_swfw_sync(hw, 516 IXGBE_GSSR_MAC_CSR_SM); 517 if (status) 518 return status; 519 520 got_lock = true; 521 } 522 523 /* Restart link */ 524 ixgbe_reset_pipeline_82599(hw); 525 526 if (got_lock) 527 hw->mac.ops.release_swfw_sync(hw, IXGBE_GSSR_MAC_CSR_SM); 528 529 /* Only poll for autoneg to complete if specified to do so */ 530 if (autoneg_wait_to_complete) { 531 autoc_reg = IXGBE_READ_REG(hw, IXGBE_AUTOC); 532 if ((autoc_reg & IXGBE_AUTOC_LMS_MASK) == 533 IXGBE_AUTOC_LMS_KX4_KX_KR || 534 (autoc_reg & IXGBE_AUTOC_LMS_MASK) == 535 IXGBE_AUTOC_LMS_KX4_KX_KR_1G_AN || 536 (autoc_reg & IXGBE_AUTOC_LMS_MASK) == 537 IXGBE_AUTOC_LMS_KX4_KX_KR_SGMII) { 538 links_reg = 0; /* Just in case Autoneg time = 0 */ 539 for (i = 0; i < IXGBE_AUTO_NEG_TIME; i++) { 540 links_reg = IXGBE_READ_REG(hw, IXGBE_LINKS); 541 if (links_reg & IXGBE_LINKS_KX_AN_COMP) 542 break; 543 msleep(100); 544 } 545 if (!(links_reg & IXGBE_LINKS_KX_AN_COMP)) { 546 status = -EIO; 547 hw_dbg(hw, "Autoneg did not complete.\n"); 548 } 549 } 550 } 551 552 /* Add delay to filter out noises during initial link setup */ 553 msleep(50); 554 555 return status; 556} 557 558/** 559 * ixgbe_disable_tx_laser_multispeed_fiber - Disable Tx laser 560 * @hw: pointer to hardware structure 561 * 562 * The base drivers may require better control over SFP+ module 563 * PHY states. This includes selectively shutting down the Tx 564 * laser on the PHY, effectively halting physical link. 565 **/ 566static void ixgbe_disable_tx_laser_multispeed_fiber(struct ixgbe_hw *hw) 567{ 568 u32 esdp_reg = IXGBE_READ_REG(hw, IXGBE_ESDP); 569 570 /* Blocked by MNG FW so bail */ 571 if (ixgbe_check_reset_blocked(hw)) 572 return; 573 574 /* Disable tx laser; allow 100us to go dark per spec */ 575 esdp_reg |= IXGBE_ESDP_SDP3; 576 IXGBE_WRITE_REG(hw, IXGBE_ESDP, esdp_reg); 577 IXGBE_WRITE_FLUSH(hw); 578 udelay(100); 579} 580 581/** 582 * ixgbe_enable_tx_laser_multispeed_fiber - Enable Tx laser 583 * @hw: pointer to hardware structure 584 * 585 * The base drivers may require better control over SFP+ module 586 * PHY states. This includes selectively turning on the Tx 587 * laser on the PHY, effectively starting physical link. 588 **/ 589static void ixgbe_enable_tx_laser_multispeed_fiber(struct ixgbe_hw *hw) 590{ 591 u32 esdp_reg = IXGBE_READ_REG(hw, IXGBE_ESDP); 592 593 /* Enable tx laser; allow 100ms to light up */ 594 esdp_reg &= ~IXGBE_ESDP_SDP3; 595 IXGBE_WRITE_REG(hw, IXGBE_ESDP, esdp_reg); 596 IXGBE_WRITE_FLUSH(hw); 597 msleep(100); 598} 599 600/** 601 * ixgbe_flap_tx_laser_multispeed_fiber - Flap Tx laser 602 * @hw: pointer to hardware structure 603 * 604 * When the driver changes the link speeds that it can support, 605 * it sets autotry_restart to true to indicate that we need to 606 * initiate a new autotry session with the link partner. To do 607 * so, we set the speed then disable and re-enable the tx laser, to 608 * alert the link partner that it also needs to restart autotry on its 609 * end. This is consistent with true clause 37 autoneg, which also 610 * involves a loss of signal. 611 **/ 612static void ixgbe_flap_tx_laser_multispeed_fiber(struct ixgbe_hw *hw) 613{ 614 /* Blocked by MNG FW so bail */ 615 if (ixgbe_check_reset_blocked(hw)) 616 return; 617 618 if (hw->mac.autotry_restart) { 619 ixgbe_disable_tx_laser_multispeed_fiber(hw); 620 ixgbe_enable_tx_laser_multispeed_fiber(hw); 621 hw->mac.autotry_restart = false; 622 } 623} 624 625/** 626 * ixgbe_set_hard_rate_select_speed - Set module link speed 627 * @hw: pointer to hardware structure 628 * @speed: link speed to set 629 * 630 * Set module link speed via RS0/RS1 rate select pins. 631 */ 632static void 633ixgbe_set_hard_rate_select_speed(struct ixgbe_hw *hw, ixgbe_link_speed speed) 634{ 635 u32 esdp_reg = IXGBE_READ_REG(hw, IXGBE_ESDP); 636 637 switch (speed) { 638 case IXGBE_LINK_SPEED_10GB_FULL: 639 esdp_reg |= (IXGBE_ESDP_SDP5_DIR | IXGBE_ESDP_SDP5); 640 break; 641 case IXGBE_LINK_SPEED_1GB_FULL: 642 esdp_reg &= ~IXGBE_ESDP_SDP5; 643 esdp_reg |= IXGBE_ESDP_SDP5_DIR; 644 break; 645 default: 646 hw_dbg(hw, "Invalid fixed module speed\n"); 647 return; 648 } 649 650 IXGBE_WRITE_REG(hw, IXGBE_ESDP, esdp_reg); 651 IXGBE_WRITE_FLUSH(hw); 652} 653 654/** 655 * ixgbe_setup_mac_link_smartspeed - Set MAC link speed using SmartSpeed 656 * @hw: pointer to hardware structure 657 * @speed: new link speed 658 * @autoneg_wait_to_complete: true when waiting for completion is needed 659 * 660 * Implements the Intel SmartSpeed algorithm. 661 **/ 662static int ixgbe_setup_mac_link_smartspeed(struct ixgbe_hw *hw, 663 ixgbe_link_speed speed, 664 bool autoneg_wait_to_complete) 665{ 666 ixgbe_link_speed link_speed = IXGBE_LINK_SPEED_UNKNOWN; 667 u32 autoc_reg = IXGBE_READ_REG(hw, IXGBE_AUTOC); 668 bool link_up = false; 669 int status = 0; 670 s32 i, j; 671 672 /* Set autoneg_advertised value based on input link speed */ 673 hw->phy.autoneg_advertised = 0; 674 675 if (speed & IXGBE_LINK_SPEED_10GB_FULL) 676 hw->phy.autoneg_advertised |= IXGBE_LINK_SPEED_10GB_FULL; 677 678 if (speed & IXGBE_LINK_SPEED_1GB_FULL) 679 hw->phy.autoneg_advertised |= IXGBE_LINK_SPEED_1GB_FULL; 680 681 if (speed & IXGBE_LINK_SPEED_100_FULL) 682 hw->phy.autoneg_advertised |= IXGBE_LINK_SPEED_100_FULL; 683 684 /* 685 * Implement Intel SmartSpeed algorithm. SmartSpeed will reduce the 686 * autoneg advertisement if link is unable to be established at the 687 * highest negotiated rate. This can sometimes happen due to integrity 688 * issues with the physical media connection. 689 */ 690 691 /* First, try to get link with full advertisement */ 692 hw->phy.smart_speed_active = false; 693 for (j = 0; j < IXGBE_SMARTSPEED_MAX_RETRIES; j++) { 694 status = ixgbe_setup_mac_link_82599(hw, speed, 695 autoneg_wait_to_complete); 696 if (status != 0) 697 goto out; 698 699 /* 700 * Wait for the controller to acquire link. Per IEEE 802.3ap, 701 * Section 73.10.2, we may have to wait up to 500ms if KR is 702 * attempted, or 200ms if KX/KX4/BX/BX4 is attempted, per 703 * Table 9 in the AN MAS. 704 */ 705 for (i = 0; i < 5; i++) { 706 mdelay(100); 707 708 /* If we have link, just jump out */ 709 status = hw->mac.ops.check_link(hw, &link_speed, 710 &link_up, false); 711 if (status != 0) 712 goto out; 713 714 if (link_up) 715 goto out; 716 } 717 } 718 719 /* 720 * We didn't get link. If we advertised KR plus one of KX4/KX 721 * (or BX4/BX), then disable KR and try again. 722 */ 723 if (((autoc_reg & IXGBE_AUTOC_KR_SUPP) == 0) || 724 ((autoc_reg & IXGBE_AUTOC_KX4_KX_SUPP_MASK) == 0)) 725 goto out; 726 727 /* Turn SmartSpeed on to disable KR support */ 728 hw->phy.smart_speed_active = true; 729 status = ixgbe_setup_mac_link_82599(hw, speed, 730 autoneg_wait_to_complete); 731 if (status != 0) 732 goto out; 733 734 /* 735 * Wait for the controller to acquire link. 600ms will allow for 736 * the AN link_fail_inhibit_timer as well for multiple cycles of 737 * parallel detect, both 10g and 1g. This allows for the maximum 738 * connect attempts as defined in the AN MAS table 73-7. 739 */ 740 for (i = 0; i < 6; i++) { 741 mdelay(100); 742 743 /* If we have link, just jump out */ 744 status = hw->mac.ops.check_link(hw, &link_speed, 745 &link_up, false); 746 if (status != 0) 747 goto out; 748 749 if (link_up) 750 goto out; 751 } 752 753 /* We didn't get link. Turn SmartSpeed back off. */ 754 hw->phy.smart_speed_active = false; 755 status = ixgbe_setup_mac_link_82599(hw, speed, 756 autoneg_wait_to_complete); 757 758out: 759 if (link_up && (link_speed == IXGBE_LINK_SPEED_1GB_FULL)) 760 hw_dbg(hw, "Smartspeed has downgraded the link speed from the maximum advertised\n"); 761 return status; 762} 763 764/** 765 * ixgbe_setup_mac_link_82599 - Set MAC link speed 766 * @hw: pointer to hardware structure 767 * @speed: new link speed 768 * @autoneg_wait_to_complete: true when waiting for completion is needed 769 * 770 * Set the link speed in the AUTOC register and restarts link. 771 **/ 772static int ixgbe_setup_mac_link_82599(struct ixgbe_hw *hw, 773 ixgbe_link_speed speed, 774 bool autoneg_wait_to_complete) 775{ 776 ixgbe_link_speed link_capabilities = IXGBE_LINK_SPEED_UNKNOWN; 777 u32 pma_pmd_10g_serial, pma_pmd_1g, link_mode, links_reg, i; 778 u32 autoc2 = IXGBE_READ_REG(hw, IXGBE_AUTOC2); 779 bool autoneg = false; 780 int status; 781 782 /* holds the value of AUTOC register at this current point in time */ 783 u32 current_autoc = IXGBE_READ_REG(hw, IXGBE_AUTOC); 784 /* holds the cached value of AUTOC register */ 785 u32 orig_autoc = 0; 786 /* temporary variable used for comparison purposes */ 787 u32 autoc = current_autoc; 788 789 pma_pmd_10g_serial = autoc2 & IXGBE_AUTOC2_10G_SERIAL_PMA_PMD_MASK; 790 791 /* Check to see if speed passed in is supported. */ 792 status = hw->mac.ops.get_link_capabilities(hw, &link_capabilities, 793 &autoneg); 794 if (status) 795 return status; 796 797 speed &= link_capabilities; 798 799 if (speed == IXGBE_LINK_SPEED_UNKNOWN) 800 return -EINVAL; 801 802 /* Use stored value (EEPROM defaults) of AUTOC to find KR/KX4 support*/ 803 if (hw->mac.orig_link_settings_stored) 804 orig_autoc = hw->mac.orig_autoc; 805 else 806 orig_autoc = autoc; 807 808 link_mode = autoc & IXGBE_AUTOC_LMS_MASK; 809 pma_pmd_1g = autoc & IXGBE_AUTOC_1G_PMA_PMD_MASK; 810 811 if (link_mode == IXGBE_AUTOC_LMS_KX4_KX_KR || 812 link_mode == IXGBE_AUTOC_LMS_KX4_KX_KR_1G_AN || 813 link_mode == IXGBE_AUTOC_LMS_KX4_KX_KR_SGMII) { 814 /* Set KX4/KX/KR support according to speed requested */ 815 autoc &= ~(IXGBE_AUTOC_KX4_KX_SUPP_MASK | IXGBE_AUTOC_KR_SUPP); 816 if (speed & IXGBE_LINK_SPEED_10GB_FULL) { 817 if (orig_autoc & IXGBE_AUTOC_KX4_SUPP) 818 autoc |= IXGBE_AUTOC_KX4_SUPP; 819 if ((orig_autoc & IXGBE_AUTOC_KR_SUPP) && 820 (hw->phy.smart_speed_active == false)) 821 autoc |= IXGBE_AUTOC_KR_SUPP; 822 } 823 if (speed & IXGBE_LINK_SPEED_1GB_FULL) 824 autoc |= IXGBE_AUTOC_KX_SUPP; 825 } else if ((pma_pmd_1g == IXGBE_AUTOC_1G_SFI) && 826 (link_mode == IXGBE_AUTOC_LMS_1G_LINK_NO_AN || 827 link_mode == IXGBE_AUTOC_LMS_1G_AN)) { 828 /* Switch from 1G SFI to 10G SFI if requested */ 829 if ((speed == IXGBE_LINK_SPEED_10GB_FULL) && 830 (pma_pmd_10g_serial == IXGBE_AUTOC2_10G_SFI)) { 831 autoc &= ~IXGBE_AUTOC_LMS_MASK; 832 autoc |= IXGBE_AUTOC_LMS_10G_SERIAL; 833 } 834 } else if ((pma_pmd_10g_serial == IXGBE_AUTOC2_10G_SFI) && 835 (link_mode == IXGBE_AUTOC_LMS_10G_SERIAL)) { 836 /* Switch from 10G SFI to 1G SFI if requested */ 837 if ((speed == IXGBE_LINK_SPEED_1GB_FULL) && 838 (pma_pmd_1g == IXGBE_AUTOC_1G_SFI)) { 839 autoc &= ~IXGBE_AUTOC_LMS_MASK; 840 if (autoneg) 841 autoc |= IXGBE_AUTOC_LMS_1G_AN; 842 else 843 autoc |= IXGBE_AUTOC_LMS_1G_LINK_NO_AN; 844 } 845 } 846 847 if (autoc != current_autoc) { 848 /* Restart link */ 849 status = hw->mac.ops.prot_autoc_write(hw, autoc, false); 850 if (status) 851 return status; 852 853 /* Only poll for autoneg to complete if specified to do so */ 854 if (autoneg_wait_to_complete) { 855 if (link_mode == IXGBE_AUTOC_LMS_KX4_KX_KR || 856 link_mode == IXGBE_AUTOC_LMS_KX4_KX_KR_1G_AN || 857 link_mode == IXGBE_AUTOC_LMS_KX4_KX_KR_SGMII) { 858 links_reg = 0; /*Just in case Autoneg time=0*/ 859 for (i = 0; i < IXGBE_AUTO_NEG_TIME; i++) { 860 links_reg = 861 IXGBE_READ_REG(hw, IXGBE_LINKS); 862 if (links_reg & IXGBE_LINKS_KX_AN_COMP) 863 break; 864 msleep(100); 865 } 866 if (!(links_reg & IXGBE_LINKS_KX_AN_COMP)) { 867 status = -EIO; 868 hw_dbg(hw, "Autoneg did not complete.\n"); 869 } 870 } 871 } 872 873 /* Add delay to filter out noises during initial link setup */ 874 msleep(50); 875 } 876 877 return status; 878} 879 880/** 881 * ixgbe_setup_copper_link_82599 - Set the PHY autoneg advertised field 882 * @hw: pointer to hardware structure 883 * @speed: new link speed 884 * @autoneg_wait_to_complete: true if waiting is needed to complete 885 * 886 * Restarts link on PHY and MAC based on settings passed in. 887 **/ 888static int ixgbe_setup_copper_link_82599(struct ixgbe_hw *hw, 889 ixgbe_link_speed speed, 890 bool autoneg_wait_to_complete) 891{ 892 int status; 893 894 /* Setup the PHY according to input speed */ 895 status = hw->phy.ops.setup_link_speed(hw, speed, 896 autoneg_wait_to_complete); 897 /* Set up MAC */ 898 ixgbe_start_mac_link_82599(hw, autoneg_wait_to_complete); 899 900 return status; 901} 902 903/** 904 * ixgbe_reset_hw_82599 - Perform hardware reset 905 * @hw: pointer to hardware structure 906 * 907 * Resets the hardware by resetting the transmit and receive units, masks 908 * and clears all interrupts, perform a PHY reset, and perform a link (MAC) 909 * reset. 910 **/ 911static int ixgbe_reset_hw_82599(struct ixgbe_hw *hw) 912{ 913 ixgbe_link_speed link_speed; 914 u32 ctrl, i, autoc, autoc2; 915 bool link_up = false; 916 u32 curr_lms; 917 int status; 918 919 /* Call adapter stop to disable tx/rx and clear interrupts */ 920 status = hw->mac.ops.stop_adapter(hw); 921 if (status) 922 return status; 923 924 /* flush pending Tx transactions */ 925 ixgbe_clear_tx_pending(hw); 926 927 /* PHY ops must be identified and initialized prior to reset */ 928 929 /* Identify PHY and related function pointers */ 930 status = hw->phy.ops.init(hw); 931 932 if (status == -EOPNOTSUPP) 933 return status; 934 935 /* Setup SFP module if there is one present. */ 936 if (hw->phy.sfp_setup_needed) { 937 status = hw->mac.ops.setup_sfp(hw); 938 hw->phy.sfp_setup_needed = false; 939 } 940 941 if (status == -EOPNOTSUPP) 942 return status; 943 944 /* Reset PHY */ 945 if (hw->phy.reset_disable == false && hw->phy.ops.reset != NULL) 946 hw->phy.ops.reset(hw); 947 948 /* remember AUTOC from before we reset */ 949 curr_lms = IXGBE_READ_REG(hw, IXGBE_AUTOC) & IXGBE_AUTOC_LMS_MASK; 950 951mac_reset_top: 952 /* 953 * Issue global reset to the MAC. Needs to be SW reset if link is up. 954 * If link reset is used when link is up, it might reset the PHY when 955 * mng is using it. If link is down or the flag to force full link 956 * reset is set, then perform link reset. 957 */ 958 ctrl = IXGBE_CTRL_LNK_RST; 959 if (!hw->force_full_reset) { 960 hw->mac.ops.check_link(hw, &link_speed, &link_up, false); 961 if (link_up) 962 ctrl = IXGBE_CTRL_RST; 963 } 964 965 ctrl |= IXGBE_READ_REG(hw, IXGBE_CTRL); 966 IXGBE_WRITE_REG(hw, IXGBE_CTRL, ctrl); 967 IXGBE_WRITE_FLUSH(hw); 968 usleep_range(1000, 1200); 969 970 /* Poll for reset bit to self-clear indicating reset is complete */ 971 for (i = 0; i < 10; i++) { 972 ctrl = IXGBE_READ_REG(hw, IXGBE_CTRL); 973 if (!(ctrl & IXGBE_CTRL_RST_MASK)) 974 break; 975 udelay(1); 976 } 977 978 if (ctrl & IXGBE_CTRL_RST_MASK) { 979 status = -EIO; 980 hw_dbg(hw, "Reset polling failed to complete.\n"); 981 } 982 983 msleep(50); 984 985 /* 986 * Double resets are required for recovery from certain error 987 * conditions. Between resets, it is necessary to stall to allow time 988 * for any pending HW events to complete. 989 */ 990 if (hw->mac.flags & IXGBE_FLAGS_DOUBLE_RESET_REQUIRED) { 991 hw->mac.flags &= ~IXGBE_FLAGS_DOUBLE_RESET_REQUIRED; 992 goto mac_reset_top; 993 } 994 995 /* 996 * Store the original AUTOC/AUTOC2 values if they have not been 997 * stored off yet. Otherwise restore the stored original 998 * values since the reset operation sets back to defaults. 999 */ 1000 autoc = IXGBE_READ_REG(hw, IXGBE_AUTOC); 1001 autoc2 = IXGBE_READ_REG(hw, IXGBE_AUTOC2); 1002 1003 /* Enable link if disabled in NVM */ 1004 if (autoc2 & IXGBE_AUTOC2_LINK_DISABLE_MASK) { 1005 autoc2 &= ~IXGBE_AUTOC2_LINK_DISABLE_MASK; 1006 IXGBE_WRITE_REG(hw, IXGBE_AUTOC2, autoc2); 1007 IXGBE_WRITE_FLUSH(hw); 1008 } 1009 1010 if (hw->mac.orig_link_settings_stored == false) { 1011 hw->mac.orig_autoc = autoc; 1012 hw->mac.orig_autoc2 = autoc2; 1013 hw->mac.orig_link_settings_stored = true; 1014 } else { 1015 1016 /* If MNG FW is running on a multi-speed device that 1017 * doesn't autoneg with out driver support we need to 1018 * leave LMS in the state it was before we MAC reset. 1019 * Likewise if we support WoL we don't want change the 1020 * LMS state either. 1021 */ 1022 if ((hw->phy.multispeed_fiber && ixgbe_mng_enabled(hw)) || 1023 hw->wol_enabled) 1024 hw->mac.orig_autoc = 1025 (hw->mac.orig_autoc & ~IXGBE_AUTOC_LMS_MASK) | 1026 curr_lms; 1027 1028 if (autoc != hw->mac.orig_autoc) { 1029 status = hw->mac.ops.prot_autoc_write(hw, 1030 hw->mac.orig_autoc, 1031 false); 1032 if (status) 1033 return status; 1034 } 1035 1036 if ((autoc2 & IXGBE_AUTOC2_UPPER_MASK) != 1037 (hw->mac.orig_autoc2 & IXGBE_AUTOC2_UPPER_MASK)) { 1038 autoc2 &= ~IXGBE_AUTOC2_UPPER_MASK; 1039 autoc2 |= (hw->mac.orig_autoc2 & 1040 IXGBE_AUTOC2_UPPER_MASK); 1041 IXGBE_WRITE_REG(hw, IXGBE_AUTOC2, autoc2); 1042 } 1043 } 1044 1045 /* Store the permanent mac address */ 1046 hw->mac.ops.get_mac_addr(hw, hw->mac.perm_addr); 1047 1048 /* 1049 * Store MAC address from RAR0, clear receive address registers, and 1050 * clear the multicast table. Also reset num_rar_entries to 128, 1051 * since we modify this value when programming the SAN MAC address. 1052 */ 1053 hw->mac.num_rar_entries = IXGBE_82599_RAR_ENTRIES; 1054 hw->mac.ops.init_rx_addrs(hw); 1055 1056 /* Store the permanent SAN mac address */ 1057 hw->mac.ops.get_san_mac_addr(hw, hw->mac.san_addr); 1058 1059 /* Add the SAN MAC address to the RAR only if it's a valid address */ 1060 if (is_valid_ether_addr(hw->mac.san_addr)) { 1061 /* Save the SAN MAC RAR index */ 1062 hw->mac.san_mac_rar_index = hw->mac.num_rar_entries - 1; 1063 1064 hw->mac.ops.set_rar(hw, hw->mac.san_mac_rar_index, 1065 hw->mac.san_addr, 0, IXGBE_RAH_AV); 1066 1067 /* clear VMDq pool/queue selection for this RAR */ 1068 hw->mac.ops.clear_vmdq(hw, hw->mac.san_mac_rar_index, 1069 IXGBE_CLEAR_VMDQ_ALL); 1070 1071 /* Reserve the last RAR for the SAN MAC address */ 1072 hw->mac.num_rar_entries--; 1073 } 1074 1075 /* Store the alternative WWNN/WWPN prefix */ 1076 hw->mac.ops.get_wwn_prefix(hw, &hw->mac.wwnn_prefix, 1077 &hw->mac.wwpn_prefix); 1078 1079 return status; 1080} 1081 1082/** 1083 * ixgbe_fdir_check_cmd_complete - poll to check whether FDIRCMD is complete 1084 * @hw: pointer to hardware structure 1085 * @fdircmd: current value of FDIRCMD register 1086 */ 1087static int ixgbe_fdir_check_cmd_complete(struct ixgbe_hw *hw, u32 *fdircmd) 1088{ 1089 int i; 1090 1091 for (i = 0; i < IXGBE_FDIRCMD_CMD_POLL; i++) { 1092 *fdircmd = IXGBE_READ_REG(hw, IXGBE_FDIRCMD); 1093 if (!(*fdircmd & IXGBE_FDIRCMD_CMD_MASK)) 1094 return 0; 1095 udelay(10); 1096 } 1097 1098 return -EIO; 1099} 1100 1101/** 1102 * ixgbe_reinit_fdir_tables_82599 - Reinitialize Flow Director tables. 1103 * @hw: pointer to hardware structure 1104 **/ 1105int ixgbe_reinit_fdir_tables_82599(struct ixgbe_hw *hw) 1106{ 1107 u32 fdirctrl = IXGBE_READ_REG(hw, IXGBE_FDIRCTRL); 1108 u32 fdircmd; 1109 int err; 1110 int i; 1111 1112 fdirctrl &= ~IXGBE_FDIRCTRL_INIT_DONE; 1113 1114 /* 1115 * Before starting reinitialization process, 1116 * FDIRCMD.CMD must be zero. 1117 */ 1118 err = ixgbe_fdir_check_cmd_complete(hw, &fdircmd); 1119 if (err) { 1120 hw_dbg(hw, "Flow Director previous command did not complete, aborting table re-initialization.\n"); 1121 return err; 1122 } 1123 1124 IXGBE_WRITE_REG(hw, IXGBE_FDIRFREE, 0); 1125 IXGBE_WRITE_FLUSH(hw); 1126 /* 1127 * 82599 adapters flow director init flow cannot be restarted, 1128 * Workaround 82599 silicon errata by performing the following steps 1129 * before re-writing the FDIRCTRL control register with the same value. 1130 * - write 1 to bit 8 of FDIRCMD register & 1131 * - write 0 to bit 8 of FDIRCMD register 1132 */ 1133 IXGBE_WRITE_REG(hw, IXGBE_FDIRCMD, 1134 (IXGBE_READ_REG(hw, IXGBE_FDIRCMD) | 1135 IXGBE_FDIRCMD_CLEARHT)); 1136 IXGBE_WRITE_FLUSH(hw); 1137 IXGBE_WRITE_REG(hw, IXGBE_FDIRCMD, 1138 (IXGBE_READ_REG(hw, IXGBE_FDIRCMD) & 1139 ~IXGBE_FDIRCMD_CLEARHT)); 1140 IXGBE_WRITE_FLUSH(hw); 1141 /* 1142 * Clear FDIR Hash register to clear any leftover hashes 1143 * waiting to be programmed. 1144 */ 1145 IXGBE_WRITE_REG(hw, IXGBE_FDIRHASH, 0x00); 1146 IXGBE_WRITE_FLUSH(hw); 1147 1148 IXGBE_WRITE_REG(hw, IXGBE_FDIRCTRL, fdirctrl); 1149 IXGBE_WRITE_FLUSH(hw); 1150 1151 /* Poll init-done after we write FDIRCTRL register */ 1152 for (i = 0; i < IXGBE_FDIR_INIT_DONE_POLL; i++) { 1153 if (IXGBE_READ_REG(hw, IXGBE_FDIRCTRL) & 1154 IXGBE_FDIRCTRL_INIT_DONE) 1155 break; 1156 usleep_range(1000, 2000); 1157 } 1158 if (i >= IXGBE_FDIR_INIT_DONE_POLL) { 1159 hw_dbg(hw, "Flow Director Signature poll time exceeded!\n"); 1160 return -EIO; 1161 } 1162 1163 /* Clear FDIR statistics registers (read to clear) */ 1164 IXGBE_READ_REG(hw, IXGBE_FDIRUSTAT); 1165 IXGBE_READ_REG(hw, IXGBE_FDIRFSTAT); 1166 IXGBE_READ_REG(hw, IXGBE_FDIRMATCH); 1167 IXGBE_READ_REG(hw, IXGBE_FDIRMISS); 1168 IXGBE_READ_REG(hw, IXGBE_FDIRLEN); 1169 1170 return 0; 1171} 1172 1173/** 1174 * ixgbe_fdir_enable_82599 - Initialize Flow Director control registers 1175 * @hw: pointer to hardware structure 1176 * @fdirctrl: value to write to flow director control register 1177 **/ 1178static void ixgbe_fdir_enable_82599(struct ixgbe_hw *hw, u32 fdirctrl) 1179{ 1180 int i; 1181 1182 /* Prime the keys for hashing */ 1183 IXGBE_WRITE_REG(hw, IXGBE_FDIRHKEY, IXGBE_ATR_BUCKET_HASH_KEY); 1184 IXGBE_WRITE_REG(hw, IXGBE_FDIRSKEY, IXGBE_ATR_SIGNATURE_HASH_KEY); 1185 1186 /* 1187 * Poll init-done after we write the register. Estimated times: 1188 * 10G: PBALLOC = 11b, timing is 60us 1189 * 1G: PBALLOC = 11b, timing is 600us 1190 * 100M: PBALLOC = 11b, timing is 6ms 1191 * 1192 * Multiple these timings by 4 if under full Rx load 1193 * 1194 * So we'll poll for IXGBE_FDIR_INIT_DONE_POLL times, sleeping for 1195 * 1 msec per poll time. If we're at line rate and drop to 100M, then 1196 * this might not finish in our poll time, but we can live with that 1197 * for now. 1198 */ 1199 IXGBE_WRITE_REG(hw, IXGBE_FDIRCTRL, fdirctrl); 1200 IXGBE_WRITE_FLUSH(hw); 1201 for (i = 0; i < IXGBE_FDIR_INIT_DONE_POLL; i++) { 1202 if (IXGBE_READ_REG(hw, IXGBE_FDIRCTRL) & 1203 IXGBE_FDIRCTRL_INIT_DONE) 1204 break; 1205 usleep_range(1000, 2000); 1206 } 1207 1208 if (i >= IXGBE_FDIR_INIT_DONE_POLL) 1209 hw_dbg(hw, "Flow Director poll time exceeded!\n"); 1210} 1211 1212/** 1213 * ixgbe_init_fdir_signature_82599 - Initialize Flow Director signature filters 1214 * @hw: pointer to hardware structure 1215 * @fdirctrl: value to write to flow director control register, initially 1216 * contains just the value of the Rx packet buffer allocation 1217 **/ 1218int ixgbe_init_fdir_signature_82599(struct ixgbe_hw *hw, u32 fdirctrl) 1219{ 1220 /* 1221 * Continue setup of fdirctrl register bits: 1222 * Move the flexible bytes to use the ethertype - shift 6 words 1223 * Set the maximum length per hash bucket to 0xA filters 1224 * Send interrupt when 64 filters are left 1225 */ 1226 fdirctrl |= (0x6 << IXGBE_FDIRCTRL_FLEX_SHIFT) | 1227 (0xA << IXGBE_FDIRCTRL_MAX_LENGTH_SHIFT) | 1228 (4 << IXGBE_FDIRCTRL_FULL_THRESH_SHIFT); 1229 1230 /* write hashes and fdirctrl register, poll for completion */ 1231 ixgbe_fdir_enable_82599(hw, fdirctrl); 1232 1233 return 0; 1234} 1235 1236/** 1237 * ixgbe_init_fdir_perfect_82599 - Initialize Flow Director perfect filters 1238 * @hw: pointer to hardware structure 1239 * @fdirctrl: value to write to flow director control register, initially 1240 * contains just the value of the Rx packet buffer allocation 1241 **/ 1242int ixgbe_init_fdir_perfect_82599(struct ixgbe_hw *hw, u32 fdirctrl) 1243{ 1244 /* 1245 * Continue setup of fdirctrl register bits: 1246 * Turn perfect match filtering on 1247 * Initialize the drop queue 1248 * Move the flexible bytes to use the ethertype - shift 6 words 1249 * Set the maximum length per hash bucket to 0xA filters 1250 * Send interrupt when 64 (0x4 * 16) filters are left 1251 */ 1252 fdirctrl |= IXGBE_FDIRCTRL_PERFECT_MATCH | 1253 (IXGBE_FDIR_DROP_QUEUE << IXGBE_FDIRCTRL_DROP_Q_SHIFT) | 1254 (0x6 << IXGBE_FDIRCTRL_FLEX_SHIFT) | 1255 (0xA << IXGBE_FDIRCTRL_MAX_LENGTH_SHIFT) | 1256 (4 << IXGBE_FDIRCTRL_FULL_THRESH_SHIFT); 1257 1258 /* write hashes and fdirctrl register, poll for completion */ 1259 ixgbe_fdir_enable_82599(hw, fdirctrl); 1260 1261 return 0; 1262} 1263 1264/* 1265 * These defines allow us to quickly generate all of the necessary instructions 1266 * in the function below by simply calling out IXGBE_COMPUTE_SIG_HASH_ITERATION 1267 * for values 0 through 15 1268 */ 1269#define IXGBE_ATR_COMMON_HASH_KEY \ 1270 (IXGBE_ATR_BUCKET_HASH_KEY & IXGBE_ATR_SIGNATURE_HASH_KEY) 1271#define IXGBE_COMPUTE_SIG_HASH_ITERATION(_n) \ 1272do { \ 1273 u32 n = (_n); \ 1274 if (IXGBE_ATR_COMMON_HASH_KEY & BIT(n)) \ 1275 common_hash ^= lo_hash_dword >> n; \ 1276 else if (IXGBE_ATR_BUCKET_HASH_KEY & BIT(n)) \ 1277 bucket_hash ^= lo_hash_dword >> n; \ 1278 else if (IXGBE_ATR_SIGNATURE_HASH_KEY & BIT(n)) \ 1279 sig_hash ^= lo_hash_dword << (16 - n); \ 1280 if (IXGBE_ATR_COMMON_HASH_KEY & BIT(n + 16)) \ 1281 common_hash ^= hi_hash_dword >> n; \ 1282 else if (IXGBE_ATR_BUCKET_HASH_KEY & BIT(n + 16)) \ 1283 bucket_hash ^= hi_hash_dword >> n; \ 1284 else if (IXGBE_ATR_SIGNATURE_HASH_KEY & BIT(n + 16)) \ 1285 sig_hash ^= hi_hash_dword << (16 - n); \ 1286} while (0) 1287 1288/** 1289 * ixgbe_atr_compute_sig_hash_82599 - Compute the signature hash 1290 * @input: input bitstream to compute the hash on 1291 * @common: compressed common input dword 1292 * 1293 * This function is almost identical to the function above but contains 1294 * several optimizations such as unwinding all of the loops, letting the 1295 * compiler work out all of the conditional ifs since the keys are static 1296 * defines, and computing two keys at once since the hashed dword stream 1297 * will be the same for both keys. 1298 **/ 1299static u32 ixgbe_atr_compute_sig_hash_82599(union ixgbe_atr_hash_dword input, 1300 union ixgbe_atr_hash_dword common) 1301{ 1302 u32 hi_hash_dword, lo_hash_dword, flow_vm_vlan; 1303 u32 sig_hash = 0, bucket_hash = 0, common_hash = 0; 1304 1305 /* record the flow_vm_vlan bits as they are a key part to the hash */ 1306 flow_vm_vlan = ntohl(input.dword); 1307 1308 /* generate common hash dword */ 1309 hi_hash_dword = ntohl(common.dword); 1310 1311 /* low dword is word swapped version of common */ 1312 lo_hash_dword = (hi_hash_dword >> 16) | (hi_hash_dword << 16); 1313 1314 /* apply flow ID/VM pool/VLAN ID bits to hash words */ 1315 hi_hash_dword ^= flow_vm_vlan ^ (flow_vm_vlan >> 16); 1316 1317 /* Process bits 0 and 16 */ 1318 IXGBE_COMPUTE_SIG_HASH_ITERATION(0); 1319 1320 /* 1321 * apply flow ID/VM pool/VLAN ID bits to lo hash dword, we had to 1322 * delay this because bit 0 of the stream should not be processed 1323 * so we do not add the vlan until after bit 0 was processed 1324 */ 1325 lo_hash_dword ^= flow_vm_vlan ^ (flow_vm_vlan << 16); 1326 1327 /* Process remaining 30 bit of the key */ 1328 IXGBE_COMPUTE_SIG_HASH_ITERATION(1); 1329 IXGBE_COMPUTE_SIG_HASH_ITERATION(2); 1330 IXGBE_COMPUTE_SIG_HASH_ITERATION(3); 1331 IXGBE_COMPUTE_SIG_HASH_ITERATION(4); 1332 IXGBE_COMPUTE_SIG_HASH_ITERATION(5); 1333 IXGBE_COMPUTE_SIG_HASH_ITERATION(6); 1334 IXGBE_COMPUTE_SIG_HASH_ITERATION(7); 1335 IXGBE_COMPUTE_SIG_HASH_ITERATION(8); 1336 IXGBE_COMPUTE_SIG_HASH_ITERATION(9); 1337 IXGBE_COMPUTE_SIG_HASH_ITERATION(10); 1338 IXGBE_COMPUTE_SIG_HASH_ITERATION(11); 1339 IXGBE_COMPUTE_SIG_HASH_ITERATION(12); 1340 IXGBE_COMPUTE_SIG_HASH_ITERATION(13); 1341 IXGBE_COMPUTE_SIG_HASH_ITERATION(14); 1342 IXGBE_COMPUTE_SIG_HASH_ITERATION(15); 1343 1344 /* combine common_hash result with signature and bucket hashes */ 1345 bucket_hash ^= common_hash; 1346 bucket_hash &= IXGBE_ATR_HASH_MASK; 1347 1348 sig_hash ^= common_hash << 16; 1349 sig_hash &= IXGBE_ATR_HASH_MASK << 16; 1350 1351 /* return completed signature hash */ 1352 return sig_hash ^ bucket_hash; 1353} 1354 1355/** 1356 * ixgbe_fdir_add_signature_filter_82599 - Adds a signature hash filter 1357 * @hw: pointer to hardware structure 1358 * @input: unique input dword 1359 * @common: compressed common input dword 1360 * @queue: queue index to direct traffic to 1361 * 1362 * Note that the tunnel bit in input must not be set when the hardware 1363 * tunneling support does not exist. 1364 **/ 1365int ixgbe_fdir_add_signature_filter_82599(struct ixgbe_hw *hw, 1366 union ixgbe_atr_hash_dword input, 1367 union ixgbe_atr_hash_dword common, 1368 u8 queue) 1369{ 1370 u64 fdirhashcmd; 1371 u8 flow_type; 1372 bool tunnel; 1373 u32 fdircmd; 1374 1375 /* 1376 * Get the flow_type in order to program FDIRCMD properly 1377 * lowest 2 bits are FDIRCMD.L4TYPE, third lowest bit is FDIRCMD.IPV6 1378 */ 1379 tunnel = !!(input.formatted.flow_type & IXGBE_ATR_L4TYPE_TUNNEL_MASK); 1380 flow_type = input.formatted.flow_type & 1381 (IXGBE_ATR_L4TYPE_TUNNEL_MASK - 1); 1382 switch (flow_type) { 1383 case IXGBE_ATR_FLOW_TYPE_TCPV4: 1384 case IXGBE_ATR_FLOW_TYPE_UDPV4: 1385 case IXGBE_ATR_FLOW_TYPE_SCTPV4: 1386 case IXGBE_ATR_FLOW_TYPE_TCPV6: 1387 case IXGBE_ATR_FLOW_TYPE_UDPV6: 1388 case IXGBE_ATR_FLOW_TYPE_SCTPV6: 1389 break; 1390 default: 1391 hw_dbg(hw, " Error on flow type input\n"); 1392 return -EIO; 1393 } 1394 1395 /* configure FDIRCMD register */ 1396 fdircmd = IXGBE_FDIRCMD_CMD_ADD_FLOW | IXGBE_FDIRCMD_FILTER_UPDATE | 1397 IXGBE_FDIRCMD_LAST | IXGBE_FDIRCMD_QUEUE_EN; 1398 fdircmd |= (u32)flow_type << IXGBE_FDIRCMD_FLOW_TYPE_SHIFT; 1399 fdircmd |= (u32)queue << IXGBE_FDIRCMD_RX_QUEUE_SHIFT; 1400 if (tunnel) 1401 fdircmd |= IXGBE_FDIRCMD_TUNNEL_FILTER; 1402 1403 /* 1404 * The lower 32-bits of fdirhashcmd is for FDIRHASH, the upper 32-bits 1405 * is for FDIRCMD. Then do a 64-bit register write from FDIRHASH. 1406 */ 1407 fdirhashcmd = (u64)fdircmd << 32; 1408 fdirhashcmd |= ixgbe_atr_compute_sig_hash_82599(input, common); 1409 IXGBE_WRITE_REG64(hw, IXGBE_FDIRHASH, fdirhashcmd); 1410 1411 hw_dbg(hw, "Tx Queue=%x hash=%x\n", queue, (u32)fdirhashcmd); 1412 1413 return 0; 1414} 1415 1416#define IXGBE_COMPUTE_BKT_HASH_ITERATION(_n) \ 1417do { \ 1418 u32 n = (_n); \ 1419 if (IXGBE_ATR_BUCKET_HASH_KEY & BIT(n)) \ 1420 bucket_hash ^= lo_hash_dword >> n; \ 1421 if (IXGBE_ATR_BUCKET_HASH_KEY & BIT(n + 16)) \ 1422 bucket_hash ^= hi_hash_dword >> n; \ 1423} while (0) 1424 1425/** 1426 * ixgbe_atr_compute_perfect_hash_82599 - Compute the perfect filter hash 1427 * @input: input bitstream to compute the hash on 1428 * @input_mask: mask for the input bitstream 1429 * 1430 * This function serves two main purposes. First it applies the input_mask 1431 * to the atr_input resulting in a cleaned up atr_input data stream. 1432 * Secondly it computes the hash and stores it in the bkt_hash field at 1433 * the end of the input byte stream. This way it will be available for 1434 * future use without needing to recompute the hash. 1435 **/ 1436void ixgbe_atr_compute_perfect_hash_82599(union ixgbe_atr_input *input, 1437 union ixgbe_atr_input *input_mask) 1438{ 1439 1440 u32 hi_hash_dword, lo_hash_dword, flow_vm_vlan; 1441 u32 bucket_hash = 0; 1442 __be32 hi_dword = 0; 1443 int i; 1444 1445 /* Apply masks to input data */ 1446 for (i = 0; i <= 10; i++) 1447 input->dword_stream[i] &= input_mask->dword_stream[i]; 1448 1449 /* record the flow_vm_vlan bits as they are a key part to the hash */ 1450 flow_vm_vlan = ntohl(input->dword_stream[0]); 1451 1452 /* generate common hash dword */ 1453 for (i = 1; i <= 10; i++) 1454 hi_dword ^= input->dword_stream[i]; 1455 hi_hash_dword = ntohl(hi_dword); 1456 1457 /* low dword is word swapped version of common */ 1458 lo_hash_dword = (hi_hash_dword >> 16) | (hi_hash_dword << 16); 1459 1460 /* apply flow ID/VM pool/VLAN ID bits to hash words */ 1461 hi_hash_dword ^= flow_vm_vlan ^ (flow_vm_vlan >> 16); 1462 1463 /* Process bits 0 and 16 */ 1464 IXGBE_COMPUTE_BKT_HASH_ITERATION(0); 1465 1466 /* 1467 * apply flow ID/VM pool/VLAN ID bits to lo hash dword, we had to 1468 * delay this because bit 0 of the stream should not be processed 1469 * so we do not add the vlan until after bit 0 was processed 1470 */ 1471 lo_hash_dword ^= flow_vm_vlan ^ (flow_vm_vlan << 16); 1472 1473 /* Process remaining 30 bit of the key */ 1474 for (i = 1; i <= 15; i++) 1475 IXGBE_COMPUTE_BKT_HASH_ITERATION(i); 1476 1477 /* 1478 * Limit hash to 13 bits since max bucket count is 8K. 1479 * Store result at the end of the input stream. 1480 */ 1481 input->formatted.bkt_hash = (__force __be16)(bucket_hash & 0x1FFF); 1482} 1483 1484/** 1485 * ixgbe_get_fdirtcpm_82599 - generate a tcp port from atr_input_masks 1486 * @input_mask: mask to be bit swapped 1487 * 1488 * The source and destination port masks for flow director are bit swapped 1489 * in that bit 15 effects bit 0, 14 effects 1, 13, 2 etc. In order to 1490 * generate a correctly swapped value we need to bit swap the mask and that 1491 * is what is accomplished by this function. 1492 **/ 1493static u32 ixgbe_get_fdirtcpm_82599(union ixgbe_atr_input *input_mask) 1494{ 1495 u32 mask = ntohs(input_mask->formatted.dst_port); 1496 1497 mask <<= IXGBE_FDIRTCPM_DPORTM_SHIFT; 1498 mask |= ntohs(input_mask->formatted.src_port); 1499 mask = ((mask & 0x55555555) << 1) | ((mask & 0xAAAAAAAA) >> 1); 1500 mask = ((mask & 0x33333333) << 2) | ((mask & 0xCCCCCCCC) >> 2); 1501 mask = ((mask & 0x0F0F0F0F) << 4) | ((mask & 0xF0F0F0F0) >> 4); 1502 return ((mask & 0x00FF00FF) << 8) | ((mask & 0xFF00FF00) >> 8); 1503} 1504 1505/* 1506 * These two macros are meant to address the fact that we have registers 1507 * that are either all or in part big-endian. As a result on big-endian 1508 * systems we will end up byte swapping the value to little-endian before 1509 * it is byte swapped again and written to the hardware in the original 1510 * big-endian format. 1511 */ 1512#define IXGBE_STORE_AS_BE32(_value) \ 1513 (((u32)(_value) >> 24) | (((u32)(_value) & 0x00FF0000) >> 8) | \ 1514 (((u32)(_value) & 0x0000FF00) << 8) | ((u32)(_value) << 24)) 1515 1516#define IXGBE_WRITE_REG_BE32(a, reg, value) \ 1517 IXGBE_WRITE_REG((a), (reg), IXGBE_STORE_AS_BE32(ntohl(value))) 1518 1519#define IXGBE_STORE_AS_BE16(_value) __swab16(ntohs((_value))) 1520 1521int ixgbe_fdir_set_input_mask_82599(struct ixgbe_hw *hw, 1522 union ixgbe_atr_input *input_mask) 1523{ 1524 /* mask IPv6 since it is currently not supported */ 1525 u32 fdirm = IXGBE_FDIRM_DIPv6; 1526 u32 fdirtcpm; 1527 1528 /* 1529 * Program the relevant mask registers. If src/dst_port or src/dst_addr 1530 * are zero, then assume a full mask for that field. Also assume that 1531 * a VLAN of 0 is unspecified, so mask that out as well. L4type 1532 * cannot be masked out in this implementation. 1533 * 1534 * This also assumes IPv4 only. IPv6 masking isn't supported at this 1535 * point in time. 1536 */ 1537 1538 /* verify bucket hash is cleared on hash generation */ 1539 if (input_mask->formatted.bkt_hash) 1540 hw_dbg(hw, " bucket hash should always be 0 in mask\n"); 1541 1542 /* Program FDIRM and verify partial masks */ 1543 switch (input_mask->formatted.vm_pool & 0x7F) { 1544 case 0x0: 1545 fdirm |= IXGBE_FDIRM_POOL; 1546 break; 1547 case 0x7F: 1548 break; 1549 default: 1550 hw_dbg(hw, " Error on vm pool mask\n"); 1551 return -EIO; 1552 } 1553 1554 switch (input_mask->formatted.flow_type & IXGBE_ATR_L4TYPE_MASK) { 1555 case 0x0: 1556 fdirm |= IXGBE_FDIRM_L4P; 1557 if (input_mask->formatted.dst_port || 1558 input_mask->formatted.src_port) { 1559 hw_dbg(hw, " Error on src/dst port mask\n"); 1560 return -EIO; 1561 } 1562 break; 1563 case IXGBE_ATR_L4TYPE_MASK: 1564 break; 1565 default: 1566 hw_dbg(hw, " Error on flow type mask\n"); 1567 return -EIO; 1568 } 1569 1570 switch (ntohs(input_mask->formatted.vlan_id) & 0xEFFF) { 1571 case 0x0000: 1572 /* mask VLAN ID */ 1573 fdirm |= IXGBE_FDIRM_VLANID; 1574 fallthrough; 1575 case 0x0FFF: 1576 /* mask VLAN priority */ 1577 fdirm |= IXGBE_FDIRM_VLANP; 1578 break; 1579 case 0xE000: 1580 /* mask VLAN ID only */ 1581 fdirm |= IXGBE_FDIRM_VLANID; 1582 fallthrough; 1583 case 0xEFFF: 1584 /* no VLAN fields masked */ 1585 break; 1586 default: 1587 hw_dbg(hw, " Error on VLAN mask\n"); 1588 return -EIO; 1589 } 1590 1591 switch ((__force u16)input_mask->formatted.flex_bytes & 0xFFFF) { 1592 case 0x0000: 1593 /* Mask Flex Bytes */ 1594 fdirm |= IXGBE_FDIRM_FLEX; 1595 fallthrough; 1596 case 0xFFFF: 1597 break; 1598 default: 1599 hw_dbg(hw, " Error on flexible byte mask\n"); 1600 return -EIO; 1601 } 1602 1603 /* Now mask VM pool and destination IPv6 - bits 5 and 2 */ 1604 IXGBE_WRITE_REG(hw, IXGBE_FDIRM, fdirm); 1605 1606 /* store the TCP/UDP port masks, bit reversed from port layout */ 1607 fdirtcpm = ixgbe_get_fdirtcpm_82599(input_mask); 1608 1609 /* write both the same so that UDP and TCP use the same mask */ 1610 IXGBE_WRITE_REG(hw, IXGBE_FDIRTCPM, ~fdirtcpm); 1611 IXGBE_WRITE_REG(hw, IXGBE_FDIRUDPM, ~fdirtcpm); 1612 1613 /* also use it for SCTP */ 1614 switch (hw->mac.type) { 1615 case ixgbe_mac_X550: 1616 case ixgbe_mac_X550EM_x: 1617 case ixgbe_mac_x550em_a: 1618 IXGBE_WRITE_REG(hw, IXGBE_FDIRSCTPM, ~fdirtcpm); 1619 break; 1620 default: 1621 break; 1622 } 1623 1624 /* store source and destination IP masks (big-enian) */ 1625 IXGBE_WRITE_REG_BE32(hw, IXGBE_FDIRSIP4M, 1626 ~input_mask->formatted.src_ip[0]); 1627 IXGBE_WRITE_REG_BE32(hw, IXGBE_FDIRDIP4M, 1628 ~input_mask->formatted.dst_ip[0]); 1629 1630 return 0; 1631} 1632 1633int ixgbe_fdir_write_perfect_filter_82599(struct ixgbe_hw *hw, 1634 union ixgbe_atr_input *input, 1635 u16 soft_id, u8 queue) 1636{ 1637 u32 fdirport, fdirvlan, fdirhash, fdircmd; 1638 int err; 1639 1640 /* currently IPv6 is not supported, must be programmed with 0 */ 1641 IXGBE_WRITE_REG_BE32(hw, IXGBE_FDIRSIPv6(0), 1642 input->formatted.src_ip[0]); 1643 IXGBE_WRITE_REG_BE32(hw, IXGBE_FDIRSIPv6(1), 1644 input->formatted.src_ip[1]); 1645 IXGBE_WRITE_REG_BE32(hw, IXGBE_FDIRSIPv6(2), 1646 input->formatted.src_ip[2]); 1647 1648 /* record the source address (big-endian) */ 1649 IXGBE_WRITE_REG_BE32(hw, IXGBE_FDIRIPSA, input->formatted.src_ip[0]); 1650 1651 /* record the first 32 bits of the destination address (big-endian) */ 1652 IXGBE_WRITE_REG_BE32(hw, IXGBE_FDIRIPDA, input->formatted.dst_ip[0]); 1653 1654 /* record source and destination port (little-endian)*/ 1655 fdirport = be16_to_cpu(input->formatted.dst_port); 1656 fdirport <<= IXGBE_FDIRPORT_DESTINATION_SHIFT; 1657 fdirport |= be16_to_cpu(input->formatted.src_port); 1658 IXGBE_WRITE_REG(hw, IXGBE_FDIRPORT, fdirport); 1659 1660 /* record vlan (little-endian) and flex_bytes(big-endian) */ 1661 fdirvlan = IXGBE_STORE_AS_BE16(input->formatted.flex_bytes); 1662 fdirvlan <<= IXGBE_FDIRVLAN_FLEX_SHIFT; 1663 fdirvlan |= ntohs(input->formatted.vlan_id); 1664 IXGBE_WRITE_REG(hw, IXGBE_FDIRVLAN, fdirvlan); 1665 1666 /* configure FDIRHASH register */ 1667 fdirhash = (__force u32)input->formatted.bkt_hash; 1668 fdirhash |= soft_id << IXGBE_FDIRHASH_SIG_SW_INDEX_SHIFT; 1669 IXGBE_WRITE_REG(hw, IXGBE_FDIRHASH, fdirhash); 1670 1671 /* 1672 * flush all previous writes to make certain registers are 1673 * programmed prior to issuing the command 1674 */ 1675 IXGBE_WRITE_FLUSH(hw); 1676 1677 /* configure FDIRCMD register */ 1678 fdircmd = IXGBE_FDIRCMD_CMD_ADD_FLOW | IXGBE_FDIRCMD_FILTER_UPDATE | 1679 IXGBE_FDIRCMD_LAST | IXGBE_FDIRCMD_QUEUE_EN; 1680 if (queue == IXGBE_FDIR_DROP_QUEUE) 1681 fdircmd |= IXGBE_FDIRCMD_DROP; 1682 fdircmd |= input->formatted.flow_type << IXGBE_FDIRCMD_FLOW_TYPE_SHIFT; 1683 fdircmd |= (u32)queue << IXGBE_FDIRCMD_RX_QUEUE_SHIFT; 1684 fdircmd |= (u32)input->formatted.vm_pool << IXGBE_FDIRCMD_VT_POOL_SHIFT; 1685 1686 IXGBE_WRITE_REG(hw, IXGBE_FDIRCMD, fdircmd); 1687 err = ixgbe_fdir_check_cmd_complete(hw, &fdircmd); 1688 if (err) { 1689 hw_dbg(hw, "Flow Director command did not complete!\n"); 1690 return err; 1691 } 1692 1693 return 0; 1694} 1695 1696int ixgbe_fdir_erase_perfect_filter_82599(struct ixgbe_hw *hw, 1697 union ixgbe_atr_input *input, 1698 u16 soft_id) 1699{ 1700 u32 fdirhash; 1701 u32 fdircmd; 1702 int err; 1703 1704 /* configure FDIRHASH register */ 1705 fdirhash = (__force u32)input->formatted.bkt_hash; 1706 fdirhash |= soft_id << IXGBE_FDIRHASH_SIG_SW_INDEX_SHIFT; 1707 IXGBE_WRITE_REG(hw, IXGBE_FDIRHASH, fdirhash); 1708 1709 /* flush hash to HW */ 1710 IXGBE_WRITE_FLUSH(hw); 1711 1712 /* Query if filter is present */ 1713 IXGBE_WRITE_REG(hw, IXGBE_FDIRCMD, IXGBE_FDIRCMD_CMD_QUERY_REM_FILT); 1714 1715 err = ixgbe_fdir_check_cmd_complete(hw, &fdircmd); 1716 if (err) { 1717 hw_dbg(hw, "Flow Director command did not complete!\n"); 1718 return err; 1719 } 1720 1721 /* if filter exists in hardware then remove it */ 1722 if (fdircmd & IXGBE_FDIRCMD_FILTER_VALID) { 1723 IXGBE_WRITE_REG(hw, IXGBE_FDIRHASH, fdirhash); 1724 IXGBE_WRITE_FLUSH(hw); 1725 IXGBE_WRITE_REG(hw, IXGBE_FDIRCMD, 1726 IXGBE_FDIRCMD_CMD_REMOVE_FLOW); 1727 } 1728 1729 return 0; 1730} 1731 1732/** 1733 * ixgbe_read_analog_reg8_82599 - Reads 8 bit Omer analog register 1734 * @hw: pointer to hardware structure 1735 * @reg: analog register to read 1736 * @val: read value 1737 * 1738 * Performs read operation to Omer analog register specified. 1739 **/ 1740static int ixgbe_read_analog_reg8_82599(struct ixgbe_hw *hw, u32 reg, u8 *val) 1741{ 1742 u32 core_ctl; 1743 1744 IXGBE_WRITE_REG(hw, IXGBE_CORECTL, IXGBE_CORECTL_WRITE_CMD | 1745 (reg << 8)); 1746 IXGBE_WRITE_FLUSH(hw); 1747 udelay(10); 1748 core_ctl = IXGBE_READ_REG(hw, IXGBE_CORECTL); 1749 *val = (u8)core_ctl; 1750 1751 return 0; 1752} 1753 1754/** 1755 * ixgbe_write_analog_reg8_82599 - Writes 8 bit Omer analog register 1756 * @hw: pointer to hardware structure 1757 * @reg: atlas register to write 1758 * @val: value to write 1759 * 1760 * Performs write operation to Omer analog register specified. 1761 **/ 1762static int ixgbe_write_analog_reg8_82599(struct ixgbe_hw *hw, u32 reg, u8 val) 1763{ 1764 u32 core_ctl; 1765 1766 core_ctl = (reg << 8) | val; 1767 IXGBE_WRITE_REG(hw, IXGBE_CORECTL, core_ctl); 1768 IXGBE_WRITE_FLUSH(hw); 1769 udelay(10); 1770 1771 return 0; 1772} 1773 1774/** 1775 * ixgbe_start_hw_82599 - Prepare hardware for Tx/Rx 1776 * @hw: pointer to hardware structure 1777 * 1778 * Starts the hardware using the generic start_hw function 1779 * and the generation start_hw function. 1780 * Then performs revision-specific operations, if any. 1781 **/ 1782static int ixgbe_start_hw_82599(struct ixgbe_hw *hw) 1783{ 1784 int ret_val = 0; 1785 1786 ret_val = ixgbe_start_hw_generic(hw); 1787 if (ret_val) 1788 return ret_val; 1789 1790 ret_val = ixgbe_start_hw_gen2(hw); 1791 if (ret_val) 1792 return ret_val; 1793 1794 /* We need to run link autotry after the driver loads */ 1795 hw->mac.autotry_restart = true; 1796 1797 return ixgbe_verify_fw_version_82599(hw); 1798} 1799 1800/** 1801 * ixgbe_identify_phy_82599 - Get physical layer module 1802 * @hw: pointer to hardware structure 1803 * 1804 * Determines the physical layer module found on the current adapter. 1805 * If PHY already detected, maintains current PHY type in hw struct, 1806 * otherwise executes the PHY detection routine. 1807 **/ 1808static int ixgbe_identify_phy_82599(struct ixgbe_hw *hw) 1809{ 1810 int status; 1811 1812 /* Detect PHY if not unknown - returns success if already detected. */ 1813 status = ixgbe_identify_phy_generic(hw); 1814 if (status) { 1815 /* 82599 10GBASE-T requires an external PHY */ 1816 if (hw->mac.ops.get_media_type(hw) == ixgbe_media_type_copper) 1817 return status; 1818 status = ixgbe_identify_module_generic(hw); 1819 } 1820 1821 /* Set PHY type none if no PHY detected */ 1822 if (hw->phy.type == ixgbe_phy_unknown) { 1823 hw->phy.type = ixgbe_phy_none; 1824 status = 0; 1825 } 1826 1827 /* Return error if SFP module has been detected but is not supported */ 1828 if (hw->phy.type == ixgbe_phy_sfp_unsupported) 1829 return -EOPNOTSUPP; 1830 1831 return status; 1832} 1833 1834/** 1835 * ixgbe_enable_rx_dma_82599 - Enable the Rx DMA unit on 82599 1836 * @hw: pointer to hardware structure 1837 * @regval: register value to write to RXCTRL 1838 * 1839 * Enables the Rx DMA unit for 82599 1840 **/ 1841static int ixgbe_enable_rx_dma_82599(struct ixgbe_hw *hw, u32 regval) 1842{ 1843 /* 1844 * Workaround for 82599 silicon errata when enabling the Rx datapath. 1845 * If traffic is incoming before we enable the Rx unit, it could hang 1846 * the Rx DMA unit. Therefore, make sure the security engine is 1847 * completely disabled prior to enabling the Rx unit. 1848 */ 1849 hw->mac.ops.disable_rx_buff(hw); 1850 1851 if (regval & IXGBE_RXCTRL_RXEN) 1852 hw->mac.ops.enable_rx(hw); 1853 else 1854 hw->mac.ops.disable_rx(hw); 1855 1856 hw->mac.ops.enable_rx_buff(hw); 1857 1858 return 0; 1859} 1860 1861/** 1862 * ixgbe_verify_fw_version_82599 - verify fw version for 82599 1863 * @hw: pointer to hardware structure 1864 * 1865 * Verifies that installed the firmware version is 0.6 or higher 1866 * for SFI devices. All 82599 SFI devices should have version 0.6 or higher. 1867 * 1868 * Return: -EACCES if the FW is not present or if the FW version is 1869 * not supported. 1870 **/ 1871static int ixgbe_verify_fw_version_82599(struct ixgbe_hw *hw) 1872{ 1873 u16 fw_offset, fw_ptp_cfg_offset; 1874 int status = -EACCES; 1875 u16 fw_version = 0; 1876 u16 offset; 1877 1878 /* firmware check is only necessary for SFI devices */ 1879 if (hw->phy.media_type != ixgbe_media_type_fiber) 1880 return 0; 1881 1882 /* get the offset to the Firmware Module block */ 1883 offset = IXGBE_FW_PTR; 1884 if (hw->eeprom.ops.read(hw, offset, &fw_offset)) 1885 goto fw_version_err; 1886 1887 if (fw_offset == 0 || fw_offset == 0xFFFF) 1888 return -EACCES; 1889 1890 /* get the offset to the Pass Through Patch Configuration block */ 1891 offset = fw_offset + IXGBE_FW_PASSTHROUGH_PATCH_CONFIG_PTR; 1892 if (hw->eeprom.ops.read(hw, offset, &fw_ptp_cfg_offset)) 1893 goto fw_version_err; 1894 1895 if (fw_ptp_cfg_offset == 0 || fw_ptp_cfg_offset == 0xFFFF) 1896 return -EACCES; 1897 1898 /* get the firmware version */ 1899 offset = fw_ptp_cfg_offset + IXGBE_FW_PATCH_VERSION_4; 1900 if (hw->eeprom.ops.read(hw, offset, &fw_version)) 1901 goto fw_version_err; 1902 1903 if (fw_version > 0x5) 1904 status = 0; 1905 1906 return status; 1907 1908fw_version_err: 1909 hw_err(hw, "eeprom read at offset %d failed\n", offset); 1910 return -EACCES; 1911} 1912 1913/** 1914 * ixgbe_verify_lesm_fw_enabled_82599 - Checks LESM FW module state. 1915 * @hw: pointer to hardware structure 1916 * 1917 * Returns true if the LESM FW module is present and enabled. Otherwise 1918 * returns false. Smart Speed must be disabled if LESM FW module is enabled. 1919 **/ 1920static bool ixgbe_verify_lesm_fw_enabled_82599(struct ixgbe_hw *hw) 1921{ 1922 u16 fw_offset, fw_lesm_param_offset, fw_lesm_state; 1923 int status; 1924 1925 /* get the offset to the Firmware Module block */ 1926 status = hw->eeprom.ops.read(hw, IXGBE_FW_PTR, &fw_offset); 1927 1928 if (status || fw_offset == 0 || fw_offset == 0xFFFF) 1929 return false; 1930 1931 /* get the offset to the LESM Parameters block */ 1932 status = hw->eeprom.ops.read(hw, (fw_offset + 1933 IXGBE_FW_LESM_PARAMETERS_PTR), 1934 &fw_lesm_param_offset); 1935 1936 if (status || 1937 fw_lesm_param_offset == 0 || fw_lesm_param_offset == 0xFFFF) 1938 return false; 1939 1940 /* get the lesm state word */ 1941 status = hw->eeprom.ops.read(hw, (fw_lesm_param_offset + 1942 IXGBE_FW_LESM_STATE_1), 1943 &fw_lesm_state); 1944 1945 if (!status && (fw_lesm_state & IXGBE_FW_LESM_STATE_ENABLED)) 1946 return true; 1947 1948 return false; 1949} 1950 1951/** 1952 * ixgbe_read_eeprom_buffer_82599 - Read EEPROM word(s) using 1953 * fastest available method 1954 * 1955 * @hw: pointer to hardware structure 1956 * @offset: offset of word in EEPROM to read 1957 * @words: number of words 1958 * @data: word(s) read from the EEPROM 1959 * 1960 * Retrieves 16 bit word(s) read from EEPROM 1961 **/ 1962static int ixgbe_read_eeprom_buffer_82599(struct ixgbe_hw *hw, u16 offset, 1963 u16 words, u16 *data) 1964{ 1965 struct ixgbe_eeprom_info *eeprom = &hw->eeprom; 1966 1967 /* If EEPROM is detected and can be addressed using 14 bits, 1968 * use EERD otherwise use bit bang 1969 */ 1970 if (eeprom->type == ixgbe_eeprom_spi && 1971 offset + (words - 1) <= IXGBE_EERD_MAX_ADDR) 1972 return ixgbe_read_eerd_buffer_generic(hw, offset, words, data); 1973 1974 return ixgbe_read_eeprom_buffer_bit_bang_generic(hw, offset, words, 1975 data); 1976} 1977 1978/** 1979 * ixgbe_read_eeprom_82599 - Read EEPROM word using 1980 * fastest available method 1981 * 1982 * @hw: pointer to hardware structure 1983 * @offset: offset of word in the EEPROM to read 1984 * @data: word read from the EEPROM 1985 * 1986 * Reads a 16 bit word from the EEPROM 1987 **/ 1988static int ixgbe_read_eeprom_82599(struct ixgbe_hw *hw, 1989 u16 offset, u16 *data) 1990{ 1991 struct ixgbe_eeprom_info *eeprom = &hw->eeprom; 1992 1993 /* 1994 * If EEPROM is detected and can be addressed using 14 bits, 1995 * use EERD otherwise use bit bang 1996 */ 1997 if (eeprom->type == ixgbe_eeprom_spi && offset <= IXGBE_EERD_MAX_ADDR) 1998 return ixgbe_read_eerd_generic(hw, offset, data); 1999 2000 return ixgbe_read_eeprom_bit_bang_generic(hw, offset, data); 2001} 2002 2003/** 2004 * ixgbe_reset_pipeline_82599 - perform pipeline reset 2005 * 2006 * @hw: pointer to hardware structure 2007 * 2008 * Reset pipeline by asserting Restart_AN together with LMS change to ensure 2009 * full pipeline reset. Note - We must hold the SW/FW semaphore before writing 2010 * to AUTOC, so this function assumes the semaphore is held. 2011 **/ 2012static int ixgbe_reset_pipeline_82599(struct ixgbe_hw *hw) 2013{ 2014 u32 i, autoc_reg, autoc2_reg; 2015 u32 anlp1_reg = 0; 2016 int ret_val; 2017 2018 /* Enable link if disabled in NVM */ 2019 autoc2_reg = IXGBE_READ_REG(hw, IXGBE_AUTOC2); 2020 if (autoc2_reg & IXGBE_AUTOC2_LINK_DISABLE_MASK) { 2021 autoc2_reg &= ~IXGBE_AUTOC2_LINK_DISABLE_MASK; 2022 IXGBE_WRITE_REG(hw, IXGBE_AUTOC2, autoc2_reg); 2023 IXGBE_WRITE_FLUSH(hw); 2024 } 2025 2026 autoc_reg = IXGBE_READ_REG(hw, IXGBE_AUTOC); 2027 autoc_reg |= IXGBE_AUTOC_AN_RESTART; 2028 2029 /* Write AUTOC register with toggled LMS[2] bit and Restart_AN */ 2030 IXGBE_WRITE_REG(hw, IXGBE_AUTOC, 2031 autoc_reg ^ (0x4 << IXGBE_AUTOC_LMS_SHIFT)); 2032 2033 /* Wait for AN to leave state 0 */ 2034 for (i = 0; i < 10; i++) { 2035 usleep_range(4000, 8000); 2036 anlp1_reg = IXGBE_READ_REG(hw, IXGBE_ANLP1); 2037 if (anlp1_reg & IXGBE_ANLP1_AN_STATE_MASK) 2038 break; 2039 } 2040 2041 if (!(anlp1_reg & IXGBE_ANLP1_AN_STATE_MASK)) { 2042 hw_dbg(hw, "auto negotiation not completed\n"); 2043 ret_val = -EIO; 2044 goto reset_pipeline_out; 2045 } 2046 2047 ret_val = 0; 2048 2049reset_pipeline_out: 2050 /* Write AUTOC register with original LMS field and Restart_AN */ 2051 IXGBE_WRITE_REG(hw, IXGBE_AUTOC, autoc_reg); 2052 IXGBE_WRITE_FLUSH(hw); 2053 2054 return ret_val; 2055} 2056 2057/** 2058 * ixgbe_read_i2c_byte_82599 - Reads 8 bit word over I2C 2059 * @hw: pointer to hardware structure 2060 * @byte_offset: byte offset to read 2061 * @dev_addr: address to read from 2062 * @data: value read 2063 * 2064 * Performs byte read operation to SFP module's EEPROM over I2C interface at 2065 * a specified device address. 2066 **/ 2067static int ixgbe_read_i2c_byte_82599(struct ixgbe_hw *hw, u8 byte_offset, 2068 u8 dev_addr, u8 *data) 2069{ 2070 s32 timeout = 200; 2071 int status; 2072 u32 esdp; 2073 2074 if (hw->phy.qsfp_shared_i2c_bus == true) { 2075 /* Acquire I2C bus ownership. */ 2076 esdp = IXGBE_READ_REG(hw, IXGBE_ESDP); 2077 esdp |= IXGBE_ESDP_SDP0; 2078 IXGBE_WRITE_REG(hw, IXGBE_ESDP, esdp); 2079 IXGBE_WRITE_FLUSH(hw); 2080 2081 while (timeout) { 2082 esdp = IXGBE_READ_REG(hw, IXGBE_ESDP); 2083 if (esdp & IXGBE_ESDP_SDP1) 2084 break; 2085 2086 usleep_range(5000, 10000); 2087 timeout--; 2088 } 2089 2090 if (!timeout) { 2091 hw_dbg(hw, "Driver can't access resource, acquiring I2C bus timeout.\n"); 2092 status = -EIO; 2093 goto release_i2c_access; 2094 } 2095 } 2096 2097 status = ixgbe_read_i2c_byte_generic(hw, byte_offset, dev_addr, data); 2098 2099release_i2c_access: 2100 if (hw->phy.qsfp_shared_i2c_bus == true) { 2101 /* Release I2C bus ownership. */ 2102 esdp = IXGBE_READ_REG(hw, IXGBE_ESDP); 2103 esdp &= ~IXGBE_ESDP_SDP0; 2104 IXGBE_WRITE_REG(hw, IXGBE_ESDP, esdp); 2105 IXGBE_WRITE_FLUSH(hw); 2106 } 2107 2108 return status; 2109} 2110 2111/** 2112 * ixgbe_write_i2c_byte_82599 - Writes 8 bit word over I2C 2113 * @hw: pointer to hardware structure 2114 * @byte_offset: byte offset to write 2115 * @dev_addr: address to write to 2116 * @data: value to write 2117 * 2118 * Performs byte write operation to SFP module's EEPROM over I2C interface at 2119 * a specified device address. 2120 **/ 2121static int ixgbe_write_i2c_byte_82599(struct ixgbe_hw *hw, u8 byte_offset, 2122 u8 dev_addr, u8 data) 2123{ 2124 s32 timeout = 200; 2125 int status; 2126 u32 esdp; 2127 2128 if (hw->phy.qsfp_shared_i2c_bus == true) { 2129 /* Acquire I2C bus ownership. */ 2130 esdp = IXGBE_READ_REG(hw, IXGBE_ESDP); 2131 esdp |= IXGBE_ESDP_SDP0; 2132 IXGBE_WRITE_REG(hw, IXGBE_ESDP, esdp); 2133 IXGBE_WRITE_FLUSH(hw); 2134 2135 while (timeout) { 2136 esdp = IXGBE_READ_REG(hw, IXGBE_ESDP); 2137 if (esdp & IXGBE_ESDP_SDP1) 2138 break; 2139 2140 usleep_range(5000, 10000); 2141 timeout--; 2142 } 2143 2144 if (!timeout) { 2145 hw_dbg(hw, "Driver can't access resource, acquiring I2C bus timeout.\n"); 2146 status = -EIO; 2147 goto release_i2c_access; 2148 } 2149 } 2150 2151 status = ixgbe_write_i2c_byte_generic(hw, byte_offset, dev_addr, data); 2152 2153release_i2c_access: 2154 if (hw->phy.qsfp_shared_i2c_bus == true) { 2155 /* Release I2C bus ownership. */ 2156 esdp = IXGBE_READ_REG(hw, IXGBE_ESDP); 2157 esdp &= ~IXGBE_ESDP_SDP0; 2158 IXGBE_WRITE_REG(hw, IXGBE_ESDP, esdp); 2159 IXGBE_WRITE_FLUSH(hw); 2160 } 2161 2162 return status; 2163} 2164 2165static const struct ixgbe_mac_operations mac_ops_82599 = { 2166 .init_hw = &ixgbe_init_hw_generic, 2167 .reset_hw = &ixgbe_reset_hw_82599, 2168 .start_hw = &ixgbe_start_hw_82599, 2169 .clear_hw_cntrs = &ixgbe_clear_hw_cntrs_generic, 2170 .get_media_type = &ixgbe_get_media_type_82599, 2171 .enable_rx_dma = &ixgbe_enable_rx_dma_82599, 2172 .disable_rx_buff = &ixgbe_disable_rx_buff_generic, 2173 .enable_rx_buff = &ixgbe_enable_rx_buff_generic, 2174 .get_mac_addr = &ixgbe_get_mac_addr_generic, 2175 .get_san_mac_addr = &ixgbe_get_san_mac_addr_generic, 2176 .get_device_caps = &ixgbe_get_device_caps_generic, 2177 .get_wwn_prefix = &ixgbe_get_wwn_prefix_generic, 2178 .stop_adapter = &ixgbe_stop_adapter_generic, 2179 .get_bus_info = &ixgbe_get_bus_info_generic, 2180 .set_lan_id = &ixgbe_set_lan_id_multi_port_pcie, 2181 .read_analog_reg8 = &ixgbe_read_analog_reg8_82599, 2182 .write_analog_reg8 = &ixgbe_write_analog_reg8_82599, 2183 .stop_link_on_d3 = &ixgbe_stop_mac_link_on_d3_82599, 2184 .setup_link = &ixgbe_setup_mac_link_82599, 2185 .set_rxpba = &ixgbe_set_rxpba_generic, 2186 .check_link = &ixgbe_check_mac_link_generic, 2187 .get_link_capabilities = &ixgbe_get_link_capabilities_82599, 2188 .led_on = &ixgbe_led_on_generic, 2189 .led_off = &ixgbe_led_off_generic, 2190 .init_led_link_act = ixgbe_init_led_link_act_generic, 2191 .blink_led_start = &ixgbe_blink_led_start_generic, 2192 .blink_led_stop = &ixgbe_blink_led_stop_generic, 2193 .set_rar = &ixgbe_set_rar_generic, 2194 .clear_rar = &ixgbe_clear_rar_generic, 2195 .set_vmdq = &ixgbe_set_vmdq_generic, 2196 .set_vmdq_san_mac = &ixgbe_set_vmdq_san_mac_generic, 2197 .clear_vmdq = &ixgbe_clear_vmdq_generic, 2198 .init_rx_addrs = &ixgbe_init_rx_addrs_generic, 2199 .update_mc_addr_list = &ixgbe_update_mc_addr_list_generic, 2200 .enable_mc = &ixgbe_enable_mc_generic, 2201 .disable_mc = &ixgbe_disable_mc_generic, 2202 .clear_vfta = &ixgbe_clear_vfta_generic, 2203 .set_vfta = &ixgbe_set_vfta_generic, 2204 .fc_enable = &ixgbe_fc_enable_generic, 2205 .setup_fc = ixgbe_setup_fc_generic, 2206 .fc_autoneg = ixgbe_fc_autoneg, 2207 .set_fw_drv_ver = &ixgbe_set_fw_drv_ver_generic, 2208 .init_uta_tables = &ixgbe_init_uta_tables_generic, 2209 .setup_sfp = &ixgbe_setup_sfp_modules_82599, 2210 .set_mac_anti_spoofing = &ixgbe_set_mac_anti_spoofing, 2211 .set_vlan_anti_spoofing = &ixgbe_set_vlan_anti_spoofing, 2212 .acquire_swfw_sync = &ixgbe_acquire_swfw_sync, 2213 .release_swfw_sync = &ixgbe_release_swfw_sync, 2214 .init_swfw_sync = NULL, 2215 .get_thermal_sensor_data = &ixgbe_get_thermal_sensor_data_generic, 2216 .init_thermal_sensor_thresh = &ixgbe_init_thermal_sensor_thresh_generic, 2217 .prot_autoc_read = &prot_autoc_read_82599, 2218 .prot_autoc_write = &prot_autoc_write_82599, 2219 .enable_rx = &ixgbe_enable_rx_generic, 2220 .disable_rx = &ixgbe_disable_rx_generic, 2221}; 2222 2223static const struct ixgbe_eeprom_operations eeprom_ops_82599 = { 2224 .init_params = &ixgbe_init_eeprom_params_generic, 2225 .read = &ixgbe_read_eeprom_82599, 2226 .read_buffer = &ixgbe_read_eeprom_buffer_82599, 2227 .write = &ixgbe_write_eeprom_generic, 2228 .write_buffer = &ixgbe_write_eeprom_buffer_bit_bang_generic, 2229 .calc_checksum = &ixgbe_calc_eeprom_checksum_generic, 2230 .validate_checksum = &ixgbe_validate_eeprom_checksum_generic, 2231 .update_checksum = &ixgbe_update_eeprom_checksum_generic, 2232}; 2233 2234static const struct ixgbe_phy_operations phy_ops_82599 = { 2235 .identify = &ixgbe_identify_phy_82599, 2236 .identify_sfp = &ixgbe_identify_module_generic, 2237 .init = &ixgbe_init_phy_ops_82599, 2238 .reset = &ixgbe_reset_phy_generic, 2239 .read_reg = &ixgbe_read_phy_reg_generic, 2240 .write_reg = &ixgbe_write_phy_reg_generic, 2241 .setup_link = &ixgbe_setup_phy_link_generic, 2242 .setup_link_speed = &ixgbe_setup_phy_link_speed_generic, 2243 .read_i2c_byte = &ixgbe_read_i2c_byte_generic, 2244 .write_i2c_byte = &ixgbe_write_i2c_byte_generic, 2245 .read_i2c_sff8472 = &ixgbe_read_i2c_sff8472_generic, 2246 .read_i2c_eeprom = &ixgbe_read_i2c_eeprom_generic, 2247 .write_i2c_eeprom = &ixgbe_write_i2c_eeprom_generic, 2248 .check_overtemp = &ixgbe_tn_check_overtemp, 2249}; 2250 2251const struct ixgbe_info ixgbe_82599_info = { 2252 .mac = ixgbe_mac_82599EB, 2253 .get_invariants = &ixgbe_get_invariants_82599, 2254 .mac_ops = &mac_ops_82599, 2255 .eeprom_ops = &eeprom_ops_82599, 2256 .phy_ops = &phy_ops_82599, 2257 .mbx_ops = &mbx_ops_generic, 2258 .mvals = ixgbe_mvals_8259X, 2259}; 2260