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 #include <linux/netdevice.h> 8 9 #include "ixgbe.h" 10 #include "ixgbe_common.h" 11 #include "ixgbe_phy.h" 12 13 static s32 ixgbe_acquire_eeprom(struct ixgbe_hw *hw); 14 static s32 ixgbe_get_eeprom_semaphore(struct ixgbe_hw *hw); 15 static void ixgbe_release_eeprom_semaphore(struct ixgbe_hw *hw); 16 static s32 ixgbe_ready_eeprom(struct ixgbe_hw *hw); 17 static void ixgbe_standby_eeprom(struct ixgbe_hw *hw); 18 static void ixgbe_shift_out_eeprom_bits(struct ixgbe_hw *hw, u16 data, 19 u16 count); 20 static u16 ixgbe_shift_in_eeprom_bits(struct ixgbe_hw *hw, u16 count); 21 static void ixgbe_raise_eeprom_clk(struct ixgbe_hw *hw, u32 *eec); 22 static void ixgbe_lower_eeprom_clk(struct ixgbe_hw *hw, u32 *eec); 23 static void ixgbe_release_eeprom(struct ixgbe_hw *hw); 24 25 static s32 ixgbe_mta_vector(struct ixgbe_hw *hw, u8 *mc_addr); 26 static s32 ixgbe_poll_eerd_eewr_done(struct ixgbe_hw *hw, u32 ee_reg); 27 static s32 ixgbe_read_eeprom_buffer_bit_bang(struct ixgbe_hw *hw, u16 offset, 28 u16 words, u16 *data); 29 static s32 ixgbe_write_eeprom_buffer_bit_bang(struct ixgbe_hw *hw, u16 offset, 30 u16 words, u16 *data); 31 static s32 ixgbe_detect_eeprom_page_size_generic(struct ixgbe_hw *hw, 32 u16 offset); 33 static s32 ixgbe_disable_pcie_master(struct ixgbe_hw *hw); 34 35 /* Base table for registers values that change by MAC */ 36 const u32 ixgbe_mvals_8259X[IXGBE_MVALS_IDX_LIMIT] = { 37 IXGBE_MVALS_INIT(8259X) 38 }; 39 40 /** 41 * ixgbe_device_supports_autoneg_fc - Check if phy supports autoneg flow 42 * control 43 * @hw: pointer to hardware structure 44 * 45 * There are several phys that do not support autoneg flow control. This 46 * function check the device id to see if the associated phy supports 47 * autoneg flow control. 48 **/ 49 bool ixgbe_device_supports_autoneg_fc(struct ixgbe_hw *hw) 50 { 51 bool supported = false; 52 ixgbe_link_speed speed; 53 bool link_up; 54 55 switch (hw->phy.media_type) { 56 case ixgbe_media_type_fiber: 57 /* flow control autoneg black list */ 58 switch (hw->device_id) { 59 case IXGBE_DEV_ID_X550EM_A_SFP: 60 case IXGBE_DEV_ID_X550EM_A_SFP_N: 61 supported = false; 62 break; 63 default: 64 hw->mac.ops.check_link(hw, &speed, &link_up, false); 65 /* if link is down, assume supported */ 66 if (link_up) 67 supported = speed == IXGBE_LINK_SPEED_1GB_FULL ? 68 true : false; 69 else 70 supported = true; 71 } 72 73 break; 74 case ixgbe_media_type_backplane: 75 if (hw->device_id == IXGBE_DEV_ID_X550EM_X_XFI) 76 supported = false; 77 else 78 supported = true; 79 break; 80 case ixgbe_media_type_copper: 81 /* only some copper devices support flow control autoneg */ 82 switch (hw->device_id) { 83 case IXGBE_DEV_ID_82599_T3_LOM: 84 case IXGBE_DEV_ID_X540T: 85 case IXGBE_DEV_ID_X540T1: 86 case IXGBE_DEV_ID_X550T: 87 case IXGBE_DEV_ID_X550T1: 88 case IXGBE_DEV_ID_X550EM_X_10G_T: 89 case IXGBE_DEV_ID_X550EM_A_10G_T: 90 case IXGBE_DEV_ID_X550EM_A_1G_T: 91 case IXGBE_DEV_ID_X550EM_A_1G_T_L: 92 supported = true; 93 break; 94 default: 95 break; 96 } 97 default: 98 break; 99 } 100 101 if (!supported) 102 hw_dbg(hw, "Device %x does not support flow control autoneg\n", 103 hw->device_id); 104 105 return supported; 106 } 107 108 /** 109 * ixgbe_setup_fc_generic - Set up flow control 110 * @hw: pointer to hardware structure 111 * 112 * Called at init time to set up flow control. 113 **/ 114 s32 ixgbe_setup_fc_generic(struct ixgbe_hw *hw) 115 { 116 s32 ret_val = 0; 117 u32 reg = 0, reg_bp = 0; 118 u16 reg_cu = 0; 119 bool locked = false; 120 121 /* 122 * Validate the requested mode. Strict IEEE mode does not allow 123 * ixgbe_fc_rx_pause because it will cause us to fail at UNH. 124 */ 125 if (hw->fc.strict_ieee && hw->fc.requested_mode == ixgbe_fc_rx_pause) { 126 hw_dbg(hw, "ixgbe_fc_rx_pause not valid in strict IEEE mode\n"); 127 return IXGBE_ERR_INVALID_LINK_SETTINGS; 128 } 129 130 /* 131 * 10gig parts do not have a word in the EEPROM to determine the 132 * default flow control setting, so we explicitly set it to full. 133 */ 134 if (hw->fc.requested_mode == ixgbe_fc_default) 135 hw->fc.requested_mode = ixgbe_fc_full; 136 137 /* 138 * Set up the 1G and 10G flow control advertisement registers so the 139 * HW will be able to do fc autoneg once the cable is plugged in. If 140 * we link at 10G, the 1G advertisement is harmless and vice versa. 141 */ 142 switch (hw->phy.media_type) { 143 case ixgbe_media_type_backplane: 144 /* some MAC's need RMW protection on AUTOC */ 145 ret_val = hw->mac.ops.prot_autoc_read(hw, &locked, ®_bp); 146 if (ret_val) 147 return ret_val; 148 149 /* fall through - only backplane uses autoc */ 150 case ixgbe_media_type_fiber: 151 reg = IXGBE_READ_REG(hw, IXGBE_PCS1GANA); 152 153 break; 154 case ixgbe_media_type_copper: 155 hw->phy.ops.read_reg(hw, MDIO_AN_ADVERTISE, 156 MDIO_MMD_AN, ®_cu); 157 break; 158 default: 159 break; 160 } 161 162 /* 163 * The possible values of fc.requested_mode are: 164 * 0: Flow control is completely disabled 165 * 1: Rx flow control is enabled (we can receive pause frames, 166 * but not send pause frames). 167 * 2: Tx flow control is enabled (we can send pause frames but 168 * we do not support receiving pause frames). 169 * 3: Both Rx and Tx flow control (symmetric) are enabled. 170 * other: Invalid. 171 */ 172 switch (hw->fc.requested_mode) { 173 case ixgbe_fc_none: 174 /* Flow control completely disabled by software override. */ 175 reg &= ~(IXGBE_PCS1GANA_SYM_PAUSE | IXGBE_PCS1GANA_ASM_PAUSE); 176 if (hw->phy.media_type == ixgbe_media_type_backplane) 177 reg_bp &= ~(IXGBE_AUTOC_SYM_PAUSE | 178 IXGBE_AUTOC_ASM_PAUSE); 179 else if (hw->phy.media_type == ixgbe_media_type_copper) 180 reg_cu &= ~(IXGBE_TAF_SYM_PAUSE | IXGBE_TAF_ASM_PAUSE); 181 break; 182 case ixgbe_fc_tx_pause: 183 /* 184 * Tx Flow control is enabled, and Rx Flow control is 185 * disabled by software override. 186 */ 187 reg |= IXGBE_PCS1GANA_ASM_PAUSE; 188 reg &= ~IXGBE_PCS1GANA_SYM_PAUSE; 189 if (hw->phy.media_type == ixgbe_media_type_backplane) { 190 reg_bp |= IXGBE_AUTOC_ASM_PAUSE; 191 reg_bp &= ~IXGBE_AUTOC_SYM_PAUSE; 192 } else if (hw->phy.media_type == ixgbe_media_type_copper) { 193 reg_cu |= IXGBE_TAF_ASM_PAUSE; 194 reg_cu &= ~IXGBE_TAF_SYM_PAUSE; 195 } 196 break; 197 case ixgbe_fc_rx_pause: 198 /* 199 * Rx Flow control is enabled and Tx Flow control is 200 * disabled by software override. Since there really 201 * isn't a way to advertise that we are capable of RX 202 * Pause ONLY, we will advertise that we support both 203 * symmetric and asymmetric Rx PAUSE, as such we fall 204 * through to the fc_full statement. Later, we will 205 * disable the adapter's ability to send PAUSE frames. 206 */ 207 case ixgbe_fc_full: 208 /* Flow control (both Rx and Tx) is enabled by SW override. */ 209 reg |= IXGBE_PCS1GANA_SYM_PAUSE | IXGBE_PCS1GANA_ASM_PAUSE; 210 if (hw->phy.media_type == ixgbe_media_type_backplane) 211 reg_bp |= IXGBE_AUTOC_SYM_PAUSE | 212 IXGBE_AUTOC_ASM_PAUSE; 213 else if (hw->phy.media_type == ixgbe_media_type_copper) 214 reg_cu |= IXGBE_TAF_SYM_PAUSE | IXGBE_TAF_ASM_PAUSE; 215 break; 216 default: 217 hw_dbg(hw, "Flow control param set incorrectly\n"); 218 return IXGBE_ERR_CONFIG; 219 } 220 221 if (hw->mac.type != ixgbe_mac_X540) { 222 /* 223 * Enable auto-negotiation between the MAC & PHY; 224 * the MAC will advertise clause 37 flow control. 225 */ 226 IXGBE_WRITE_REG(hw, IXGBE_PCS1GANA, reg); 227 reg = IXGBE_READ_REG(hw, IXGBE_PCS1GLCTL); 228 229 /* Disable AN timeout */ 230 if (hw->fc.strict_ieee) 231 reg &= ~IXGBE_PCS1GLCTL_AN_1G_TIMEOUT_EN; 232 233 IXGBE_WRITE_REG(hw, IXGBE_PCS1GLCTL, reg); 234 hw_dbg(hw, "Set up FC; PCS1GLCTL = 0x%08X\n", reg); 235 } 236 237 /* 238 * AUTOC restart handles negotiation of 1G and 10G on backplane 239 * and copper. There is no need to set the PCS1GCTL register. 240 * 241 */ 242 if (hw->phy.media_type == ixgbe_media_type_backplane) { 243 /* Need the SW/FW semaphore around AUTOC writes if 82599 and 244 * LESM is on, likewise reset_pipeline requries the lock as 245 * it also writes AUTOC. 246 */ 247 ret_val = hw->mac.ops.prot_autoc_write(hw, reg_bp, locked); 248 if (ret_val) 249 return ret_val; 250 251 } else if ((hw->phy.media_type == ixgbe_media_type_copper) && 252 ixgbe_device_supports_autoneg_fc(hw)) { 253 hw->phy.ops.write_reg(hw, MDIO_AN_ADVERTISE, 254 MDIO_MMD_AN, reg_cu); 255 } 256 257 hw_dbg(hw, "Set up FC; IXGBE_AUTOC = 0x%08X\n", reg); 258 return ret_val; 259 } 260 261 /** 262 * ixgbe_start_hw_generic - Prepare hardware for Tx/Rx 263 * @hw: pointer to hardware structure 264 * 265 * Starts the hardware by filling the bus info structure and media type, clears 266 * all on chip counters, initializes receive address registers, multicast 267 * table, VLAN filter table, calls routine to set up link and flow control 268 * settings, and leaves transmit and receive units disabled and uninitialized 269 **/ 270 s32 ixgbe_start_hw_generic(struct ixgbe_hw *hw) 271 { 272 s32 ret_val; 273 u32 ctrl_ext; 274 u16 device_caps; 275 276 /* Set the media type */ 277 hw->phy.media_type = hw->mac.ops.get_media_type(hw); 278 279 /* Identify the PHY */ 280 hw->phy.ops.identify(hw); 281 282 /* Clear the VLAN filter table */ 283 hw->mac.ops.clear_vfta(hw); 284 285 /* Clear statistics registers */ 286 hw->mac.ops.clear_hw_cntrs(hw); 287 288 /* Set No Snoop Disable */ 289 ctrl_ext = IXGBE_READ_REG(hw, IXGBE_CTRL_EXT); 290 ctrl_ext |= IXGBE_CTRL_EXT_NS_DIS; 291 IXGBE_WRITE_REG(hw, IXGBE_CTRL_EXT, ctrl_ext); 292 IXGBE_WRITE_FLUSH(hw); 293 294 /* Setup flow control if method for doing so */ 295 if (hw->mac.ops.setup_fc) { 296 ret_val = hw->mac.ops.setup_fc(hw); 297 if (ret_val) 298 return ret_val; 299 } 300 301 /* Cashe bit indicating need for crosstalk fix */ 302 switch (hw->mac.type) { 303 case ixgbe_mac_82599EB: 304 case ixgbe_mac_X550EM_x: 305 case ixgbe_mac_x550em_a: 306 hw->mac.ops.get_device_caps(hw, &device_caps); 307 if (device_caps & IXGBE_DEVICE_CAPS_NO_CROSSTALK_WR) 308 hw->need_crosstalk_fix = false; 309 else 310 hw->need_crosstalk_fix = true; 311 break; 312 default: 313 hw->need_crosstalk_fix = false; 314 break; 315 } 316 317 /* Clear adapter stopped flag */ 318 hw->adapter_stopped = false; 319 320 return 0; 321 } 322 323 /** 324 * ixgbe_start_hw_gen2 - Init sequence for common device family 325 * @hw: pointer to hw structure 326 * 327 * Performs the init sequence common to the second generation 328 * of 10 GbE devices. 329 * Devices in the second generation: 330 * 82599 331 * X540 332 **/ 333 s32 ixgbe_start_hw_gen2(struct ixgbe_hw *hw) 334 { 335 u32 i; 336 337 /* Clear the rate limiters */ 338 for (i = 0; i < hw->mac.max_tx_queues; i++) { 339 IXGBE_WRITE_REG(hw, IXGBE_RTTDQSEL, i); 340 IXGBE_WRITE_REG(hw, IXGBE_RTTBCNRC, 0); 341 } 342 IXGBE_WRITE_FLUSH(hw); 343 344 return 0; 345 } 346 347 /** 348 * ixgbe_init_hw_generic - Generic hardware initialization 349 * @hw: pointer to hardware structure 350 * 351 * Initialize the hardware by resetting the hardware, filling the bus info 352 * structure and media type, clears all on chip counters, initializes receive 353 * address registers, multicast table, VLAN filter table, calls routine to set 354 * up link and flow control settings, and leaves transmit and receive units 355 * disabled and uninitialized 356 **/ 357 s32 ixgbe_init_hw_generic(struct ixgbe_hw *hw) 358 { 359 s32 status; 360 361 /* Reset the hardware */ 362 status = hw->mac.ops.reset_hw(hw); 363 364 if (status == 0) { 365 /* Start the HW */ 366 status = hw->mac.ops.start_hw(hw); 367 } 368 369 /* Initialize the LED link active for LED blink support */ 370 if (hw->mac.ops.init_led_link_act) 371 hw->mac.ops.init_led_link_act(hw); 372 373 return status; 374 } 375 376 /** 377 * ixgbe_clear_hw_cntrs_generic - Generic clear hardware counters 378 * @hw: pointer to hardware structure 379 * 380 * Clears all hardware statistics counters by reading them from the hardware 381 * Statistics counters are clear on read. 382 **/ 383 s32 ixgbe_clear_hw_cntrs_generic(struct ixgbe_hw *hw) 384 { 385 u16 i = 0; 386 387 IXGBE_READ_REG(hw, IXGBE_CRCERRS); 388 IXGBE_READ_REG(hw, IXGBE_ILLERRC); 389 IXGBE_READ_REG(hw, IXGBE_ERRBC); 390 IXGBE_READ_REG(hw, IXGBE_MSPDC); 391 for (i = 0; i < 8; i++) 392 IXGBE_READ_REG(hw, IXGBE_MPC(i)); 393 394 IXGBE_READ_REG(hw, IXGBE_MLFC); 395 IXGBE_READ_REG(hw, IXGBE_MRFC); 396 IXGBE_READ_REG(hw, IXGBE_RLEC); 397 IXGBE_READ_REG(hw, IXGBE_LXONTXC); 398 IXGBE_READ_REG(hw, IXGBE_LXOFFTXC); 399 if (hw->mac.type >= ixgbe_mac_82599EB) { 400 IXGBE_READ_REG(hw, IXGBE_LXONRXCNT); 401 IXGBE_READ_REG(hw, IXGBE_LXOFFRXCNT); 402 } else { 403 IXGBE_READ_REG(hw, IXGBE_LXONRXC); 404 IXGBE_READ_REG(hw, IXGBE_LXOFFRXC); 405 } 406 407 for (i = 0; i < 8; i++) { 408 IXGBE_READ_REG(hw, IXGBE_PXONTXC(i)); 409 IXGBE_READ_REG(hw, IXGBE_PXOFFTXC(i)); 410 if (hw->mac.type >= ixgbe_mac_82599EB) { 411 IXGBE_READ_REG(hw, IXGBE_PXONRXCNT(i)); 412 IXGBE_READ_REG(hw, IXGBE_PXOFFRXCNT(i)); 413 } else { 414 IXGBE_READ_REG(hw, IXGBE_PXONRXC(i)); 415 IXGBE_READ_REG(hw, IXGBE_PXOFFRXC(i)); 416 } 417 } 418 if (hw->mac.type >= ixgbe_mac_82599EB) 419 for (i = 0; i < 8; i++) 420 IXGBE_READ_REG(hw, IXGBE_PXON2OFFCNT(i)); 421 IXGBE_READ_REG(hw, IXGBE_PRC64); 422 IXGBE_READ_REG(hw, IXGBE_PRC127); 423 IXGBE_READ_REG(hw, IXGBE_PRC255); 424 IXGBE_READ_REG(hw, IXGBE_PRC511); 425 IXGBE_READ_REG(hw, IXGBE_PRC1023); 426 IXGBE_READ_REG(hw, IXGBE_PRC1522); 427 IXGBE_READ_REG(hw, IXGBE_GPRC); 428 IXGBE_READ_REG(hw, IXGBE_BPRC); 429 IXGBE_READ_REG(hw, IXGBE_MPRC); 430 IXGBE_READ_REG(hw, IXGBE_GPTC); 431 IXGBE_READ_REG(hw, IXGBE_GORCL); 432 IXGBE_READ_REG(hw, IXGBE_GORCH); 433 IXGBE_READ_REG(hw, IXGBE_GOTCL); 434 IXGBE_READ_REG(hw, IXGBE_GOTCH); 435 if (hw->mac.type == ixgbe_mac_82598EB) 436 for (i = 0; i < 8; i++) 437 IXGBE_READ_REG(hw, IXGBE_RNBC(i)); 438 IXGBE_READ_REG(hw, IXGBE_RUC); 439 IXGBE_READ_REG(hw, IXGBE_RFC); 440 IXGBE_READ_REG(hw, IXGBE_ROC); 441 IXGBE_READ_REG(hw, IXGBE_RJC); 442 IXGBE_READ_REG(hw, IXGBE_MNGPRC); 443 IXGBE_READ_REG(hw, IXGBE_MNGPDC); 444 IXGBE_READ_REG(hw, IXGBE_MNGPTC); 445 IXGBE_READ_REG(hw, IXGBE_TORL); 446 IXGBE_READ_REG(hw, IXGBE_TORH); 447 IXGBE_READ_REG(hw, IXGBE_TPR); 448 IXGBE_READ_REG(hw, IXGBE_TPT); 449 IXGBE_READ_REG(hw, IXGBE_PTC64); 450 IXGBE_READ_REG(hw, IXGBE_PTC127); 451 IXGBE_READ_REG(hw, IXGBE_PTC255); 452 IXGBE_READ_REG(hw, IXGBE_PTC511); 453 IXGBE_READ_REG(hw, IXGBE_PTC1023); 454 IXGBE_READ_REG(hw, IXGBE_PTC1522); 455 IXGBE_READ_REG(hw, IXGBE_MPTC); 456 IXGBE_READ_REG(hw, IXGBE_BPTC); 457 for (i = 0; i < 16; i++) { 458 IXGBE_READ_REG(hw, IXGBE_QPRC(i)); 459 IXGBE_READ_REG(hw, IXGBE_QPTC(i)); 460 if (hw->mac.type >= ixgbe_mac_82599EB) { 461 IXGBE_READ_REG(hw, IXGBE_QBRC_L(i)); 462 IXGBE_READ_REG(hw, IXGBE_QBRC_H(i)); 463 IXGBE_READ_REG(hw, IXGBE_QBTC_L(i)); 464 IXGBE_READ_REG(hw, IXGBE_QBTC_H(i)); 465 IXGBE_READ_REG(hw, IXGBE_QPRDC(i)); 466 } else { 467 IXGBE_READ_REG(hw, IXGBE_QBRC(i)); 468 IXGBE_READ_REG(hw, IXGBE_QBTC(i)); 469 } 470 } 471 472 if (hw->mac.type == ixgbe_mac_X550 || hw->mac.type == ixgbe_mac_X540) { 473 if (hw->phy.id == 0) 474 hw->phy.ops.identify(hw); 475 hw->phy.ops.read_reg(hw, IXGBE_PCRC8ECL, MDIO_MMD_PCS, &i); 476 hw->phy.ops.read_reg(hw, IXGBE_PCRC8ECH, MDIO_MMD_PCS, &i); 477 hw->phy.ops.read_reg(hw, IXGBE_LDPCECL, MDIO_MMD_PCS, &i); 478 hw->phy.ops.read_reg(hw, IXGBE_LDPCECH, MDIO_MMD_PCS, &i); 479 } 480 481 return 0; 482 } 483 484 /** 485 * ixgbe_read_pba_string_generic - Reads part number string from EEPROM 486 * @hw: pointer to hardware structure 487 * @pba_num: stores the part number string from the EEPROM 488 * @pba_num_size: part number string buffer length 489 * 490 * Reads the part number string from the EEPROM. 491 **/ 492 s32 ixgbe_read_pba_string_generic(struct ixgbe_hw *hw, u8 *pba_num, 493 u32 pba_num_size) 494 { 495 s32 ret_val; 496 u16 data; 497 u16 pba_ptr; 498 u16 offset; 499 u16 length; 500 501 if (pba_num == NULL) { 502 hw_dbg(hw, "PBA string buffer was null\n"); 503 return IXGBE_ERR_INVALID_ARGUMENT; 504 } 505 506 ret_val = hw->eeprom.ops.read(hw, IXGBE_PBANUM0_PTR, &data); 507 if (ret_val) { 508 hw_dbg(hw, "NVM Read Error\n"); 509 return ret_val; 510 } 511 512 ret_val = hw->eeprom.ops.read(hw, IXGBE_PBANUM1_PTR, &pba_ptr); 513 if (ret_val) { 514 hw_dbg(hw, "NVM Read Error\n"); 515 return ret_val; 516 } 517 518 /* 519 * if data is not ptr guard the PBA must be in legacy format which 520 * means pba_ptr is actually our second data word for the PBA number 521 * and we can decode it into an ascii string 522 */ 523 if (data != IXGBE_PBANUM_PTR_GUARD) { 524 hw_dbg(hw, "NVM PBA number is not stored as string\n"); 525 526 /* we will need 11 characters to store the PBA */ 527 if (pba_num_size < 11) { 528 hw_dbg(hw, "PBA string buffer too small\n"); 529 return IXGBE_ERR_NO_SPACE; 530 } 531 532 /* extract hex string from data and pba_ptr */ 533 pba_num[0] = (data >> 12) & 0xF; 534 pba_num[1] = (data >> 8) & 0xF; 535 pba_num[2] = (data >> 4) & 0xF; 536 pba_num[3] = data & 0xF; 537 pba_num[4] = (pba_ptr >> 12) & 0xF; 538 pba_num[5] = (pba_ptr >> 8) & 0xF; 539 pba_num[6] = '-'; 540 pba_num[7] = 0; 541 pba_num[8] = (pba_ptr >> 4) & 0xF; 542 pba_num[9] = pba_ptr & 0xF; 543 544 /* put a null character on the end of our string */ 545 pba_num[10] = '\0'; 546 547 /* switch all the data but the '-' to hex char */ 548 for (offset = 0; offset < 10; offset++) { 549 if (pba_num[offset] < 0xA) 550 pba_num[offset] += '0'; 551 else if (pba_num[offset] < 0x10) 552 pba_num[offset] += 'A' - 0xA; 553 } 554 555 return 0; 556 } 557 558 ret_val = hw->eeprom.ops.read(hw, pba_ptr, &length); 559 if (ret_val) { 560 hw_dbg(hw, "NVM Read Error\n"); 561 return ret_val; 562 } 563 564 if (length == 0xFFFF || length == 0) { 565 hw_dbg(hw, "NVM PBA number section invalid length\n"); 566 return IXGBE_ERR_PBA_SECTION; 567 } 568 569 /* check if pba_num buffer is big enough */ 570 if (pba_num_size < (((u32)length * 2) - 1)) { 571 hw_dbg(hw, "PBA string buffer too small\n"); 572 return IXGBE_ERR_NO_SPACE; 573 } 574 575 /* trim pba length from start of string */ 576 pba_ptr++; 577 length--; 578 579 for (offset = 0; offset < length; offset++) { 580 ret_val = hw->eeprom.ops.read(hw, pba_ptr + offset, &data); 581 if (ret_val) { 582 hw_dbg(hw, "NVM Read Error\n"); 583 return ret_val; 584 } 585 pba_num[offset * 2] = (u8)(data >> 8); 586 pba_num[(offset * 2) + 1] = (u8)(data & 0xFF); 587 } 588 pba_num[offset * 2] = '\0'; 589 590 return 0; 591 } 592 593 /** 594 * ixgbe_get_mac_addr_generic - Generic get MAC address 595 * @hw: pointer to hardware structure 596 * @mac_addr: Adapter MAC address 597 * 598 * Reads the adapter's MAC address from first Receive Address Register (RAR0) 599 * A reset of the adapter must be performed prior to calling this function 600 * in order for the MAC address to have been loaded from the EEPROM into RAR0 601 **/ 602 s32 ixgbe_get_mac_addr_generic(struct ixgbe_hw *hw, u8 *mac_addr) 603 { 604 u32 rar_high; 605 u32 rar_low; 606 u16 i; 607 608 rar_high = IXGBE_READ_REG(hw, IXGBE_RAH(0)); 609 rar_low = IXGBE_READ_REG(hw, IXGBE_RAL(0)); 610 611 for (i = 0; i < 4; i++) 612 mac_addr[i] = (u8)(rar_low >> (i*8)); 613 614 for (i = 0; i < 2; i++) 615 mac_addr[i+4] = (u8)(rar_high >> (i*8)); 616 617 return 0; 618 } 619 620 enum ixgbe_bus_width ixgbe_convert_bus_width(u16 link_status) 621 { 622 switch (link_status & IXGBE_PCI_LINK_WIDTH) { 623 case IXGBE_PCI_LINK_WIDTH_1: 624 return ixgbe_bus_width_pcie_x1; 625 case IXGBE_PCI_LINK_WIDTH_2: 626 return ixgbe_bus_width_pcie_x2; 627 case IXGBE_PCI_LINK_WIDTH_4: 628 return ixgbe_bus_width_pcie_x4; 629 case IXGBE_PCI_LINK_WIDTH_8: 630 return ixgbe_bus_width_pcie_x8; 631 default: 632 return ixgbe_bus_width_unknown; 633 } 634 } 635 636 enum ixgbe_bus_speed ixgbe_convert_bus_speed(u16 link_status) 637 { 638 switch (link_status & IXGBE_PCI_LINK_SPEED) { 639 case IXGBE_PCI_LINK_SPEED_2500: 640 return ixgbe_bus_speed_2500; 641 case IXGBE_PCI_LINK_SPEED_5000: 642 return ixgbe_bus_speed_5000; 643 case IXGBE_PCI_LINK_SPEED_8000: 644 return ixgbe_bus_speed_8000; 645 default: 646 return ixgbe_bus_speed_unknown; 647 } 648 } 649 650 /** 651 * ixgbe_get_bus_info_generic - Generic set PCI bus info 652 * @hw: pointer to hardware structure 653 * 654 * Sets the PCI bus info (speed, width, type) within the ixgbe_hw structure 655 **/ 656 s32 ixgbe_get_bus_info_generic(struct ixgbe_hw *hw) 657 { 658 u16 link_status; 659 660 hw->bus.type = ixgbe_bus_type_pci_express; 661 662 /* Get the negotiated link width and speed from PCI config space */ 663 link_status = ixgbe_read_pci_cfg_word(hw, IXGBE_PCI_LINK_STATUS); 664 665 hw->bus.width = ixgbe_convert_bus_width(link_status); 666 hw->bus.speed = ixgbe_convert_bus_speed(link_status); 667 668 hw->mac.ops.set_lan_id(hw); 669 670 return 0; 671 } 672 673 /** 674 * ixgbe_set_lan_id_multi_port_pcie - Set LAN id for PCIe multiple port devices 675 * @hw: pointer to the HW structure 676 * 677 * Determines the LAN function id by reading memory-mapped registers 678 * and swaps the port value if requested. 679 **/ 680 void ixgbe_set_lan_id_multi_port_pcie(struct ixgbe_hw *hw) 681 { 682 struct ixgbe_bus_info *bus = &hw->bus; 683 u16 ee_ctrl_4; 684 u32 reg; 685 686 reg = IXGBE_READ_REG(hw, IXGBE_STATUS); 687 bus->func = (reg & IXGBE_STATUS_LAN_ID) >> IXGBE_STATUS_LAN_ID_SHIFT; 688 bus->lan_id = bus->func; 689 690 /* check for a port swap */ 691 reg = IXGBE_READ_REG(hw, IXGBE_FACTPS(hw)); 692 if (reg & IXGBE_FACTPS_LFS) 693 bus->func ^= 0x1; 694 695 /* Get MAC instance from EEPROM for configuring CS4227 */ 696 if (hw->device_id == IXGBE_DEV_ID_X550EM_A_SFP) { 697 hw->eeprom.ops.read(hw, IXGBE_EEPROM_CTRL_4, &ee_ctrl_4); 698 bus->instance_id = (ee_ctrl_4 & IXGBE_EE_CTRL_4_INST_ID) >> 699 IXGBE_EE_CTRL_4_INST_ID_SHIFT; 700 } 701 } 702 703 /** 704 * ixgbe_stop_adapter_generic - Generic stop Tx/Rx units 705 * @hw: pointer to hardware structure 706 * 707 * Sets the adapter_stopped flag within ixgbe_hw struct. Clears interrupts, 708 * disables transmit and receive units. The adapter_stopped flag is used by 709 * the shared code and drivers to determine if the adapter is in a stopped 710 * state and should not touch the hardware. 711 **/ 712 s32 ixgbe_stop_adapter_generic(struct ixgbe_hw *hw) 713 { 714 u32 reg_val; 715 u16 i; 716 717 /* 718 * Set the adapter_stopped flag so other driver functions stop touching 719 * the hardware 720 */ 721 hw->adapter_stopped = true; 722 723 /* Disable the receive unit */ 724 hw->mac.ops.disable_rx(hw); 725 726 /* Clear interrupt mask to stop interrupts from being generated */ 727 IXGBE_WRITE_REG(hw, IXGBE_EIMC, IXGBE_IRQ_CLEAR_MASK); 728 729 /* Clear any pending interrupts, flush previous writes */ 730 IXGBE_READ_REG(hw, IXGBE_EICR); 731 732 /* Disable the transmit unit. Each queue must be disabled. */ 733 for (i = 0; i < hw->mac.max_tx_queues; i++) 734 IXGBE_WRITE_REG(hw, IXGBE_TXDCTL(i), IXGBE_TXDCTL_SWFLSH); 735 736 /* Disable the receive unit by stopping each queue */ 737 for (i = 0; i < hw->mac.max_rx_queues; i++) { 738 reg_val = IXGBE_READ_REG(hw, IXGBE_RXDCTL(i)); 739 reg_val &= ~IXGBE_RXDCTL_ENABLE; 740 reg_val |= IXGBE_RXDCTL_SWFLSH; 741 IXGBE_WRITE_REG(hw, IXGBE_RXDCTL(i), reg_val); 742 } 743 744 /* flush all queues disables */ 745 IXGBE_WRITE_FLUSH(hw); 746 usleep_range(1000, 2000); 747 748 /* 749 * Prevent the PCI-E bus from from hanging by disabling PCI-E master 750 * access and verify no pending requests 751 */ 752 return ixgbe_disable_pcie_master(hw); 753 } 754 755 /** 756 * ixgbe_init_led_link_act_generic - Store the LED index link/activity. 757 * @hw: pointer to hardware structure 758 * 759 * Store the index for the link active LED. This will be used to support 760 * blinking the LED. 761 **/ 762 s32 ixgbe_init_led_link_act_generic(struct ixgbe_hw *hw) 763 { 764 struct ixgbe_mac_info *mac = &hw->mac; 765 u32 led_reg, led_mode; 766 u16 i; 767 768 led_reg = IXGBE_READ_REG(hw, IXGBE_LEDCTL); 769 770 /* Get LED link active from the LEDCTL register */ 771 for (i = 0; i < 4; i++) { 772 led_mode = led_reg >> IXGBE_LED_MODE_SHIFT(i); 773 774 if ((led_mode & IXGBE_LED_MODE_MASK_BASE) == 775 IXGBE_LED_LINK_ACTIVE) { 776 mac->led_link_act = i; 777 return 0; 778 } 779 } 780 781 /* If LEDCTL register does not have the LED link active set, then use 782 * known MAC defaults. 783 */ 784 switch (hw->mac.type) { 785 case ixgbe_mac_x550em_a: 786 mac->led_link_act = 0; 787 break; 788 case ixgbe_mac_X550EM_x: 789 mac->led_link_act = 1; 790 break; 791 default: 792 mac->led_link_act = 2; 793 } 794 795 return 0; 796 } 797 798 /** 799 * ixgbe_led_on_generic - Turns on the software controllable LEDs. 800 * @hw: pointer to hardware structure 801 * @index: led number to turn on 802 **/ 803 s32 ixgbe_led_on_generic(struct ixgbe_hw *hw, u32 index) 804 { 805 u32 led_reg = IXGBE_READ_REG(hw, IXGBE_LEDCTL); 806 807 if (index > 3) 808 return IXGBE_ERR_PARAM; 809 810 /* To turn on the LED, set mode to ON. */ 811 led_reg &= ~IXGBE_LED_MODE_MASK(index); 812 led_reg |= IXGBE_LED_ON << IXGBE_LED_MODE_SHIFT(index); 813 IXGBE_WRITE_REG(hw, IXGBE_LEDCTL, led_reg); 814 IXGBE_WRITE_FLUSH(hw); 815 816 return 0; 817 } 818 819 /** 820 * ixgbe_led_off_generic - Turns off the software controllable LEDs. 821 * @hw: pointer to hardware structure 822 * @index: led number to turn off 823 **/ 824 s32 ixgbe_led_off_generic(struct ixgbe_hw *hw, u32 index) 825 { 826 u32 led_reg = IXGBE_READ_REG(hw, IXGBE_LEDCTL); 827 828 if (index > 3) 829 return IXGBE_ERR_PARAM; 830 831 /* To turn off the LED, set mode to OFF. */ 832 led_reg &= ~IXGBE_LED_MODE_MASK(index); 833 led_reg |= IXGBE_LED_OFF << IXGBE_LED_MODE_SHIFT(index); 834 IXGBE_WRITE_REG(hw, IXGBE_LEDCTL, led_reg); 835 IXGBE_WRITE_FLUSH(hw); 836 837 return 0; 838 } 839 840 /** 841 * ixgbe_init_eeprom_params_generic - Initialize EEPROM params 842 * @hw: pointer to hardware structure 843 * 844 * Initializes the EEPROM parameters ixgbe_eeprom_info within the 845 * ixgbe_hw struct in order to set up EEPROM access. 846 **/ 847 s32 ixgbe_init_eeprom_params_generic(struct ixgbe_hw *hw) 848 { 849 struct ixgbe_eeprom_info *eeprom = &hw->eeprom; 850 u32 eec; 851 u16 eeprom_size; 852 853 if (eeprom->type == ixgbe_eeprom_uninitialized) { 854 eeprom->type = ixgbe_eeprom_none; 855 /* Set default semaphore delay to 10ms which is a well 856 * tested value */ 857 eeprom->semaphore_delay = 10; 858 /* Clear EEPROM page size, it will be initialized as needed */ 859 eeprom->word_page_size = 0; 860 861 /* 862 * Check for EEPROM present first. 863 * If not present leave as none 864 */ 865 eec = IXGBE_READ_REG(hw, IXGBE_EEC(hw)); 866 if (eec & IXGBE_EEC_PRES) { 867 eeprom->type = ixgbe_eeprom_spi; 868 869 /* 870 * SPI EEPROM is assumed here. This code would need to 871 * change if a future EEPROM is not SPI. 872 */ 873 eeprom_size = (u16)((eec & IXGBE_EEC_SIZE) >> 874 IXGBE_EEC_SIZE_SHIFT); 875 eeprom->word_size = BIT(eeprom_size + 876 IXGBE_EEPROM_WORD_SIZE_SHIFT); 877 } 878 879 if (eec & IXGBE_EEC_ADDR_SIZE) 880 eeprom->address_bits = 16; 881 else 882 eeprom->address_bits = 8; 883 hw_dbg(hw, "Eeprom params: type = %d, size = %d, address bits: %d\n", 884 eeprom->type, eeprom->word_size, eeprom->address_bits); 885 } 886 887 return 0; 888 } 889 890 /** 891 * ixgbe_write_eeprom_buffer_bit_bang_generic - Write EEPROM using bit-bang 892 * @hw: pointer to hardware structure 893 * @offset: offset within the EEPROM to write 894 * @words: number of words 895 * @data: 16 bit word(s) to write to EEPROM 896 * 897 * Reads 16 bit word(s) from EEPROM through bit-bang method 898 **/ 899 s32 ixgbe_write_eeprom_buffer_bit_bang_generic(struct ixgbe_hw *hw, u16 offset, 900 u16 words, u16 *data) 901 { 902 s32 status; 903 u16 i, count; 904 905 hw->eeprom.ops.init_params(hw); 906 907 if (words == 0) 908 return IXGBE_ERR_INVALID_ARGUMENT; 909 910 if (offset + words > hw->eeprom.word_size) 911 return IXGBE_ERR_EEPROM; 912 913 /* 914 * The EEPROM page size cannot be queried from the chip. We do lazy 915 * initialization. It is worth to do that when we write large buffer. 916 */ 917 if ((hw->eeprom.word_page_size == 0) && 918 (words > IXGBE_EEPROM_PAGE_SIZE_MAX)) 919 ixgbe_detect_eeprom_page_size_generic(hw, offset); 920 921 /* 922 * We cannot hold synchronization semaphores for too long 923 * to avoid other entity starvation. However it is more efficient 924 * to read in bursts than synchronizing access for each word. 925 */ 926 for (i = 0; i < words; i += IXGBE_EEPROM_RD_BUFFER_MAX_COUNT) { 927 count = (words - i) / IXGBE_EEPROM_RD_BUFFER_MAX_COUNT > 0 ? 928 IXGBE_EEPROM_RD_BUFFER_MAX_COUNT : (words - i); 929 status = ixgbe_write_eeprom_buffer_bit_bang(hw, offset + i, 930 count, &data[i]); 931 932 if (status != 0) 933 break; 934 } 935 936 return status; 937 } 938 939 /** 940 * ixgbe_write_eeprom_buffer_bit_bang - Writes 16 bit word(s) to EEPROM 941 * @hw: pointer to hardware structure 942 * @offset: offset within the EEPROM to be written to 943 * @words: number of word(s) 944 * @data: 16 bit word(s) to be written to the EEPROM 945 * 946 * If ixgbe_eeprom_update_checksum is not called after this function, the 947 * EEPROM will most likely contain an invalid checksum. 948 **/ 949 static s32 ixgbe_write_eeprom_buffer_bit_bang(struct ixgbe_hw *hw, u16 offset, 950 u16 words, u16 *data) 951 { 952 s32 status; 953 u16 word; 954 u16 page_size; 955 u16 i; 956 u8 write_opcode = IXGBE_EEPROM_WRITE_OPCODE_SPI; 957 958 /* Prepare the EEPROM for writing */ 959 status = ixgbe_acquire_eeprom(hw); 960 if (status) 961 return status; 962 963 if (ixgbe_ready_eeprom(hw) != 0) { 964 ixgbe_release_eeprom(hw); 965 return IXGBE_ERR_EEPROM; 966 } 967 968 for (i = 0; i < words; i++) { 969 ixgbe_standby_eeprom(hw); 970 971 /* Send the WRITE ENABLE command (8 bit opcode) */ 972 ixgbe_shift_out_eeprom_bits(hw, 973 IXGBE_EEPROM_WREN_OPCODE_SPI, 974 IXGBE_EEPROM_OPCODE_BITS); 975 976 ixgbe_standby_eeprom(hw); 977 978 /* Some SPI eeproms use the 8th address bit embedded 979 * in the opcode 980 */ 981 if ((hw->eeprom.address_bits == 8) && 982 ((offset + i) >= 128)) 983 write_opcode |= IXGBE_EEPROM_A8_OPCODE_SPI; 984 985 /* Send the Write command (8-bit opcode + addr) */ 986 ixgbe_shift_out_eeprom_bits(hw, write_opcode, 987 IXGBE_EEPROM_OPCODE_BITS); 988 ixgbe_shift_out_eeprom_bits(hw, (u16)((offset + i) * 2), 989 hw->eeprom.address_bits); 990 991 page_size = hw->eeprom.word_page_size; 992 993 /* Send the data in burst via SPI */ 994 do { 995 word = data[i]; 996 word = (word >> 8) | (word << 8); 997 ixgbe_shift_out_eeprom_bits(hw, word, 16); 998 999 if (page_size == 0) 1000 break; 1001 1002 /* do not wrap around page */ 1003 if (((offset + i) & (page_size - 1)) == 1004 (page_size - 1)) 1005 break; 1006 } while (++i < words); 1007 1008 ixgbe_standby_eeprom(hw); 1009 usleep_range(10000, 20000); 1010 } 1011 /* Done with writing - release the EEPROM */ 1012 ixgbe_release_eeprom(hw); 1013 1014 return 0; 1015 } 1016 1017 /** 1018 * ixgbe_write_eeprom_generic - Writes 16 bit value to EEPROM 1019 * @hw: pointer to hardware structure 1020 * @offset: offset within the EEPROM to be written to 1021 * @data: 16 bit word to be written to the EEPROM 1022 * 1023 * If ixgbe_eeprom_update_checksum is not called after this function, the 1024 * EEPROM will most likely contain an invalid checksum. 1025 **/ 1026 s32 ixgbe_write_eeprom_generic(struct ixgbe_hw *hw, u16 offset, u16 data) 1027 { 1028 hw->eeprom.ops.init_params(hw); 1029 1030 if (offset >= hw->eeprom.word_size) 1031 return IXGBE_ERR_EEPROM; 1032 1033 return ixgbe_write_eeprom_buffer_bit_bang(hw, offset, 1, &data); 1034 } 1035 1036 /** 1037 * ixgbe_read_eeprom_buffer_bit_bang_generic - Read EEPROM using bit-bang 1038 * @hw: pointer to hardware structure 1039 * @offset: offset within the EEPROM to be read 1040 * @words: number of word(s) 1041 * @data: read 16 bit words(s) from EEPROM 1042 * 1043 * Reads 16 bit word(s) from EEPROM through bit-bang method 1044 **/ 1045 s32 ixgbe_read_eeprom_buffer_bit_bang_generic(struct ixgbe_hw *hw, u16 offset, 1046 u16 words, u16 *data) 1047 { 1048 s32 status; 1049 u16 i, count; 1050 1051 hw->eeprom.ops.init_params(hw); 1052 1053 if (words == 0) 1054 return IXGBE_ERR_INVALID_ARGUMENT; 1055 1056 if (offset + words > hw->eeprom.word_size) 1057 return IXGBE_ERR_EEPROM; 1058 1059 /* 1060 * We cannot hold synchronization semaphores for too long 1061 * to avoid other entity starvation. However it is more efficient 1062 * to read in bursts than synchronizing access for each word. 1063 */ 1064 for (i = 0; i < words; i += IXGBE_EEPROM_RD_BUFFER_MAX_COUNT) { 1065 count = (words - i) / IXGBE_EEPROM_RD_BUFFER_MAX_COUNT > 0 ? 1066 IXGBE_EEPROM_RD_BUFFER_MAX_COUNT : (words - i); 1067 1068 status = ixgbe_read_eeprom_buffer_bit_bang(hw, offset + i, 1069 count, &data[i]); 1070 1071 if (status) 1072 return status; 1073 } 1074 1075 return 0; 1076 } 1077 1078 /** 1079 * ixgbe_read_eeprom_buffer_bit_bang - Read EEPROM using bit-bang 1080 * @hw: pointer to hardware structure 1081 * @offset: offset within the EEPROM to be read 1082 * @words: number of word(s) 1083 * @data: read 16 bit word(s) from EEPROM 1084 * 1085 * Reads 16 bit word(s) from EEPROM through bit-bang method 1086 **/ 1087 static s32 ixgbe_read_eeprom_buffer_bit_bang(struct ixgbe_hw *hw, u16 offset, 1088 u16 words, u16 *data) 1089 { 1090 s32 status; 1091 u16 word_in; 1092 u8 read_opcode = IXGBE_EEPROM_READ_OPCODE_SPI; 1093 u16 i; 1094 1095 /* Prepare the EEPROM for reading */ 1096 status = ixgbe_acquire_eeprom(hw); 1097 if (status) 1098 return status; 1099 1100 if (ixgbe_ready_eeprom(hw) != 0) { 1101 ixgbe_release_eeprom(hw); 1102 return IXGBE_ERR_EEPROM; 1103 } 1104 1105 for (i = 0; i < words; i++) { 1106 ixgbe_standby_eeprom(hw); 1107 /* Some SPI eeproms use the 8th address bit embedded 1108 * in the opcode 1109 */ 1110 if ((hw->eeprom.address_bits == 8) && 1111 ((offset + i) >= 128)) 1112 read_opcode |= IXGBE_EEPROM_A8_OPCODE_SPI; 1113 1114 /* Send the READ command (opcode + addr) */ 1115 ixgbe_shift_out_eeprom_bits(hw, read_opcode, 1116 IXGBE_EEPROM_OPCODE_BITS); 1117 ixgbe_shift_out_eeprom_bits(hw, (u16)((offset + i) * 2), 1118 hw->eeprom.address_bits); 1119 1120 /* Read the data. */ 1121 word_in = ixgbe_shift_in_eeprom_bits(hw, 16); 1122 data[i] = (word_in >> 8) | (word_in << 8); 1123 } 1124 1125 /* End this read operation */ 1126 ixgbe_release_eeprom(hw); 1127 1128 return 0; 1129 } 1130 1131 /** 1132 * ixgbe_read_eeprom_bit_bang_generic - Read EEPROM word using bit-bang 1133 * @hw: pointer to hardware structure 1134 * @offset: offset within the EEPROM to be read 1135 * @data: read 16 bit value from EEPROM 1136 * 1137 * Reads 16 bit value from EEPROM through bit-bang method 1138 **/ 1139 s32 ixgbe_read_eeprom_bit_bang_generic(struct ixgbe_hw *hw, u16 offset, 1140 u16 *data) 1141 { 1142 hw->eeprom.ops.init_params(hw); 1143 1144 if (offset >= hw->eeprom.word_size) 1145 return IXGBE_ERR_EEPROM; 1146 1147 return ixgbe_read_eeprom_buffer_bit_bang(hw, offset, 1, data); 1148 } 1149 1150 /** 1151 * ixgbe_read_eerd_buffer_generic - Read EEPROM word(s) using EERD 1152 * @hw: pointer to hardware structure 1153 * @offset: offset of word in the EEPROM to read 1154 * @words: number of word(s) 1155 * @data: 16 bit word(s) from the EEPROM 1156 * 1157 * Reads a 16 bit word(s) from the EEPROM using the EERD register. 1158 **/ 1159 s32 ixgbe_read_eerd_buffer_generic(struct ixgbe_hw *hw, u16 offset, 1160 u16 words, u16 *data) 1161 { 1162 u32 eerd; 1163 s32 status; 1164 u32 i; 1165 1166 hw->eeprom.ops.init_params(hw); 1167 1168 if (words == 0) 1169 return IXGBE_ERR_INVALID_ARGUMENT; 1170 1171 if (offset >= hw->eeprom.word_size) 1172 return IXGBE_ERR_EEPROM; 1173 1174 for (i = 0; i < words; i++) { 1175 eerd = ((offset + i) << IXGBE_EEPROM_RW_ADDR_SHIFT) | 1176 IXGBE_EEPROM_RW_REG_START; 1177 1178 IXGBE_WRITE_REG(hw, IXGBE_EERD, eerd); 1179 status = ixgbe_poll_eerd_eewr_done(hw, IXGBE_NVM_POLL_READ); 1180 1181 if (status == 0) { 1182 data[i] = (IXGBE_READ_REG(hw, IXGBE_EERD) >> 1183 IXGBE_EEPROM_RW_REG_DATA); 1184 } else { 1185 hw_dbg(hw, "Eeprom read timed out\n"); 1186 return status; 1187 } 1188 } 1189 1190 return 0; 1191 } 1192 1193 /** 1194 * ixgbe_detect_eeprom_page_size_generic - Detect EEPROM page size 1195 * @hw: pointer to hardware structure 1196 * @offset: offset within the EEPROM to be used as a scratch pad 1197 * 1198 * Discover EEPROM page size by writing marching data at given offset. 1199 * This function is called only when we are writing a new large buffer 1200 * at given offset so the data would be overwritten anyway. 1201 **/ 1202 static s32 ixgbe_detect_eeprom_page_size_generic(struct ixgbe_hw *hw, 1203 u16 offset) 1204 { 1205 u16 data[IXGBE_EEPROM_PAGE_SIZE_MAX]; 1206 s32 status; 1207 u16 i; 1208 1209 for (i = 0; i < IXGBE_EEPROM_PAGE_SIZE_MAX; i++) 1210 data[i] = i; 1211 1212 hw->eeprom.word_page_size = IXGBE_EEPROM_PAGE_SIZE_MAX; 1213 status = ixgbe_write_eeprom_buffer_bit_bang(hw, offset, 1214 IXGBE_EEPROM_PAGE_SIZE_MAX, data); 1215 hw->eeprom.word_page_size = 0; 1216 if (status) 1217 return status; 1218 1219 status = ixgbe_read_eeprom_buffer_bit_bang(hw, offset, 1, data); 1220 if (status) 1221 return status; 1222 1223 /* 1224 * When writing in burst more than the actual page size 1225 * EEPROM address wraps around current page. 1226 */ 1227 hw->eeprom.word_page_size = IXGBE_EEPROM_PAGE_SIZE_MAX - data[0]; 1228 1229 hw_dbg(hw, "Detected EEPROM page size = %d words.\n", 1230 hw->eeprom.word_page_size); 1231 return 0; 1232 } 1233 1234 /** 1235 * ixgbe_read_eerd_generic - Read EEPROM word using EERD 1236 * @hw: pointer to hardware structure 1237 * @offset: offset of word in the EEPROM to read 1238 * @data: word read from the EEPROM 1239 * 1240 * Reads a 16 bit word from the EEPROM using the EERD register. 1241 **/ 1242 s32 ixgbe_read_eerd_generic(struct ixgbe_hw *hw, u16 offset, u16 *data) 1243 { 1244 return ixgbe_read_eerd_buffer_generic(hw, offset, 1, data); 1245 } 1246 1247 /** 1248 * ixgbe_write_eewr_buffer_generic - Write EEPROM word(s) using EEWR 1249 * @hw: pointer to hardware structure 1250 * @offset: offset of word in the EEPROM to write 1251 * @words: number of words 1252 * @data: word(s) write to the EEPROM 1253 * 1254 * Write a 16 bit word(s) to the EEPROM using the EEWR register. 1255 **/ 1256 s32 ixgbe_write_eewr_buffer_generic(struct ixgbe_hw *hw, u16 offset, 1257 u16 words, u16 *data) 1258 { 1259 u32 eewr; 1260 s32 status; 1261 u16 i; 1262 1263 hw->eeprom.ops.init_params(hw); 1264 1265 if (words == 0) 1266 return IXGBE_ERR_INVALID_ARGUMENT; 1267 1268 if (offset >= hw->eeprom.word_size) 1269 return IXGBE_ERR_EEPROM; 1270 1271 for (i = 0; i < words; i++) { 1272 eewr = ((offset + i) << IXGBE_EEPROM_RW_ADDR_SHIFT) | 1273 (data[i] << IXGBE_EEPROM_RW_REG_DATA) | 1274 IXGBE_EEPROM_RW_REG_START; 1275 1276 status = ixgbe_poll_eerd_eewr_done(hw, IXGBE_NVM_POLL_WRITE); 1277 if (status) { 1278 hw_dbg(hw, "Eeprom write EEWR timed out\n"); 1279 return status; 1280 } 1281 1282 IXGBE_WRITE_REG(hw, IXGBE_EEWR, eewr); 1283 1284 status = ixgbe_poll_eerd_eewr_done(hw, IXGBE_NVM_POLL_WRITE); 1285 if (status) { 1286 hw_dbg(hw, "Eeprom write EEWR timed out\n"); 1287 return status; 1288 } 1289 } 1290 1291 return 0; 1292 } 1293 1294 /** 1295 * ixgbe_write_eewr_generic - Write EEPROM word using EEWR 1296 * @hw: pointer to hardware structure 1297 * @offset: offset of word in the EEPROM to write 1298 * @data: word write to the EEPROM 1299 * 1300 * Write a 16 bit word to the EEPROM using the EEWR register. 1301 **/ 1302 s32 ixgbe_write_eewr_generic(struct ixgbe_hw *hw, u16 offset, u16 data) 1303 { 1304 return ixgbe_write_eewr_buffer_generic(hw, offset, 1, &data); 1305 } 1306 1307 /** 1308 * ixgbe_poll_eerd_eewr_done - Poll EERD read or EEWR write status 1309 * @hw: pointer to hardware structure 1310 * @ee_reg: EEPROM flag for polling 1311 * 1312 * Polls the status bit (bit 1) of the EERD or EEWR to determine when the 1313 * read or write is done respectively. 1314 **/ 1315 static s32 ixgbe_poll_eerd_eewr_done(struct ixgbe_hw *hw, u32 ee_reg) 1316 { 1317 u32 i; 1318 u32 reg; 1319 1320 for (i = 0; i < IXGBE_EERD_EEWR_ATTEMPTS; i++) { 1321 if (ee_reg == IXGBE_NVM_POLL_READ) 1322 reg = IXGBE_READ_REG(hw, IXGBE_EERD); 1323 else 1324 reg = IXGBE_READ_REG(hw, IXGBE_EEWR); 1325 1326 if (reg & IXGBE_EEPROM_RW_REG_DONE) { 1327 return 0; 1328 } 1329 udelay(5); 1330 } 1331 return IXGBE_ERR_EEPROM; 1332 } 1333 1334 /** 1335 * ixgbe_acquire_eeprom - Acquire EEPROM using bit-bang 1336 * @hw: pointer to hardware structure 1337 * 1338 * Prepares EEPROM for access using bit-bang method. This function should 1339 * be called before issuing a command to the EEPROM. 1340 **/ 1341 static s32 ixgbe_acquire_eeprom(struct ixgbe_hw *hw) 1342 { 1343 u32 eec; 1344 u32 i; 1345 1346 if (hw->mac.ops.acquire_swfw_sync(hw, IXGBE_GSSR_EEP_SM) != 0) 1347 return IXGBE_ERR_SWFW_SYNC; 1348 1349 eec = IXGBE_READ_REG(hw, IXGBE_EEC(hw)); 1350 1351 /* Request EEPROM Access */ 1352 eec |= IXGBE_EEC_REQ; 1353 IXGBE_WRITE_REG(hw, IXGBE_EEC(hw), eec); 1354 1355 for (i = 0; i < IXGBE_EEPROM_GRANT_ATTEMPTS; i++) { 1356 eec = IXGBE_READ_REG(hw, IXGBE_EEC(hw)); 1357 if (eec & IXGBE_EEC_GNT) 1358 break; 1359 udelay(5); 1360 } 1361 1362 /* Release if grant not acquired */ 1363 if (!(eec & IXGBE_EEC_GNT)) { 1364 eec &= ~IXGBE_EEC_REQ; 1365 IXGBE_WRITE_REG(hw, IXGBE_EEC(hw), eec); 1366 hw_dbg(hw, "Could not acquire EEPROM grant\n"); 1367 1368 hw->mac.ops.release_swfw_sync(hw, IXGBE_GSSR_EEP_SM); 1369 return IXGBE_ERR_EEPROM; 1370 } 1371 1372 /* Setup EEPROM for Read/Write */ 1373 /* Clear CS and SK */ 1374 eec &= ~(IXGBE_EEC_CS | IXGBE_EEC_SK); 1375 IXGBE_WRITE_REG(hw, IXGBE_EEC(hw), eec); 1376 IXGBE_WRITE_FLUSH(hw); 1377 udelay(1); 1378 return 0; 1379 } 1380 1381 /** 1382 * ixgbe_get_eeprom_semaphore - Get hardware semaphore 1383 * @hw: pointer to hardware structure 1384 * 1385 * Sets the hardware semaphores so EEPROM access can occur for bit-bang method 1386 **/ 1387 static s32 ixgbe_get_eeprom_semaphore(struct ixgbe_hw *hw) 1388 { 1389 u32 timeout = 2000; 1390 u32 i; 1391 u32 swsm; 1392 1393 /* Get SMBI software semaphore between device drivers first */ 1394 for (i = 0; i < timeout; i++) { 1395 /* 1396 * If the SMBI bit is 0 when we read it, then the bit will be 1397 * set and we have the semaphore 1398 */ 1399 swsm = IXGBE_READ_REG(hw, IXGBE_SWSM(hw)); 1400 if (!(swsm & IXGBE_SWSM_SMBI)) 1401 break; 1402 usleep_range(50, 100); 1403 } 1404 1405 if (i == timeout) { 1406 hw_dbg(hw, "Driver can't access the Eeprom - SMBI Semaphore not granted.\n"); 1407 /* this release is particularly important because our attempts 1408 * above to get the semaphore may have succeeded, and if there 1409 * was a timeout, we should unconditionally clear the semaphore 1410 * bits to free the driver to make progress 1411 */ 1412 ixgbe_release_eeprom_semaphore(hw); 1413 1414 usleep_range(50, 100); 1415 /* one last try 1416 * If the SMBI bit is 0 when we read it, then the bit will be 1417 * set and we have the semaphore 1418 */ 1419 swsm = IXGBE_READ_REG(hw, IXGBE_SWSM(hw)); 1420 if (swsm & IXGBE_SWSM_SMBI) { 1421 hw_dbg(hw, "Software semaphore SMBI between device drivers not granted.\n"); 1422 return IXGBE_ERR_EEPROM; 1423 } 1424 } 1425 1426 /* Now get the semaphore between SW/FW through the SWESMBI bit */ 1427 for (i = 0; i < timeout; i++) { 1428 swsm = IXGBE_READ_REG(hw, IXGBE_SWSM(hw)); 1429 1430 /* Set the SW EEPROM semaphore bit to request access */ 1431 swsm |= IXGBE_SWSM_SWESMBI; 1432 IXGBE_WRITE_REG(hw, IXGBE_SWSM(hw), swsm); 1433 1434 /* If we set the bit successfully then we got the 1435 * semaphore. 1436 */ 1437 swsm = IXGBE_READ_REG(hw, IXGBE_SWSM(hw)); 1438 if (swsm & IXGBE_SWSM_SWESMBI) 1439 break; 1440 1441 usleep_range(50, 100); 1442 } 1443 1444 /* Release semaphores and return error if SW EEPROM semaphore 1445 * was not granted because we don't have access to the EEPROM 1446 */ 1447 if (i >= timeout) { 1448 hw_dbg(hw, "SWESMBI Software EEPROM semaphore not granted.\n"); 1449 ixgbe_release_eeprom_semaphore(hw); 1450 return IXGBE_ERR_EEPROM; 1451 } 1452 1453 return 0; 1454 } 1455 1456 /** 1457 * ixgbe_release_eeprom_semaphore - Release hardware semaphore 1458 * @hw: pointer to hardware structure 1459 * 1460 * This function clears hardware semaphore bits. 1461 **/ 1462 static void ixgbe_release_eeprom_semaphore(struct ixgbe_hw *hw) 1463 { 1464 u32 swsm; 1465 1466 swsm = IXGBE_READ_REG(hw, IXGBE_SWSM(hw)); 1467 1468 /* Release both semaphores by writing 0 to the bits SWESMBI and SMBI */ 1469 swsm &= ~(IXGBE_SWSM_SWESMBI | IXGBE_SWSM_SMBI); 1470 IXGBE_WRITE_REG(hw, IXGBE_SWSM(hw), swsm); 1471 IXGBE_WRITE_FLUSH(hw); 1472 } 1473 1474 /** 1475 * ixgbe_ready_eeprom - Polls for EEPROM ready 1476 * @hw: pointer to hardware structure 1477 **/ 1478 static s32 ixgbe_ready_eeprom(struct ixgbe_hw *hw) 1479 { 1480 u16 i; 1481 u8 spi_stat_reg; 1482 1483 /* 1484 * Read "Status Register" repeatedly until the LSB is cleared. The 1485 * EEPROM will signal that the command has been completed by clearing 1486 * bit 0 of the internal status register. If it's not cleared within 1487 * 5 milliseconds, then error out. 1488 */ 1489 for (i = 0; i < IXGBE_EEPROM_MAX_RETRY_SPI; i += 5) { 1490 ixgbe_shift_out_eeprom_bits(hw, IXGBE_EEPROM_RDSR_OPCODE_SPI, 1491 IXGBE_EEPROM_OPCODE_BITS); 1492 spi_stat_reg = (u8)ixgbe_shift_in_eeprom_bits(hw, 8); 1493 if (!(spi_stat_reg & IXGBE_EEPROM_STATUS_RDY_SPI)) 1494 break; 1495 1496 udelay(5); 1497 ixgbe_standby_eeprom(hw); 1498 } 1499 1500 /* 1501 * On some parts, SPI write time could vary from 0-20mSec on 3.3V 1502 * devices (and only 0-5mSec on 5V devices) 1503 */ 1504 if (i >= IXGBE_EEPROM_MAX_RETRY_SPI) { 1505 hw_dbg(hw, "SPI EEPROM Status error\n"); 1506 return IXGBE_ERR_EEPROM; 1507 } 1508 1509 return 0; 1510 } 1511 1512 /** 1513 * ixgbe_standby_eeprom - Returns EEPROM to a "standby" state 1514 * @hw: pointer to hardware structure 1515 **/ 1516 static void ixgbe_standby_eeprom(struct ixgbe_hw *hw) 1517 { 1518 u32 eec; 1519 1520 eec = IXGBE_READ_REG(hw, IXGBE_EEC(hw)); 1521 1522 /* Toggle CS to flush commands */ 1523 eec |= IXGBE_EEC_CS; 1524 IXGBE_WRITE_REG(hw, IXGBE_EEC(hw), eec); 1525 IXGBE_WRITE_FLUSH(hw); 1526 udelay(1); 1527 eec &= ~IXGBE_EEC_CS; 1528 IXGBE_WRITE_REG(hw, IXGBE_EEC(hw), eec); 1529 IXGBE_WRITE_FLUSH(hw); 1530 udelay(1); 1531 } 1532 1533 /** 1534 * ixgbe_shift_out_eeprom_bits - Shift data bits out to the EEPROM. 1535 * @hw: pointer to hardware structure 1536 * @data: data to send to the EEPROM 1537 * @count: number of bits to shift out 1538 **/ 1539 static void ixgbe_shift_out_eeprom_bits(struct ixgbe_hw *hw, u16 data, 1540 u16 count) 1541 { 1542 u32 eec; 1543 u32 mask; 1544 u32 i; 1545 1546 eec = IXGBE_READ_REG(hw, IXGBE_EEC(hw)); 1547 1548 /* 1549 * Mask is used to shift "count" bits of "data" out to the EEPROM 1550 * one bit at a time. Determine the starting bit based on count 1551 */ 1552 mask = BIT(count - 1); 1553 1554 for (i = 0; i < count; i++) { 1555 /* 1556 * A "1" is shifted out to the EEPROM by setting bit "DI" to a 1557 * "1", and then raising and then lowering the clock (the SK 1558 * bit controls the clock input to the EEPROM). A "0" is 1559 * shifted out to the EEPROM by setting "DI" to "0" and then 1560 * raising and then lowering the clock. 1561 */ 1562 if (data & mask) 1563 eec |= IXGBE_EEC_DI; 1564 else 1565 eec &= ~IXGBE_EEC_DI; 1566 1567 IXGBE_WRITE_REG(hw, IXGBE_EEC(hw), eec); 1568 IXGBE_WRITE_FLUSH(hw); 1569 1570 udelay(1); 1571 1572 ixgbe_raise_eeprom_clk(hw, &eec); 1573 ixgbe_lower_eeprom_clk(hw, &eec); 1574 1575 /* 1576 * Shift mask to signify next bit of data to shift in to the 1577 * EEPROM 1578 */ 1579 mask = mask >> 1; 1580 } 1581 1582 /* We leave the "DI" bit set to "0" when we leave this routine. */ 1583 eec &= ~IXGBE_EEC_DI; 1584 IXGBE_WRITE_REG(hw, IXGBE_EEC(hw), eec); 1585 IXGBE_WRITE_FLUSH(hw); 1586 } 1587 1588 /** 1589 * ixgbe_shift_in_eeprom_bits - Shift data bits in from the EEPROM 1590 * @hw: pointer to hardware structure 1591 * @count: number of bits to shift 1592 **/ 1593 static u16 ixgbe_shift_in_eeprom_bits(struct ixgbe_hw *hw, u16 count) 1594 { 1595 u32 eec; 1596 u32 i; 1597 u16 data = 0; 1598 1599 /* 1600 * In order to read a register from the EEPROM, we need to shift 1601 * 'count' bits in from the EEPROM. Bits are "shifted in" by raising 1602 * the clock input to the EEPROM (setting the SK bit), and then reading 1603 * the value of the "DO" bit. During this "shifting in" process the 1604 * "DI" bit should always be clear. 1605 */ 1606 eec = IXGBE_READ_REG(hw, IXGBE_EEC(hw)); 1607 1608 eec &= ~(IXGBE_EEC_DO | IXGBE_EEC_DI); 1609 1610 for (i = 0; i < count; i++) { 1611 data = data << 1; 1612 ixgbe_raise_eeprom_clk(hw, &eec); 1613 1614 eec = IXGBE_READ_REG(hw, IXGBE_EEC(hw)); 1615 1616 eec &= ~(IXGBE_EEC_DI); 1617 if (eec & IXGBE_EEC_DO) 1618 data |= 1; 1619 1620 ixgbe_lower_eeprom_clk(hw, &eec); 1621 } 1622 1623 return data; 1624 } 1625 1626 /** 1627 * ixgbe_raise_eeprom_clk - Raises the EEPROM's clock input. 1628 * @hw: pointer to hardware structure 1629 * @eec: EEC register's current value 1630 **/ 1631 static void ixgbe_raise_eeprom_clk(struct ixgbe_hw *hw, u32 *eec) 1632 { 1633 /* 1634 * Raise the clock input to the EEPROM 1635 * (setting the SK bit), then delay 1636 */ 1637 *eec = *eec | IXGBE_EEC_SK; 1638 IXGBE_WRITE_REG(hw, IXGBE_EEC(hw), *eec); 1639 IXGBE_WRITE_FLUSH(hw); 1640 udelay(1); 1641 } 1642 1643 /** 1644 * ixgbe_lower_eeprom_clk - Lowers the EEPROM's clock input. 1645 * @hw: pointer to hardware structure 1646 * @eec: EEC's current value 1647 **/ 1648 static void ixgbe_lower_eeprom_clk(struct ixgbe_hw *hw, u32 *eec) 1649 { 1650 /* 1651 * Lower the clock input to the EEPROM (clearing the SK bit), then 1652 * delay 1653 */ 1654 *eec = *eec & ~IXGBE_EEC_SK; 1655 IXGBE_WRITE_REG(hw, IXGBE_EEC(hw), *eec); 1656 IXGBE_WRITE_FLUSH(hw); 1657 udelay(1); 1658 } 1659 1660 /** 1661 * ixgbe_release_eeprom - Release EEPROM, release semaphores 1662 * @hw: pointer to hardware structure 1663 **/ 1664 static void ixgbe_release_eeprom(struct ixgbe_hw *hw) 1665 { 1666 u32 eec; 1667 1668 eec = IXGBE_READ_REG(hw, IXGBE_EEC(hw)); 1669 1670 eec |= IXGBE_EEC_CS; /* Pull CS high */ 1671 eec &= ~IXGBE_EEC_SK; /* Lower SCK */ 1672 1673 IXGBE_WRITE_REG(hw, IXGBE_EEC(hw), eec); 1674 IXGBE_WRITE_FLUSH(hw); 1675 1676 udelay(1); 1677 1678 /* Stop requesting EEPROM access */ 1679 eec &= ~IXGBE_EEC_REQ; 1680 IXGBE_WRITE_REG(hw, IXGBE_EEC(hw), eec); 1681 1682 hw->mac.ops.release_swfw_sync(hw, IXGBE_GSSR_EEP_SM); 1683 1684 /* 1685 * Delay before attempt to obtain semaphore again to allow FW 1686 * access. semaphore_delay is in ms we need us for usleep_range 1687 */ 1688 usleep_range(hw->eeprom.semaphore_delay * 1000, 1689 hw->eeprom.semaphore_delay * 2000); 1690 } 1691 1692 /** 1693 * ixgbe_calc_eeprom_checksum_generic - Calculates and returns the checksum 1694 * @hw: pointer to hardware structure 1695 **/ 1696 s32 ixgbe_calc_eeprom_checksum_generic(struct ixgbe_hw *hw) 1697 { 1698 u16 i; 1699 u16 j; 1700 u16 checksum = 0; 1701 u16 length = 0; 1702 u16 pointer = 0; 1703 u16 word = 0; 1704 1705 /* Include 0x0-0x3F in the checksum */ 1706 for (i = 0; i < IXGBE_EEPROM_CHECKSUM; i++) { 1707 if (hw->eeprom.ops.read(hw, i, &word)) { 1708 hw_dbg(hw, "EEPROM read failed\n"); 1709 break; 1710 } 1711 checksum += word; 1712 } 1713 1714 /* Include all data from pointers except for the fw pointer */ 1715 for (i = IXGBE_PCIE_ANALOG_PTR; i < IXGBE_FW_PTR; i++) { 1716 if (hw->eeprom.ops.read(hw, i, &pointer)) { 1717 hw_dbg(hw, "EEPROM read failed\n"); 1718 return IXGBE_ERR_EEPROM; 1719 } 1720 1721 /* If the pointer seems invalid */ 1722 if (pointer == 0xFFFF || pointer == 0) 1723 continue; 1724 1725 if (hw->eeprom.ops.read(hw, pointer, &length)) { 1726 hw_dbg(hw, "EEPROM read failed\n"); 1727 return IXGBE_ERR_EEPROM; 1728 } 1729 1730 if (length == 0xFFFF || length == 0) 1731 continue; 1732 1733 for (j = pointer + 1; j <= pointer + length; j++) { 1734 if (hw->eeprom.ops.read(hw, j, &word)) { 1735 hw_dbg(hw, "EEPROM read failed\n"); 1736 return IXGBE_ERR_EEPROM; 1737 } 1738 checksum += word; 1739 } 1740 } 1741 1742 checksum = (u16)IXGBE_EEPROM_SUM - checksum; 1743 1744 return (s32)checksum; 1745 } 1746 1747 /** 1748 * ixgbe_validate_eeprom_checksum_generic - Validate EEPROM checksum 1749 * @hw: pointer to hardware structure 1750 * @checksum_val: calculated checksum 1751 * 1752 * Performs checksum calculation and validates the EEPROM checksum. If the 1753 * caller does not need checksum_val, the value can be NULL. 1754 **/ 1755 s32 ixgbe_validate_eeprom_checksum_generic(struct ixgbe_hw *hw, 1756 u16 *checksum_val) 1757 { 1758 s32 status; 1759 u16 checksum; 1760 u16 read_checksum = 0; 1761 1762 /* 1763 * Read the first word from the EEPROM. If this times out or fails, do 1764 * not continue or we could be in for a very long wait while every 1765 * EEPROM read fails 1766 */ 1767 status = hw->eeprom.ops.read(hw, 0, &checksum); 1768 if (status) { 1769 hw_dbg(hw, "EEPROM read failed\n"); 1770 return status; 1771 } 1772 1773 status = hw->eeprom.ops.calc_checksum(hw); 1774 if (status < 0) 1775 return status; 1776 1777 checksum = (u16)(status & 0xffff); 1778 1779 status = hw->eeprom.ops.read(hw, IXGBE_EEPROM_CHECKSUM, &read_checksum); 1780 if (status) { 1781 hw_dbg(hw, "EEPROM read failed\n"); 1782 return status; 1783 } 1784 1785 /* Verify read checksum from EEPROM is the same as 1786 * calculated checksum 1787 */ 1788 if (read_checksum != checksum) 1789 status = IXGBE_ERR_EEPROM_CHECKSUM; 1790 1791 /* If the user cares, return the calculated checksum */ 1792 if (checksum_val) 1793 *checksum_val = checksum; 1794 1795 return status; 1796 } 1797 1798 /** 1799 * ixgbe_update_eeprom_checksum_generic - Updates the EEPROM checksum 1800 * @hw: pointer to hardware structure 1801 **/ 1802 s32 ixgbe_update_eeprom_checksum_generic(struct ixgbe_hw *hw) 1803 { 1804 s32 status; 1805 u16 checksum; 1806 1807 /* 1808 * Read the first word from the EEPROM. If this times out or fails, do 1809 * not continue or we could be in for a very long wait while every 1810 * EEPROM read fails 1811 */ 1812 status = hw->eeprom.ops.read(hw, 0, &checksum); 1813 if (status) { 1814 hw_dbg(hw, "EEPROM read failed\n"); 1815 return status; 1816 } 1817 1818 status = hw->eeprom.ops.calc_checksum(hw); 1819 if (status < 0) 1820 return status; 1821 1822 checksum = (u16)(status & 0xffff); 1823 1824 status = hw->eeprom.ops.write(hw, IXGBE_EEPROM_CHECKSUM, checksum); 1825 1826 return status; 1827 } 1828 1829 /** 1830 * ixgbe_set_rar_generic - Set Rx address register 1831 * @hw: pointer to hardware structure 1832 * @index: Receive address register to write 1833 * @addr: Address to put into receive address register 1834 * @vmdq: VMDq "set" or "pool" index 1835 * @enable_addr: set flag that address is active 1836 * 1837 * Puts an ethernet address into a receive address register. 1838 **/ 1839 s32 ixgbe_set_rar_generic(struct ixgbe_hw *hw, u32 index, u8 *addr, u32 vmdq, 1840 u32 enable_addr) 1841 { 1842 u32 rar_low, rar_high; 1843 u32 rar_entries = hw->mac.num_rar_entries; 1844 1845 /* Make sure we are using a valid rar index range */ 1846 if (index >= rar_entries) { 1847 hw_dbg(hw, "RAR index %d is out of range.\n", index); 1848 return IXGBE_ERR_INVALID_ARGUMENT; 1849 } 1850 1851 /* setup VMDq pool selection before this RAR gets enabled */ 1852 hw->mac.ops.set_vmdq(hw, index, vmdq); 1853 1854 /* 1855 * HW expects these in little endian so we reverse the byte 1856 * order from network order (big endian) to little endian 1857 */ 1858 rar_low = ((u32)addr[0] | 1859 ((u32)addr[1] << 8) | 1860 ((u32)addr[2] << 16) | 1861 ((u32)addr[3] << 24)); 1862 /* 1863 * Some parts put the VMDq setting in the extra RAH bits, 1864 * so save everything except the lower 16 bits that hold part 1865 * of the address and the address valid bit. 1866 */ 1867 rar_high = IXGBE_READ_REG(hw, IXGBE_RAH(index)); 1868 rar_high &= ~(0x0000FFFF | IXGBE_RAH_AV); 1869 rar_high |= ((u32)addr[4] | ((u32)addr[5] << 8)); 1870 1871 if (enable_addr != 0) 1872 rar_high |= IXGBE_RAH_AV; 1873 1874 IXGBE_WRITE_REG(hw, IXGBE_RAL(index), rar_low); 1875 IXGBE_WRITE_REG(hw, IXGBE_RAH(index), rar_high); 1876 1877 return 0; 1878 } 1879 1880 /** 1881 * ixgbe_clear_rar_generic - Remove Rx address register 1882 * @hw: pointer to hardware structure 1883 * @index: Receive address register to write 1884 * 1885 * Clears an ethernet address from a receive address register. 1886 **/ 1887 s32 ixgbe_clear_rar_generic(struct ixgbe_hw *hw, u32 index) 1888 { 1889 u32 rar_high; 1890 u32 rar_entries = hw->mac.num_rar_entries; 1891 1892 /* Make sure we are using a valid rar index range */ 1893 if (index >= rar_entries) { 1894 hw_dbg(hw, "RAR index %d is out of range.\n", index); 1895 return IXGBE_ERR_INVALID_ARGUMENT; 1896 } 1897 1898 /* 1899 * Some parts put the VMDq setting in the extra RAH bits, 1900 * so save everything except the lower 16 bits that hold part 1901 * of the address and the address valid bit. 1902 */ 1903 rar_high = IXGBE_READ_REG(hw, IXGBE_RAH(index)); 1904 rar_high &= ~(0x0000FFFF | IXGBE_RAH_AV); 1905 1906 IXGBE_WRITE_REG(hw, IXGBE_RAL(index), 0); 1907 IXGBE_WRITE_REG(hw, IXGBE_RAH(index), rar_high); 1908 1909 /* clear VMDq pool/queue selection for this RAR */ 1910 hw->mac.ops.clear_vmdq(hw, index, IXGBE_CLEAR_VMDQ_ALL); 1911 1912 return 0; 1913 } 1914 1915 /** 1916 * ixgbe_init_rx_addrs_generic - Initializes receive address filters. 1917 * @hw: pointer to hardware structure 1918 * 1919 * Places the MAC address in receive address register 0 and clears the rest 1920 * of the receive address registers. Clears the multicast table. Assumes 1921 * the receiver is in reset when the routine is called. 1922 **/ 1923 s32 ixgbe_init_rx_addrs_generic(struct ixgbe_hw *hw) 1924 { 1925 u32 i; 1926 u32 rar_entries = hw->mac.num_rar_entries; 1927 1928 /* 1929 * If the current mac address is valid, assume it is a software override 1930 * to the permanent address. 1931 * Otherwise, use the permanent address from the eeprom. 1932 */ 1933 if (!is_valid_ether_addr(hw->mac.addr)) { 1934 /* Get the MAC address from the RAR0 for later reference */ 1935 hw->mac.ops.get_mac_addr(hw, hw->mac.addr); 1936 1937 hw_dbg(hw, " Keeping Current RAR0 Addr =%pM\n", hw->mac.addr); 1938 } else { 1939 /* Setup the receive address. */ 1940 hw_dbg(hw, "Overriding MAC Address in RAR[0]\n"); 1941 hw_dbg(hw, " New MAC Addr =%pM\n", hw->mac.addr); 1942 1943 hw->mac.ops.set_rar(hw, 0, hw->mac.addr, 0, IXGBE_RAH_AV); 1944 } 1945 1946 /* clear VMDq pool/queue selection for RAR 0 */ 1947 hw->mac.ops.clear_vmdq(hw, 0, IXGBE_CLEAR_VMDQ_ALL); 1948 1949 hw->addr_ctrl.overflow_promisc = 0; 1950 1951 hw->addr_ctrl.rar_used_count = 1; 1952 1953 /* Zero out the other receive addresses. */ 1954 hw_dbg(hw, "Clearing RAR[1-%d]\n", rar_entries - 1); 1955 for (i = 1; i < rar_entries; i++) { 1956 IXGBE_WRITE_REG(hw, IXGBE_RAL(i), 0); 1957 IXGBE_WRITE_REG(hw, IXGBE_RAH(i), 0); 1958 } 1959 1960 /* Clear the MTA */ 1961 hw->addr_ctrl.mta_in_use = 0; 1962 IXGBE_WRITE_REG(hw, IXGBE_MCSTCTRL, hw->mac.mc_filter_type); 1963 1964 hw_dbg(hw, " Clearing MTA\n"); 1965 for (i = 0; i < hw->mac.mcft_size; i++) 1966 IXGBE_WRITE_REG(hw, IXGBE_MTA(i), 0); 1967 1968 if (hw->mac.ops.init_uta_tables) 1969 hw->mac.ops.init_uta_tables(hw); 1970 1971 return 0; 1972 } 1973 1974 /** 1975 * ixgbe_mta_vector - Determines bit-vector in multicast table to set 1976 * @hw: pointer to hardware structure 1977 * @mc_addr: the multicast address 1978 * 1979 * Extracts the 12 bits, from a multicast address, to determine which 1980 * bit-vector to set in the multicast table. The hardware uses 12 bits, from 1981 * incoming rx multicast addresses, to determine the bit-vector to check in 1982 * the MTA. Which of the 4 combination, of 12-bits, the hardware uses is set 1983 * by the MO field of the MCSTCTRL. The MO field is set during initialization 1984 * to mc_filter_type. 1985 **/ 1986 static s32 ixgbe_mta_vector(struct ixgbe_hw *hw, u8 *mc_addr) 1987 { 1988 u32 vector = 0; 1989 1990 switch (hw->mac.mc_filter_type) { 1991 case 0: /* use bits [47:36] of the address */ 1992 vector = ((mc_addr[4] >> 4) | (((u16)mc_addr[5]) << 4)); 1993 break; 1994 case 1: /* use bits [46:35] of the address */ 1995 vector = ((mc_addr[4] >> 3) | (((u16)mc_addr[5]) << 5)); 1996 break; 1997 case 2: /* use bits [45:34] of the address */ 1998 vector = ((mc_addr[4] >> 2) | (((u16)mc_addr[5]) << 6)); 1999 break; 2000 case 3: /* use bits [43:32] of the address */ 2001 vector = ((mc_addr[4]) | (((u16)mc_addr[5]) << 8)); 2002 break; 2003 default: /* Invalid mc_filter_type */ 2004 hw_dbg(hw, "MC filter type param set incorrectly\n"); 2005 break; 2006 } 2007 2008 /* vector can only be 12-bits or boundary will be exceeded */ 2009 vector &= 0xFFF; 2010 return vector; 2011 } 2012 2013 /** 2014 * ixgbe_set_mta - Set bit-vector in multicast table 2015 * @hw: pointer to hardware structure 2016 * @mc_addr: Multicast address 2017 * 2018 * Sets the bit-vector in the multicast table. 2019 **/ 2020 static void ixgbe_set_mta(struct ixgbe_hw *hw, u8 *mc_addr) 2021 { 2022 u32 vector; 2023 u32 vector_bit; 2024 u32 vector_reg; 2025 2026 hw->addr_ctrl.mta_in_use++; 2027 2028 vector = ixgbe_mta_vector(hw, mc_addr); 2029 hw_dbg(hw, " bit-vector = 0x%03X\n", vector); 2030 2031 /* 2032 * The MTA is a register array of 128 32-bit registers. It is treated 2033 * like an array of 4096 bits. We want to set bit 2034 * BitArray[vector_value]. So we figure out what register the bit is 2035 * in, read it, OR in the new bit, then write back the new value. The 2036 * register is determined by the upper 7 bits of the vector value and 2037 * the bit within that register are determined by the lower 5 bits of 2038 * the value. 2039 */ 2040 vector_reg = (vector >> 5) & 0x7F; 2041 vector_bit = vector & 0x1F; 2042 hw->mac.mta_shadow[vector_reg] |= BIT(vector_bit); 2043 } 2044 2045 /** 2046 * ixgbe_update_mc_addr_list_generic - Updates MAC list of multicast addresses 2047 * @hw: pointer to hardware structure 2048 * @netdev: pointer to net device structure 2049 * 2050 * The given list replaces any existing list. Clears the MC addrs from receive 2051 * address registers and the multicast table. Uses unused receive address 2052 * registers for the first multicast addresses, and hashes the rest into the 2053 * multicast table. 2054 **/ 2055 s32 ixgbe_update_mc_addr_list_generic(struct ixgbe_hw *hw, 2056 struct net_device *netdev) 2057 { 2058 struct netdev_hw_addr *ha; 2059 u32 i; 2060 2061 /* 2062 * Set the new number of MC addresses that we are being requested to 2063 * use. 2064 */ 2065 hw->addr_ctrl.num_mc_addrs = netdev_mc_count(netdev); 2066 hw->addr_ctrl.mta_in_use = 0; 2067 2068 /* Clear mta_shadow */ 2069 hw_dbg(hw, " Clearing MTA\n"); 2070 memset(&hw->mac.mta_shadow, 0, sizeof(hw->mac.mta_shadow)); 2071 2072 /* Update mta shadow */ 2073 netdev_for_each_mc_addr(ha, netdev) { 2074 hw_dbg(hw, " Adding the multicast addresses:\n"); 2075 ixgbe_set_mta(hw, ha->addr); 2076 } 2077 2078 /* Enable mta */ 2079 for (i = 0; i < hw->mac.mcft_size; i++) 2080 IXGBE_WRITE_REG_ARRAY(hw, IXGBE_MTA(0), i, 2081 hw->mac.mta_shadow[i]); 2082 2083 if (hw->addr_ctrl.mta_in_use > 0) 2084 IXGBE_WRITE_REG(hw, IXGBE_MCSTCTRL, 2085 IXGBE_MCSTCTRL_MFE | hw->mac.mc_filter_type); 2086 2087 hw_dbg(hw, "ixgbe_update_mc_addr_list_generic Complete\n"); 2088 return 0; 2089 } 2090 2091 /** 2092 * ixgbe_enable_mc_generic - Enable multicast address in RAR 2093 * @hw: pointer to hardware structure 2094 * 2095 * Enables multicast address in RAR and the use of the multicast hash table. 2096 **/ 2097 s32 ixgbe_enable_mc_generic(struct ixgbe_hw *hw) 2098 { 2099 struct ixgbe_addr_filter_info *a = &hw->addr_ctrl; 2100 2101 if (a->mta_in_use > 0) 2102 IXGBE_WRITE_REG(hw, IXGBE_MCSTCTRL, IXGBE_MCSTCTRL_MFE | 2103 hw->mac.mc_filter_type); 2104 2105 return 0; 2106 } 2107 2108 /** 2109 * ixgbe_disable_mc_generic - Disable multicast address in RAR 2110 * @hw: pointer to hardware structure 2111 * 2112 * Disables multicast address in RAR and the use of the multicast hash table. 2113 **/ 2114 s32 ixgbe_disable_mc_generic(struct ixgbe_hw *hw) 2115 { 2116 struct ixgbe_addr_filter_info *a = &hw->addr_ctrl; 2117 2118 if (a->mta_in_use > 0) 2119 IXGBE_WRITE_REG(hw, IXGBE_MCSTCTRL, hw->mac.mc_filter_type); 2120 2121 return 0; 2122 } 2123 2124 /** 2125 * ixgbe_fc_enable_generic - Enable flow control 2126 * @hw: pointer to hardware structure 2127 * 2128 * Enable flow control according to the current settings. 2129 **/ 2130 s32 ixgbe_fc_enable_generic(struct ixgbe_hw *hw) 2131 { 2132 u32 mflcn_reg, fccfg_reg; 2133 u32 reg; 2134 u32 fcrtl, fcrth; 2135 int i; 2136 2137 /* Validate the water mark configuration. */ 2138 if (!hw->fc.pause_time) 2139 return IXGBE_ERR_INVALID_LINK_SETTINGS; 2140 2141 /* Low water mark of zero causes XOFF floods */ 2142 for (i = 0; i < MAX_TRAFFIC_CLASS; i++) { 2143 if ((hw->fc.current_mode & ixgbe_fc_tx_pause) && 2144 hw->fc.high_water[i]) { 2145 if (!hw->fc.low_water[i] || 2146 hw->fc.low_water[i] >= hw->fc.high_water[i]) { 2147 hw_dbg(hw, "Invalid water mark configuration\n"); 2148 return IXGBE_ERR_INVALID_LINK_SETTINGS; 2149 } 2150 } 2151 } 2152 2153 /* Negotiate the fc mode to use */ 2154 hw->mac.ops.fc_autoneg(hw); 2155 2156 /* Disable any previous flow control settings */ 2157 mflcn_reg = IXGBE_READ_REG(hw, IXGBE_MFLCN); 2158 mflcn_reg &= ~(IXGBE_MFLCN_RPFCE_MASK | IXGBE_MFLCN_RFCE); 2159 2160 fccfg_reg = IXGBE_READ_REG(hw, IXGBE_FCCFG); 2161 fccfg_reg &= ~(IXGBE_FCCFG_TFCE_802_3X | IXGBE_FCCFG_TFCE_PRIORITY); 2162 2163 /* 2164 * The possible values of fc.current_mode are: 2165 * 0: Flow control is completely disabled 2166 * 1: Rx flow control is enabled (we can receive pause frames, 2167 * but not send pause frames). 2168 * 2: Tx flow control is enabled (we can send pause frames but 2169 * we do not support receiving pause frames). 2170 * 3: Both Rx and Tx flow control (symmetric) are enabled. 2171 * other: Invalid. 2172 */ 2173 switch (hw->fc.current_mode) { 2174 case ixgbe_fc_none: 2175 /* 2176 * Flow control is disabled by software override or autoneg. 2177 * The code below will actually disable it in the HW. 2178 */ 2179 break; 2180 case ixgbe_fc_rx_pause: 2181 /* 2182 * Rx Flow control is enabled and Tx Flow control is 2183 * disabled by software override. Since there really 2184 * isn't a way to advertise that we are capable of RX 2185 * Pause ONLY, we will advertise that we support both 2186 * symmetric and asymmetric Rx PAUSE. Later, we will 2187 * disable the adapter's ability to send PAUSE frames. 2188 */ 2189 mflcn_reg |= IXGBE_MFLCN_RFCE; 2190 break; 2191 case ixgbe_fc_tx_pause: 2192 /* 2193 * Tx Flow control is enabled, and Rx Flow control is 2194 * disabled by software override. 2195 */ 2196 fccfg_reg |= IXGBE_FCCFG_TFCE_802_3X; 2197 break; 2198 case ixgbe_fc_full: 2199 /* Flow control (both Rx and Tx) is enabled by SW override. */ 2200 mflcn_reg |= IXGBE_MFLCN_RFCE; 2201 fccfg_reg |= IXGBE_FCCFG_TFCE_802_3X; 2202 break; 2203 default: 2204 hw_dbg(hw, "Flow control param set incorrectly\n"); 2205 return IXGBE_ERR_CONFIG; 2206 } 2207 2208 /* Set 802.3x based flow control settings. */ 2209 mflcn_reg |= IXGBE_MFLCN_DPF; 2210 IXGBE_WRITE_REG(hw, IXGBE_MFLCN, mflcn_reg); 2211 IXGBE_WRITE_REG(hw, IXGBE_FCCFG, fccfg_reg); 2212 2213 /* Set up and enable Rx high/low water mark thresholds, enable XON. */ 2214 for (i = 0; i < MAX_TRAFFIC_CLASS; i++) { 2215 if ((hw->fc.current_mode & ixgbe_fc_tx_pause) && 2216 hw->fc.high_water[i]) { 2217 fcrtl = (hw->fc.low_water[i] << 10) | IXGBE_FCRTL_XONE; 2218 IXGBE_WRITE_REG(hw, IXGBE_FCRTL_82599(i), fcrtl); 2219 fcrth = (hw->fc.high_water[i] << 10) | IXGBE_FCRTH_FCEN; 2220 } else { 2221 IXGBE_WRITE_REG(hw, IXGBE_FCRTL_82599(i), 0); 2222 /* 2223 * In order to prevent Tx hangs when the internal Tx 2224 * switch is enabled we must set the high water mark 2225 * to the Rx packet buffer size - 24KB. This allows 2226 * the Tx switch to function even under heavy Rx 2227 * workloads. 2228 */ 2229 fcrth = IXGBE_READ_REG(hw, IXGBE_RXPBSIZE(i)) - 24576; 2230 } 2231 2232 IXGBE_WRITE_REG(hw, IXGBE_FCRTH_82599(i), fcrth); 2233 } 2234 2235 /* Configure pause time (2 TCs per register) */ 2236 reg = hw->fc.pause_time * 0x00010001; 2237 for (i = 0; i < (MAX_TRAFFIC_CLASS / 2); i++) 2238 IXGBE_WRITE_REG(hw, IXGBE_FCTTV(i), reg); 2239 2240 IXGBE_WRITE_REG(hw, IXGBE_FCRTV, hw->fc.pause_time / 2); 2241 2242 return 0; 2243 } 2244 2245 /** 2246 * ixgbe_negotiate_fc - Negotiate flow control 2247 * @hw: pointer to hardware structure 2248 * @adv_reg: flow control advertised settings 2249 * @lp_reg: link partner's flow control settings 2250 * @adv_sym: symmetric pause bit in advertisement 2251 * @adv_asm: asymmetric pause bit in advertisement 2252 * @lp_sym: symmetric pause bit in link partner advertisement 2253 * @lp_asm: asymmetric pause bit in link partner advertisement 2254 * 2255 * Find the intersection between advertised settings and link partner's 2256 * advertised settings 2257 **/ 2258 s32 ixgbe_negotiate_fc(struct ixgbe_hw *hw, u32 adv_reg, u32 lp_reg, 2259 u32 adv_sym, u32 adv_asm, u32 lp_sym, u32 lp_asm) 2260 { 2261 if ((!(adv_reg)) || (!(lp_reg))) 2262 return IXGBE_ERR_FC_NOT_NEGOTIATED; 2263 2264 if ((adv_reg & adv_sym) && (lp_reg & lp_sym)) { 2265 /* 2266 * Now we need to check if the user selected Rx ONLY 2267 * of pause frames. In this case, we had to advertise 2268 * FULL flow control because we could not advertise RX 2269 * ONLY. Hence, we must now check to see if we need to 2270 * turn OFF the TRANSMISSION of PAUSE frames. 2271 */ 2272 if (hw->fc.requested_mode == ixgbe_fc_full) { 2273 hw->fc.current_mode = ixgbe_fc_full; 2274 hw_dbg(hw, "Flow Control = FULL.\n"); 2275 } else { 2276 hw->fc.current_mode = ixgbe_fc_rx_pause; 2277 hw_dbg(hw, "Flow Control=RX PAUSE frames only\n"); 2278 } 2279 } else if (!(adv_reg & adv_sym) && (adv_reg & adv_asm) && 2280 (lp_reg & lp_sym) && (lp_reg & lp_asm)) { 2281 hw->fc.current_mode = ixgbe_fc_tx_pause; 2282 hw_dbg(hw, "Flow Control = TX PAUSE frames only.\n"); 2283 } else if ((adv_reg & adv_sym) && (adv_reg & adv_asm) && 2284 !(lp_reg & lp_sym) && (lp_reg & lp_asm)) { 2285 hw->fc.current_mode = ixgbe_fc_rx_pause; 2286 hw_dbg(hw, "Flow Control = RX PAUSE frames only.\n"); 2287 } else { 2288 hw->fc.current_mode = ixgbe_fc_none; 2289 hw_dbg(hw, "Flow Control = NONE.\n"); 2290 } 2291 return 0; 2292 } 2293 2294 /** 2295 * ixgbe_fc_autoneg_fiber - Enable flow control on 1 gig fiber 2296 * @hw: pointer to hardware structure 2297 * 2298 * Enable flow control according on 1 gig fiber. 2299 **/ 2300 static s32 ixgbe_fc_autoneg_fiber(struct ixgbe_hw *hw) 2301 { 2302 u32 pcs_anadv_reg, pcs_lpab_reg, linkstat; 2303 s32 ret_val; 2304 2305 /* 2306 * On multispeed fiber at 1g, bail out if 2307 * - link is up but AN did not complete, or if 2308 * - link is up and AN completed but timed out 2309 */ 2310 2311 linkstat = IXGBE_READ_REG(hw, IXGBE_PCS1GLSTA); 2312 if ((!!(linkstat & IXGBE_PCS1GLSTA_AN_COMPLETE) == 0) || 2313 (!!(linkstat & IXGBE_PCS1GLSTA_AN_TIMED_OUT) == 1)) 2314 return IXGBE_ERR_FC_NOT_NEGOTIATED; 2315 2316 pcs_anadv_reg = IXGBE_READ_REG(hw, IXGBE_PCS1GANA); 2317 pcs_lpab_reg = IXGBE_READ_REG(hw, IXGBE_PCS1GANLP); 2318 2319 ret_val = ixgbe_negotiate_fc(hw, pcs_anadv_reg, 2320 pcs_lpab_reg, IXGBE_PCS1GANA_SYM_PAUSE, 2321 IXGBE_PCS1GANA_ASM_PAUSE, 2322 IXGBE_PCS1GANA_SYM_PAUSE, 2323 IXGBE_PCS1GANA_ASM_PAUSE); 2324 2325 return ret_val; 2326 } 2327 2328 /** 2329 * ixgbe_fc_autoneg_backplane - Enable flow control IEEE clause 37 2330 * @hw: pointer to hardware structure 2331 * 2332 * Enable flow control according to IEEE clause 37. 2333 **/ 2334 static s32 ixgbe_fc_autoneg_backplane(struct ixgbe_hw *hw) 2335 { 2336 u32 links2, anlp1_reg, autoc_reg, links; 2337 s32 ret_val; 2338 2339 /* 2340 * On backplane, bail out if 2341 * - backplane autoneg was not completed, or if 2342 * - we are 82599 and link partner is not AN enabled 2343 */ 2344 links = IXGBE_READ_REG(hw, IXGBE_LINKS); 2345 if ((links & IXGBE_LINKS_KX_AN_COMP) == 0) 2346 return IXGBE_ERR_FC_NOT_NEGOTIATED; 2347 2348 if (hw->mac.type == ixgbe_mac_82599EB) { 2349 links2 = IXGBE_READ_REG(hw, IXGBE_LINKS2); 2350 if ((links2 & IXGBE_LINKS2_AN_SUPPORTED) == 0) 2351 return IXGBE_ERR_FC_NOT_NEGOTIATED; 2352 } 2353 /* 2354 * Read the 10g AN autoc and LP ability registers and resolve 2355 * local flow control settings accordingly 2356 */ 2357 autoc_reg = IXGBE_READ_REG(hw, IXGBE_AUTOC); 2358 anlp1_reg = IXGBE_READ_REG(hw, IXGBE_ANLP1); 2359 2360 ret_val = ixgbe_negotiate_fc(hw, autoc_reg, 2361 anlp1_reg, IXGBE_AUTOC_SYM_PAUSE, IXGBE_AUTOC_ASM_PAUSE, 2362 IXGBE_ANLP1_SYM_PAUSE, IXGBE_ANLP1_ASM_PAUSE); 2363 2364 return ret_val; 2365 } 2366 2367 /** 2368 * ixgbe_fc_autoneg_copper - Enable flow control IEEE clause 37 2369 * @hw: pointer to hardware structure 2370 * 2371 * Enable flow control according to IEEE clause 37. 2372 **/ 2373 static s32 ixgbe_fc_autoneg_copper(struct ixgbe_hw *hw) 2374 { 2375 u16 technology_ability_reg = 0; 2376 u16 lp_technology_ability_reg = 0; 2377 2378 hw->phy.ops.read_reg(hw, MDIO_AN_ADVERTISE, 2379 MDIO_MMD_AN, 2380 &technology_ability_reg); 2381 hw->phy.ops.read_reg(hw, MDIO_AN_LPA, 2382 MDIO_MMD_AN, 2383 &lp_technology_ability_reg); 2384 2385 return ixgbe_negotiate_fc(hw, (u32)technology_ability_reg, 2386 (u32)lp_technology_ability_reg, 2387 IXGBE_TAF_SYM_PAUSE, IXGBE_TAF_ASM_PAUSE, 2388 IXGBE_TAF_SYM_PAUSE, IXGBE_TAF_ASM_PAUSE); 2389 } 2390 2391 /** 2392 * ixgbe_fc_autoneg - Configure flow control 2393 * @hw: pointer to hardware structure 2394 * 2395 * Compares our advertised flow control capabilities to those advertised by 2396 * our link partner, and determines the proper flow control mode to use. 2397 **/ 2398 void ixgbe_fc_autoneg(struct ixgbe_hw *hw) 2399 { 2400 s32 ret_val = IXGBE_ERR_FC_NOT_NEGOTIATED; 2401 ixgbe_link_speed speed; 2402 bool link_up; 2403 2404 /* 2405 * AN should have completed when the cable was plugged in. 2406 * Look for reasons to bail out. Bail out if: 2407 * - FC autoneg is disabled, or if 2408 * - link is not up. 2409 * 2410 * Since we're being called from an LSC, link is already known to be up. 2411 * So use link_up_wait_to_complete=false. 2412 */ 2413 if (hw->fc.disable_fc_autoneg) 2414 goto out; 2415 2416 hw->mac.ops.check_link(hw, &speed, &link_up, false); 2417 if (!link_up) 2418 goto out; 2419 2420 switch (hw->phy.media_type) { 2421 /* Autoneg flow control on fiber adapters */ 2422 case ixgbe_media_type_fiber: 2423 if (speed == IXGBE_LINK_SPEED_1GB_FULL) 2424 ret_val = ixgbe_fc_autoneg_fiber(hw); 2425 break; 2426 2427 /* Autoneg flow control on backplane adapters */ 2428 case ixgbe_media_type_backplane: 2429 ret_val = ixgbe_fc_autoneg_backplane(hw); 2430 break; 2431 2432 /* Autoneg flow control on copper adapters */ 2433 case ixgbe_media_type_copper: 2434 if (ixgbe_device_supports_autoneg_fc(hw)) 2435 ret_val = ixgbe_fc_autoneg_copper(hw); 2436 break; 2437 2438 default: 2439 break; 2440 } 2441 2442 out: 2443 if (ret_val == 0) { 2444 hw->fc.fc_was_autonegged = true; 2445 } else { 2446 hw->fc.fc_was_autonegged = false; 2447 hw->fc.current_mode = hw->fc.requested_mode; 2448 } 2449 } 2450 2451 /** 2452 * ixgbe_pcie_timeout_poll - Return number of times to poll for completion 2453 * @hw: pointer to hardware structure 2454 * 2455 * System-wide timeout range is encoded in PCIe Device Control2 register. 2456 * 2457 * Add 10% to specified maximum and return the number of times to poll for 2458 * completion timeout, in units of 100 microsec. Never return less than 2459 * 800 = 80 millisec. 2460 **/ 2461 static u32 ixgbe_pcie_timeout_poll(struct ixgbe_hw *hw) 2462 { 2463 s16 devctl2; 2464 u32 pollcnt; 2465 2466 devctl2 = ixgbe_read_pci_cfg_word(hw, IXGBE_PCI_DEVICE_CONTROL2); 2467 devctl2 &= IXGBE_PCIDEVCTRL2_TIMEO_MASK; 2468 2469 switch (devctl2) { 2470 case IXGBE_PCIDEVCTRL2_65_130ms: 2471 pollcnt = 1300; /* 130 millisec */ 2472 break; 2473 case IXGBE_PCIDEVCTRL2_260_520ms: 2474 pollcnt = 5200; /* 520 millisec */ 2475 break; 2476 case IXGBE_PCIDEVCTRL2_1_2s: 2477 pollcnt = 20000; /* 2 sec */ 2478 break; 2479 case IXGBE_PCIDEVCTRL2_4_8s: 2480 pollcnt = 80000; /* 8 sec */ 2481 break; 2482 case IXGBE_PCIDEVCTRL2_17_34s: 2483 pollcnt = 34000; /* 34 sec */ 2484 break; 2485 case IXGBE_PCIDEVCTRL2_50_100us: /* 100 microsecs */ 2486 case IXGBE_PCIDEVCTRL2_1_2ms: /* 2 millisecs */ 2487 case IXGBE_PCIDEVCTRL2_16_32ms: /* 32 millisec */ 2488 case IXGBE_PCIDEVCTRL2_16_32ms_def: /* 32 millisec default */ 2489 default: 2490 pollcnt = 800; /* 80 millisec minimum */ 2491 break; 2492 } 2493 2494 /* add 10% to spec maximum */ 2495 return (pollcnt * 11) / 10; 2496 } 2497 2498 /** 2499 * ixgbe_disable_pcie_master - Disable PCI-express master access 2500 * @hw: pointer to hardware structure 2501 * 2502 * Disables PCI-Express master access and verifies there are no pending 2503 * requests. IXGBE_ERR_MASTER_REQUESTS_PENDING is returned if master disable 2504 * bit hasn't caused the master requests to be disabled, else 0 2505 * is returned signifying master requests disabled. 2506 **/ 2507 static s32 ixgbe_disable_pcie_master(struct ixgbe_hw *hw) 2508 { 2509 u32 i, poll; 2510 u16 value; 2511 2512 /* Always set this bit to ensure any future transactions are blocked */ 2513 IXGBE_WRITE_REG(hw, IXGBE_CTRL, IXGBE_CTRL_GIO_DIS); 2514 2515 /* Poll for bit to read as set */ 2516 for (i = 0; i < IXGBE_PCI_MASTER_DISABLE_TIMEOUT; i++) { 2517 if (IXGBE_READ_REG(hw, IXGBE_CTRL) & IXGBE_CTRL_GIO_DIS) 2518 break; 2519 usleep_range(100, 120); 2520 } 2521 if (i >= IXGBE_PCI_MASTER_DISABLE_TIMEOUT) { 2522 hw_dbg(hw, "GIO disable did not set - requesting resets\n"); 2523 goto gio_disable_fail; 2524 } 2525 2526 /* Exit if master requests are blocked */ 2527 if (!(IXGBE_READ_REG(hw, IXGBE_STATUS) & IXGBE_STATUS_GIO) || 2528 ixgbe_removed(hw->hw_addr)) 2529 return 0; 2530 2531 /* Poll for master request bit to clear */ 2532 for (i = 0; i < IXGBE_PCI_MASTER_DISABLE_TIMEOUT; i++) { 2533 udelay(100); 2534 if (!(IXGBE_READ_REG(hw, IXGBE_STATUS) & IXGBE_STATUS_GIO)) 2535 return 0; 2536 } 2537 2538 /* 2539 * Two consecutive resets are required via CTRL.RST per datasheet 2540 * 5.2.5.3.2 Master Disable. We set a flag to inform the reset routine 2541 * of this need. The first reset prevents new master requests from 2542 * being issued by our device. We then must wait 1usec or more for any 2543 * remaining completions from the PCIe bus to trickle in, and then reset 2544 * again to clear out any effects they may have had on our device. 2545 */ 2546 hw_dbg(hw, "GIO Master Disable bit didn't clear - requesting resets\n"); 2547 gio_disable_fail: 2548 hw->mac.flags |= IXGBE_FLAGS_DOUBLE_RESET_REQUIRED; 2549 2550 if (hw->mac.type >= ixgbe_mac_X550) 2551 return 0; 2552 2553 /* 2554 * Before proceeding, make sure that the PCIe block does not have 2555 * transactions pending. 2556 */ 2557 poll = ixgbe_pcie_timeout_poll(hw); 2558 for (i = 0; i < poll; i++) { 2559 udelay(100); 2560 value = ixgbe_read_pci_cfg_word(hw, IXGBE_PCI_DEVICE_STATUS); 2561 if (ixgbe_removed(hw->hw_addr)) 2562 return 0; 2563 if (!(value & IXGBE_PCI_DEVICE_STATUS_TRANSACTION_PENDING)) 2564 return 0; 2565 } 2566 2567 hw_dbg(hw, "PCIe transaction pending bit also did not clear.\n"); 2568 return IXGBE_ERR_MASTER_REQUESTS_PENDING; 2569 } 2570 2571 /** 2572 * ixgbe_acquire_swfw_sync - Acquire SWFW semaphore 2573 * @hw: pointer to hardware structure 2574 * @mask: Mask to specify which semaphore to acquire 2575 * 2576 * Acquires the SWFW semaphore through the GSSR register for the specified 2577 * function (CSR, PHY0, PHY1, EEPROM, Flash) 2578 **/ 2579 s32 ixgbe_acquire_swfw_sync(struct ixgbe_hw *hw, u32 mask) 2580 { 2581 u32 gssr = 0; 2582 u32 swmask = mask; 2583 u32 fwmask = mask << 5; 2584 u32 timeout = 200; 2585 u32 i; 2586 2587 for (i = 0; i < timeout; i++) { 2588 /* 2589 * SW NVM semaphore bit is used for access to all 2590 * SW_FW_SYNC bits (not just NVM) 2591 */ 2592 if (ixgbe_get_eeprom_semaphore(hw)) 2593 return IXGBE_ERR_SWFW_SYNC; 2594 2595 gssr = IXGBE_READ_REG(hw, IXGBE_GSSR); 2596 if (!(gssr & (fwmask | swmask))) { 2597 gssr |= swmask; 2598 IXGBE_WRITE_REG(hw, IXGBE_GSSR, gssr); 2599 ixgbe_release_eeprom_semaphore(hw); 2600 return 0; 2601 } else { 2602 /* Resource is currently in use by FW or SW */ 2603 ixgbe_release_eeprom_semaphore(hw); 2604 usleep_range(5000, 10000); 2605 } 2606 } 2607 2608 /* If time expired clear the bits holding the lock and retry */ 2609 if (gssr & (fwmask | swmask)) 2610 ixgbe_release_swfw_sync(hw, gssr & (fwmask | swmask)); 2611 2612 usleep_range(5000, 10000); 2613 return IXGBE_ERR_SWFW_SYNC; 2614 } 2615 2616 /** 2617 * ixgbe_release_swfw_sync - Release SWFW semaphore 2618 * @hw: pointer to hardware structure 2619 * @mask: Mask to specify which semaphore to release 2620 * 2621 * Releases the SWFW semaphore through the GSSR register for the specified 2622 * function (CSR, PHY0, PHY1, EEPROM, Flash) 2623 **/ 2624 void ixgbe_release_swfw_sync(struct ixgbe_hw *hw, u32 mask) 2625 { 2626 u32 gssr; 2627 u32 swmask = mask; 2628 2629 ixgbe_get_eeprom_semaphore(hw); 2630 2631 gssr = IXGBE_READ_REG(hw, IXGBE_GSSR); 2632 gssr &= ~swmask; 2633 IXGBE_WRITE_REG(hw, IXGBE_GSSR, gssr); 2634 2635 ixgbe_release_eeprom_semaphore(hw); 2636 } 2637 2638 /** 2639 * prot_autoc_read_generic - Hides MAC differences needed for AUTOC read 2640 * @hw: pointer to hardware structure 2641 * @reg_val: Value we read from AUTOC 2642 * @locked: bool to indicate whether the SW/FW lock should be taken. Never 2643 * true in this the generic case. 2644 * 2645 * The default case requires no protection so just to the register read. 2646 **/ 2647 s32 prot_autoc_read_generic(struct ixgbe_hw *hw, bool *locked, u32 *reg_val) 2648 { 2649 *locked = false; 2650 *reg_val = IXGBE_READ_REG(hw, IXGBE_AUTOC); 2651 return 0; 2652 } 2653 2654 /** 2655 * prot_autoc_write_generic - Hides MAC differences needed for AUTOC write 2656 * @hw: pointer to hardware structure 2657 * @reg_val: value to write to AUTOC 2658 * @locked: bool to indicate whether the SW/FW lock was already taken by 2659 * previous read. 2660 **/ 2661 s32 prot_autoc_write_generic(struct ixgbe_hw *hw, u32 reg_val, bool locked) 2662 { 2663 IXGBE_WRITE_REG(hw, IXGBE_AUTOC, reg_val); 2664 return 0; 2665 } 2666 2667 /** 2668 * ixgbe_disable_rx_buff_generic - Stops the receive data path 2669 * @hw: pointer to hardware structure 2670 * 2671 * Stops the receive data path and waits for the HW to internally 2672 * empty the Rx security block. 2673 **/ 2674 s32 ixgbe_disable_rx_buff_generic(struct ixgbe_hw *hw) 2675 { 2676 #define IXGBE_MAX_SECRX_POLL 40 2677 int i; 2678 int secrxreg; 2679 2680 secrxreg = IXGBE_READ_REG(hw, IXGBE_SECRXCTRL); 2681 secrxreg |= IXGBE_SECRXCTRL_RX_DIS; 2682 IXGBE_WRITE_REG(hw, IXGBE_SECRXCTRL, secrxreg); 2683 for (i = 0; i < IXGBE_MAX_SECRX_POLL; i++) { 2684 secrxreg = IXGBE_READ_REG(hw, IXGBE_SECRXSTAT); 2685 if (secrxreg & IXGBE_SECRXSTAT_SECRX_RDY) 2686 break; 2687 else 2688 /* Use interrupt-safe sleep just in case */ 2689 udelay(1000); 2690 } 2691 2692 /* For informational purposes only */ 2693 if (i >= IXGBE_MAX_SECRX_POLL) 2694 hw_dbg(hw, "Rx unit being enabled before security path fully disabled. Continuing with init.\n"); 2695 2696 return 0; 2697 2698 } 2699 2700 /** 2701 * ixgbe_enable_rx_buff - Enables the receive data path 2702 * @hw: pointer to hardware structure 2703 * 2704 * Enables the receive data path 2705 **/ 2706 s32 ixgbe_enable_rx_buff_generic(struct ixgbe_hw *hw) 2707 { 2708 u32 secrxreg; 2709 2710 secrxreg = IXGBE_READ_REG(hw, IXGBE_SECRXCTRL); 2711 secrxreg &= ~IXGBE_SECRXCTRL_RX_DIS; 2712 IXGBE_WRITE_REG(hw, IXGBE_SECRXCTRL, secrxreg); 2713 IXGBE_WRITE_FLUSH(hw); 2714 2715 return 0; 2716 } 2717 2718 /** 2719 * ixgbe_enable_rx_dma_generic - Enable the Rx DMA unit 2720 * @hw: pointer to hardware structure 2721 * @regval: register value to write to RXCTRL 2722 * 2723 * Enables the Rx DMA unit 2724 **/ 2725 s32 ixgbe_enable_rx_dma_generic(struct ixgbe_hw *hw, u32 regval) 2726 { 2727 if (regval & IXGBE_RXCTRL_RXEN) 2728 hw->mac.ops.enable_rx(hw); 2729 else 2730 hw->mac.ops.disable_rx(hw); 2731 2732 return 0; 2733 } 2734 2735 /** 2736 * ixgbe_blink_led_start_generic - Blink LED based on index. 2737 * @hw: pointer to hardware structure 2738 * @index: led number to blink 2739 **/ 2740 s32 ixgbe_blink_led_start_generic(struct ixgbe_hw *hw, u32 index) 2741 { 2742 ixgbe_link_speed speed = 0; 2743 bool link_up = false; 2744 u32 autoc_reg = IXGBE_READ_REG(hw, IXGBE_AUTOC); 2745 u32 led_reg = IXGBE_READ_REG(hw, IXGBE_LEDCTL); 2746 bool locked = false; 2747 s32 ret_val; 2748 2749 if (index > 3) 2750 return IXGBE_ERR_PARAM; 2751 2752 /* 2753 * Link must be up to auto-blink the LEDs; 2754 * Force it if link is down. 2755 */ 2756 hw->mac.ops.check_link(hw, &speed, &link_up, false); 2757 2758 if (!link_up) { 2759 ret_val = hw->mac.ops.prot_autoc_read(hw, &locked, &autoc_reg); 2760 if (ret_val) 2761 return ret_val; 2762 2763 autoc_reg |= IXGBE_AUTOC_AN_RESTART; 2764 autoc_reg |= IXGBE_AUTOC_FLU; 2765 2766 ret_val = hw->mac.ops.prot_autoc_write(hw, autoc_reg, locked); 2767 if (ret_val) 2768 return ret_val; 2769 2770 IXGBE_WRITE_FLUSH(hw); 2771 2772 usleep_range(10000, 20000); 2773 } 2774 2775 led_reg &= ~IXGBE_LED_MODE_MASK(index); 2776 led_reg |= IXGBE_LED_BLINK(index); 2777 IXGBE_WRITE_REG(hw, IXGBE_LEDCTL, led_reg); 2778 IXGBE_WRITE_FLUSH(hw); 2779 2780 return 0; 2781 } 2782 2783 /** 2784 * ixgbe_blink_led_stop_generic - Stop blinking LED based on index. 2785 * @hw: pointer to hardware structure 2786 * @index: led number to stop blinking 2787 **/ 2788 s32 ixgbe_blink_led_stop_generic(struct ixgbe_hw *hw, u32 index) 2789 { 2790 u32 autoc_reg = 0; 2791 u32 led_reg = IXGBE_READ_REG(hw, IXGBE_LEDCTL); 2792 bool locked = false; 2793 s32 ret_val; 2794 2795 if (index > 3) 2796 return IXGBE_ERR_PARAM; 2797 2798 ret_val = hw->mac.ops.prot_autoc_read(hw, &locked, &autoc_reg); 2799 if (ret_val) 2800 return ret_val; 2801 2802 autoc_reg &= ~IXGBE_AUTOC_FLU; 2803 autoc_reg |= IXGBE_AUTOC_AN_RESTART; 2804 2805 ret_val = hw->mac.ops.prot_autoc_write(hw, autoc_reg, locked); 2806 if (ret_val) 2807 return ret_val; 2808 2809 led_reg &= ~IXGBE_LED_MODE_MASK(index); 2810 led_reg &= ~IXGBE_LED_BLINK(index); 2811 led_reg |= IXGBE_LED_LINK_ACTIVE << IXGBE_LED_MODE_SHIFT(index); 2812 IXGBE_WRITE_REG(hw, IXGBE_LEDCTL, led_reg); 2813 IXGBE_WRITE_FLUSH(hw); 2814 2815 return 0; 2816 } 2817 2818 /** 2819 * ixgbe_get_san_mac_addr_offset - Get SAN MAC address offset from the EEPROM 2820 * @hw: pointer to hardware structure 2821 * @san_mac_offset: SAN MAC address offset 2822 * 2823 * This function will read the EEPROM location for the SAN MAC address 2824 * pointer, and returns the value at that location. This is used in both 2825 * get and set mac_addr routines. 2826 **/ 2827 static s32 ixgbe_get_san_mac_addr_offset(struct ixgbe_hw *hw, 2828 u16 *san_mac_offset) 2829 { 2830 s32 ret_val; 2831 2832 /* 2833 * First read the EEPROM pointer to see if the MAC addresses are 2834 * available. 2835 */ 2836 ret_val = hw->eeprom.ops.read(hw, IXGBE_SAN_MAC_ADDR_PTR, 2837 san_mac_offset); 2838 if (ret_val) 2839 hw_err(hw, "eeprom read at offset %d failed\n", 2840 IXGBE_SAN_MAC_ADDR_PTR); 2841 2842 return ret_val; 2843 } 2844 2845 /** 2846 * ixgbe_get_san_mac_addr_generic - SAN MAC address retrieval from the EEPROM 2847 * @hw: pointer to hardware structure 2848 * @san_mac_addr: SAN MAC address 2849 * 2850 * Reads the SAN MAC address from the EEPROM, if it's available. This is 2851 * per-port, so set_lan_id() must be called before reading the addresses. 2852 * set_lan_id() is called by identify_sfp(), but this cannot be relied 2853 * upon for non-SFP connections, so we must call it here. 2854 **/ 2855 s32 ixgbe_get_san_mac_addr_generic(struct ixgbe_hw *hw, u8 *san_mac_addr) 2856 { 2857 u16 san_mac_data, san_mac_offset; 2858 u8 i; 2859 s32 ret_val; 2860 2861 /* 2862 * First read the EEPROM pointer to see if the MAC addresses are 2863 * available. If they're not, no point in calling set_lan_id() here. 2864 */ 2865 ret_val = ixgbe_get_san_mac_addr_offset(hw, &san_mac_offset); 2866 if (ret_val || san_mac_offset == 0 || san_mac_offset == 0xFFFF) 2867 2868 goto san_mac_addr_clr; 2869 2870 /* make sure we know which port we need to program */ 2871 hw->mac.ops.set_lan_id(hw); 2872 /* apply the port offset to the address offset */ 2873 (hw->bus.func) ? (san_mac_offset += IXGBE_SAN_MAC_ADDR_PORT1_OFFSET) : 2874 (san_mac_offset += IXGBE_SAN_MAC_ADDR_PORT0_OFFSET); 2875 for (i = 0; i < 3; i++) { 2876 ret_val = hw->eeprom.ops.read(hw, san_mac_offset, 2877 &san_mac_data); 2878 if (ret_val) { 2879 hw_err(hw, "eeprom read at offset %d failed\n", 2880 san_mac_offset); 2881 goto san_mac_addr_clr; 2882 } 2883 san_mac_addr[i * 2] = (u8)(san_mac_data); 2884 san_mac_addr[i * 2 + 1] = (u8)(san_mac_data >> 8); 2885 san_mac_offset++; 2886 } 2887 return 0; 2888 2889 san_mac_addr_clr: 2890 /* No addresses available in this EEPROM. It's not necessarily an 2891 * error though, so just wipe the local address and return. 2892 */ 2893 for (i = 0; i < 6; i++) 2894 san_mac_addr[i] = 0xFF; 2895 return ret_val; 2896 } 2897 2898 /** 2899 * ixgbe_get_pcie_msix_count_generic - Gets MSI-X vector count 2900 * @hw: pointer to hardware structure 2901 * 2902 * Read PCIe configuration space, and get the MSI-X vector count from 2903 * the capabilities table. 2904 **/ 2905 u16 ixgbe_get_pcie_msix_count_generic(struct ixgbe_hw *hw) 2906 { 2907 u16 msix_count; 2908 u16 max_msix_count; 2909 u16 pcie_offset; 2910 2911 switch (hw->mac.type) { 2912 case ixgbe_mac_82598EB: 2913 pcie_offset = IXGBE_PCIE_MSIX_82598_CAPS; 2914 max_msix_count = IXGBE_MAX_MSIX_VECTORS_82598; 2915 break; 2916 case ixgbe_mac_82599EB: 2917 case ixgbe_mac_X540: 2918 case ixgbe_mac_X550: 2919 case ixgbe_mac_X550EM_x: 2920 case ixgbe_mac_x550em_a: 2921 pcie_offset = IXGBE_PCIE_MSIX_82599_CAPS; 2922 max_msix_count = IXGBE_MAX_MSIX_VECTORS_82599; 2923 break; 2924 default: 2925 return 1; 2926 } 2927 2928 msix_count = ixgbe_read_pci_cfg_word(hw, pcie_offset); 2929 if (ixgbe_removed(hw->hw_addr)) 2930 msix_count = 0; 2931 msix_count &= IXGBE_PCIE_MSIX_TBL_SZ_MASK; 2932 2933 /* MSI-X count is zero-based in HW */ 2934 msix_count++; 2935 2936 if (msix_count > max_msix_count) 2937 msix_count = max_msix_count; 2938 2939 return msix_count; 2940 } 2941 2942 /** 2943 * ixgbe_clear_vmdq_generic - Disassociate a VMDq pool index from a rx address 2944 * @hw: pointer to hardware struct 2945 * @rar: receive address register index to disassociate 2946 * @vmdq: VMDq pool index to remove from the rar 2947 **/ 2948 s32 ixgbe_clear_vmdq_generic(struct ixgbe_hw *hw, u32 rar, u32 vmdq) 2949 { 2950 u32 mpsar_lo, mpsar_hi; 2951 u32 rar_entries = hw->mac.num_rar_entries; 2952 2953 /* Make sure we are using a valid rar index range */ 2954 if (rar >= rar_entries) { 2955 hw_dbg(hw, "RAR index %d is out of range.\n", rar); 2956 return IXGBE_ERR_INVALID_ARGUMENT; 2957 } 2958 2959 mpsar_lo = IXGBE_READ_REG(hw, IXGBE_MPSAR_LO(rar)); 2960 mpsar_hi = IXGBE_READ_REG(hw, IXGBE_MPSAR_HI(rar)); 2961 2962 if (ixgbe_removed(hw->hw_addr)) 2963 return 0; 2964 2965 if (!mpsar_lo && !mpsar_hi) 2966 return 0; 2967 2968 if (vmdq == IXGBE_CLEAR_VMDQ_ALL) { 2969 if (mpsar_lo) { 2970 IXGBE_WRITE_REG(hw, IXGBE_MPSAR_LO(rar), 0); 2971 mpsar_lo = 0; 2972 } 2973 if (mpsar_hi) { 2974 IXGBE_WRITE_REG(hw, IXGBE_MPSAR_HI(rar), 0); 2975 mpsar_hi = 0; 2976 } 2977 } else if (vmdq < 32) { 2978 mpsar_lo &= ~BIT(vmdq); 2979 IXGBE_WRITE_REG(hw, IXGBE_MPSAR_LO(rar), mpsar_lo); 2980 } else { 2981 mpsar_hi &= ~BIT(vmdq - 32); 2982 IXGBE_WRITE_REG(hw, IXGBE_MPSAR_HI(rar), mpsar_hi); 2983 } 2984 2985 /* was that the last pool using this rar? */ 2986 if (mpsar_lo == 0 && mpsar_hi == 0 && 2987 rar != 0 && rar != hw->mac.san_mac_rar_index) 2988 hw->mac.ops.clear_rar(hw, rar); 2989 2990 return 0; 2991 } 2992 2993 /** 2994 * ixgbe_set_vmdq_generic - Associate a VMDq pool index with a rx address 2995 * @hw: pointer to hardware struct 2996 * @rar: receive address register index to associate with a VMDq index 2997 * @vmdq: VMDq pool index 2998 **/ 2999 s32 ixgbe_set_vmdq_generic(struct ixgbe_hw *hw, u32 rar, u32 vmdq) 3000 { 3001 u32 mpsar; 3002 u32 rar_entries = hw->mac.num_rar_entries; 3003 3004 /* Make sure we are using a valid rar index range */ 3005 if (rar >= rar_entries) { 3006 hw_dbg(hw, "RAR index %d is out of range.\n", rar); 3007 return IXGBE_ERR_INVALID_ARGUMENT; 3008 } 3009 3010 if (vmdq < 32) { 3011 mpsar = IXGBE_READ_REG(hw, IXGBE_MPSAR_LO(rar)); 3012 mpsar |= BIT(vmdq); 3013 IXGBE_WRITE_REG(hw, IXGBE_MPSAR_LO(rar), mpsar); 3014 } else { 3015 mpsar = IXGBE_READ_REG(hw, IXGBE_MPSAR_HI(rar)); 3016 mpsar |= BIT(vmdq - 32); 3017 IXGBE_WRITE_REG(hw, IXGBE_MPSAR_HI(rar), mpsar); 3018 } 3019 return 0; 3020 } 3021 3022 /** 3023 * This function should only be involved in the IOV mode. 3024 * In IOV mode, Default pool is next pool after the number of 3025 * VFs advertized and not 0. 3026 * MPSAR table needs to be updated for SAN_MAC RAR [hw->mac.san_mac_rar_index] 3027 * 3028 * ixgbe_set_vmdq_san_mac - Associate default VMDq pool index with a rx address 3029 * @hw: pointer to hardware struct 3030 * @vmdq: VMDq pool index 3031 **/ 3032 s32 ixgbe_set_vmdq_san_mac_generic(struct ixgbe_hw *hw, u32 vmdq) 3033 { 3034 u32 rar = hw->mac.san_mac_rar_index; 3035 3036 if (vmdq < 32) { 3037 IXGBE_WRITE_REG(hw, IXGBE_MPSAR_LO(rar), BIT(vmdq)); 3038 IXGBE_WRITE_REG(hw, IXGBE_MPSAR_HI(rar), 0); 3039 } else { 3040 IXGBE_WRITE_REG(hw, IXGBE_MPSAR_LO(rar), 0); 3041 IXGBE_WRITE_REG(hw, IXGBE_MPSAR_HI(rar), BIT(vmdq - 32)); 3042 } 3043 3044 return 0; 3045 } 3046 3047 /** 3048 * ixgbe_init_uta_tables_generic - Initialize the Unicast Table Array 3049 * @hw: pointer to hardware structure 3050 **/ 3051 s32 ixgbe_init_uta_tables_generic(struct ixgbe_hw *hw) 3052 { 3053 int i; 3054 3055 for (i = 0; i < 128; i++) 3056 IXGBE_WRITE_REG(hw, IXGBE_UTA(i), 0); 3057 3058 return 0; 3059 } 3060 3061 /** 3062 * ixgbe_find_vlvf_slot - find the vlanid or the first empty slot 3063 * @hw: pointer to hardware structure 3064 * @vlan: VLAN id to write to VLAN filter 3065 * @vlvf_bypass: true to find vlanid only, false returns first empty slot if 3066 * vlanid not found 3067 * 3068 * return the VLVF index where this VLAN id should be placed 3069 * 3070 **/ 3071 static s32 ixgbe_find_vlvf_slot(struct ixgbe_hw *hw, u32 vlan, bool vlvf_bypass) 3072 { 3073 s32 regindex, first_empty_slot; 3074 u32 bits; 3075 3076 /* short cut the special case */ 3077 if (vlan == 0) 3078 return 0; 3079 3080 /* if vlvf_bypass is set we don't want to use an empty slot, we 3081 * will simply bypass the VLVF if there are no entries present in the 3082 * VLVF that contain our VLAN 3083 */ 3084 first_empty_slot = vlvf_bypass ? IXGBE_ERR_NO_SPACE : 0; 3085 3086 /* add VLAN enable bit for comparison */ 3087 vlan |= IXGBE_VLVF_VIEN; 3088 3089 /* Search for the vlan id in the VLVF entries. Save off the first empty 3090 * slot found along the way. 3091 * 3092 * pre-decrement loop covering (IXGBE_VLVF_ENTRIES - 1) .. 1 3093 */ 3094 for (regindex = IXGBE_VLVF_ENTRIES; --regindex;) { 3095 bits = IXGBE_READ_REG(hw, IXGBE_VLVF(regindex)); 3096 if (bits == vlan) 3097 return regindex; 3098 if (!first_empty_slot && !bits) 3099 first_empty_slot = regindex; 3100 } 3101 3102 /* If we are here then we didn't find the VLAN. Return first empty 3103 * slot we found during our search, else error. 3104 */ 3105 if (!first_empty_slot) 3106 hw_dbg(hw, "No space in VLVF.\n"); 3107 3108 return first_empty_slot ? : IXGBE_ERR_NO_SPACE; 3109 } 3110 3111 /** 3112 * ixgbe_set_vfta_generic - Set VLAN filter table 3113 * @hw: pointer to hardware structure 3114 * @vlan: VLAN id to write to VLAN filter 3115 * @vind: VMDq output index that maps queue to VLAN id in VFVFB 3116 * @vlan_on: boolean flag to turn on/off VLAN in VFVF 3117 * @vlvf_bypass: boolean flag indicating updating default pool is okay 3118 * 3119 * Turn on/off specified VLAN in the VLAN filter table. 3120 **/ 3121 s32 ixgbe_set_vfta_generic(struct ixgbe_hw *hw, u32 vlan, u32 vind, 3122 bool vlan_on, bool vlvf_bypass) 3123 { 3124 u32 regidx, vfta_delta, vfta, bits; 3125 s32 vlvf_index; 3126 3127 if ((vlan > 4095) || (vind > 63)) 3128 return IXGBE_ERR_PARAM; 3129 3130 /* 3131 * this is a 2 part operation - first the VFTA, then the 3132 * VLVF and VLVFB if VT Mode is set 3133 * We don't write the VFTA until we know the VLVF part succeeded. 3134 */ 3135 3136 /* Part 1 3137 * The VFTA is a bitstring made up of 128 32-bit registers 3138 * that enable the particular VLAN id, much like the MTA: 3139 * bits[11-5]: which register 3140 * bits[4-0]: which bit in the register 3141 */ 3142 regidx = vlan / 32; 3143 vfta_delta = BIT(vlan % 32); 3144 vfta = IXGBE_READ_REG(hw, IXGBE_VFTA(regidx)); 3145 3146 /* vfta_delta represents the difference between the current value 3147 * of vfta and the value we want in the register. Since the diff 3148 * is an XOR mask we can just update vfta using an XOR. 3149 */ 3150 vfta_delta &= vlan_on ? ~vfta : vfta; 3151 vfta ^= vfta_delta; 3152 3153 /* Part 2 3154 * If VT Mode is set 3155 * Either vlan_on 3156 * make sure the vlan is in VLVF 3157 * set the vind bit in the matching VLVFB 3158 * Or !vlan_on 3159 * clear the pool bit and possibly the vind 3160 */ 3161 if (!(IXGBE_READ_REG(hw, IXGBE_VT_CTL) & IXGBE_VT_CTL_VT_ENABLE)) 3162 goto vfta_update; 3163 3164 vlvf_index = ixgbe_find_vlvf_slot(hw, vlan, vlvf_bypass); 3165 if (vlvf_index < 0) { 3166 if (vlvf_bypass) 3167 goto vfta_update; 3168 return vlvf_index; 3169 } 3170 3171 bits = IXGBE_READ_REG(hw, IXGBE_VLVFB(vlvf_index * 2 + vind / 32)); 3172 3173 /* set the pool bit */ 3174 bits |= BIT(vind % 32); 3175 if (vlan_on) 3176 goto vlvf_update; 3177 3178 /* clear the pool bit */ 3179 bits ^= BIT(vind % 32); 3180 3181 if (!bits && 3182 !IXGBE_READ_REG(hw, IXGBE_VLVFB(vlvf_index * 2 + 1 - vind / 32))) { 3183 /* Clear VFTA first, then disable VLVF. Otherwise 3184 * we run the risk of stray packets leaking into 3185 * the PF via the default pool 3186 */ 3187 if (vfta_delta) 3188 IXGBE_WRITE_REG(hw, IXGBE_VFTA(regidx), vfta); 3189 3190 /* disable VLVF and clear remaining bit from pool */ 3191 IXGBE_WRITE_REG(hw, IXGBE_VLVF(vlvf_index), 0); 3192 IXGBE_WRITE_REG(hw, IXGBE_VLVFB(vlvf_index * 2 + vind / 32), 0); 3193 3194 return 0; 3195 } 3196 3197 /* If there are still bits set in the VLVFB registers 3198 * for the VLAN ID indicated we need to see if the 3199 * caller is requesting that we clear the VFTA entry bit. 3200 * If the caller has requested that we clear the VFTA 3201 * entry bit but there are still pools/VFs using this VLAN 3202 * ID entry then ignore the request. We're not worried 3203 * about the case where we're turning the VFTA VLAN ID 3204 * entry bit on, only when requested to turn it off as 3205 * there may be multiple pools and/or VFs using the 3206 * VLAN ID entry. In that case we cannot clear the 3207 * VFTA bit until all pools/VFs using that VLAN ID have also 3208 * been cleared. This will be indicated by "bits" being 3209 * zero. 3210 */ 3211 vfta_delta = 0; 3212 3213 vlvf_update: 3214 /* record pool change and enable VLAN ID if not already enabled */ 3215 IXGBE_WRITE_REG(hw, IXGBE_VLVFB(vlvf_index * 2 + vind / 32), bits); 3216 IXGBE_WRITE_REG(hw, IXGBE_VLVF(vlvf_index), IXGBE_VLVF_VIEN | vlan); 3217 3218 vfta_update: 3219 /* Update VFTA now that we are ready for traffic */ 3220 if (vfta_delta) 3221 IXGBE_WRITE_REG(hw, IXGBE_VFTA(regidx), vfta); 3222 3223 return 0; 3224 } 3225 3226 /** 3227 * ixgbe_clear_vfta_generic - Clear VLAN filter table 3228 * @hw: pointer to hardware structure 3229 * 3230 * Clears the VLAN filer table, and the VMDq index associated with the filter 3231 **/ 3232 s32 ixgbe_clear_vfta_generic(struct ixgbe_hw *hw) 3233 { 3234 u32 offset; 3235 3236 for (offset = 0; offset < hw->mac.vft_size; offset++) 3237 IXGBE_WRITE_REG(hw, IXGBE_VFTA(offset), 0); 3238 3239 for (offset = 0; offset < IXGBE_VLVF_ENTRIES; offset++) { 3240 IXGBE_WRITE_REG(hw, IXGBE_VLVF(offset), 0); 3241 IXGBE_WRITE_REG(hw, IXGBE_VLVFB(offset * 2), 0); 3242 IXGBE_WRITE_REG(hw, IXGBE_VLVFB(offset * 2 + 1), 0); 3243 } 3244 3245 return 0; 3246 } 3247 3248 /** 3249 * ixgbe_need_crosstalk_fix - Determine if we need to do cross talk fix 3250 * @hw: pointer to hardware structure 3251 * 3252 * Contains the logic to identify if we need to verify link for the 3253 * crosstalk fix 3254 **/ 3255 static bool ixgbe_need_crosstalk_fix(struct ixgbe_hw *hw) 3256 { 3257 /* Does FW say we need the fix */ 3258 if (!hw->need_crosstalk_fix) 3259 return false; 3260 3261 /* Only consider SFP+ PHYs i.e. media type fiber */ 3262 switch (hw->mac.ops.get_media_type(hw)) { 3263 case ixgbe_media_type_fiber: 3264 case ixgbe_media_type_fiber_qsfp: 3265 break; 3266 default: 3267 return false; 3268 } 3269 3270 return true; 3271 } 3272 3273 /** 3274 * ixgbe_check_mac_link_generic - Determine link and speed status 3275 * @hw: pointer to hardware structure 3276 * @speed: pointer to link speed 3277 * @link_up: true when link is up 3278 * @link_up_wait_to_complete: bool used to wait for link up or not 3279 * 3280 * Reads the links register to determine if link is up and the current speed 3281 **/ 3282 s32 ixgbe_check_mac_link_generic(struct ixgbe_hw *hw, ixgbe_link_speed *speed, 3283 bool *link_up, bool link_up_wait_to_complete) 3284 { 3285 u32 links_reg, links_orig; 3286 u32 i; 3287 3288 /* If Crosstalk fix enabled do the sanity check of making sure 3289 * the SFP+ cage is full. 3290 */ 3291 if (ixgbe_need_crosstalk_fix(hw)) { 3292 u32 sfp_cage_full; 3293 3294 switch (hw->mac.type) { 3295 case ixgbe_mac_82599EB: 3296 sfp_cage_full = IXGBE_READ_REG(hw, IXGBE_ESDP) & 3297 IXGBE_ESDP_SDP2; 3298 break; 3299 case ixgbe_mac_X550EM_x: 3300 case ixgbe_mac_x550em_a: 3301 sfp_cage_full = IXGBE_READ_REG(hw, IXGBE_ESDP) & 3302 IXGBE_ESDP_SDP0; 3303 break; 3304 default: 3305 /* sanity check - No SFP+ devices here */ 3306 sfp_cage_full = false; 3307 break; 3308 } 3309 3310 if (!sfp_cage_full) { 3311 *link_up = false; 3312 *speed = IXGBE_LINK_SPEED_UNKNOWN; 3313 return 0; 3314 } 3315 } 3316 3317 /* clear the old state */ 3318 links_orig = IXGBE_READ_REG(hw, IXGBE_LINKS); 3319 3320 links_reg = IXGBE_READ_REG(hw, IXGBE_LINKS); 3321 3322 if (links_orig != links_reg) { 3323 hw_dbg(hw, "LINKS changed from %08X to %08X\n", 3324 links_orig, links_reg); 3325 } 3326 3327 if (link_up_wait_to_complete) { 3328 for (i = 0; i < IXGBE_LINK_UP_TIME; i++) { 3329 if (links_reg & IXGBE_LINKS_UP) { 3330 *link_up = true; 3331 break; 3332 } else { 3333 *link_up = false; 3334 } 3335 msleep(100); 3336 links_reg = IXGBE_READ_REG(hw, IXGBE_LINKS); 3337 } 3338 } else { 3339 if (links_reg & IXGBE_LINKS_UP) 3340 *link_up = true; 3341 else 3342 *link_up = false; 3343 } 3344 3345 switch (links_reg & IXGBE_LINKS_SPEED_82599) { 3346 case IXGBE_LINKS_SPEED_10G_82599: 3347 if ((hw->mac.type >= ixgbe_mac_X550) && 3348 (links_reg & IXGBE_LINKS_SPEED_NON_STD)) 3349 *speed = IXGBE_LINK_SPEED_2_5GB_FULL; 3350 else 3351 *speed = IXGBE_LINK_SPEED_10GB_FULL; 3352 break; 3353 case IXGBE_LINKS_SPEED_1G_82599: 3354 *speed = IXGBE_LINK_SPEED_1GB_FULL; 3355 break; 3356 case IXGBE_LINKS_SPEED_100_82599: 3357 if ((hw->mac.type >= ixgbe_mac_X550) && 3358 (links_reg & IXGBE_LINKS_SPEED_NON_STD)) 3359 *speed = IXGBE_LINK_SPEED_5GB_FULL; 3360 else 3361 *speed = IXGBE_LINK_SPEED_100_FULL; 3362 break; 3363 case IXGBE_LINKS_SPEED_10_X550EM_A: 3364 *speed = IXGBE_LINK_SPEED_UNKNOWN; 3365 if (hw->device_id == IXGBE_DEV_ID_X550EM_A_1G_T || 3366 hw->device_id == IXGBE_DEV_ID_X550EM_A_1G_T_L) { 3367 *speed = IXGBE_LINK_SPEED_10_FULL; 3368 } 3369 break; 3370 default: 3371 *speed = IXGBE_LINK_SPEED_UNKNOWN; 3372 } 3373 3374 return 0; 3375 } 3376 3377 /** 3378 * ixgbe_get_wwn_prefix_generic - Get alternative WWNN/WWPN prefix from 3379 * the EEPROM 3380 * @hw: pointer to hardware structure 3381 * @wwnn_prefix: the alternative WWNN prefix 3382 * @wwpn_prefix: the alternative WWPN prefix 3383 * 3384 * This function will read the EEPROM from the alternative SAN MAC address 3385 * block to check the support for the alternative WWNN/WWPN prefix support. 3386 **/ 3387 s32 ixgbe_get_wwn_prefix_generic(struct ixgbe_hw *hw, u16 *wwnn_prefix, 3388 u16 *wwpn_prefix) 3389 { 3390 u16 offset, caps; 3391 u16 alt_san_mac_blk_offset; 3392 3393 /* clear output first */ 3394 *wwnn_prefix = 0xFFFF; 3395 *wwpn_prefix = 0xFFFF; 3396 3397 /* check if alternative SAN MAC is supported */ 3398 offset = IXGBE_ALT_SAN_MAC_ADDR_BLK_PTR; 3399 if (hw->eeprom.ops.read(hw, offset, &alt_san_mac_blk_offset)) 3400 goto wwn_prefix_err; 3401 3402 if ((alt_san_mac_blk_offset == 0) || 3403 (alt_san_mac_blk_offset == 0xFFFF)) 3404 return 0; 3405 3406 /* check capability in alternative san mac address block */ 3407 offset = alt_san_mac_blk_offset + IXGBE_ALT_SAN_MAC_ADDR_CAPS_OFFSET; 3408 if (hw->eeprom.ops.read(hw, offset, &caps)) 3409 goto wwn_prefix_err; 3410 if (!(caps & IXGBE_ALT_SAN_MAC_ADDR_CAPS_ALTWWN)) 3411 return 0; 3412 3413 /* get the corresponding prefix for WWNN/WWPN */ 3414 offset = alt_san_mac_blk_offset + IXGBE_ALT_SAN_MAC_ADDR_WWNN_OFFSET; 3415 if (hw->eeprom.ops.read(hw, offset, wwnn_prefix)) 3416 hw_err(hw, "eeprom read at offset %d failed\n", offset); 3417 3418 offset = alt_san_mac_blk_offset + IXGBE_ALT_SAN_MAC_ADDR_WWPN_OFFSET; 3419 if (hw->eeprom.ops.read(hw, offset, wwpn_prefix)) 3420 goto wwn_prefix_err; 3421 3422 return 0; 3423 3424 wwn_prefix_err: 3425 hw_err(hw, "eeprom read at offset %d failed\n", offset); 3426 return 0; 3427 } 3428 3429 /** 3430 * ixgbe_set_mac_anti_spoofing - Enable/Disable MAC anti-spoofing 3431 * @hw: pointer to hardware structure 3432 * @enable: enable or disable switch for MAC anti-spoofing 3433 * @vf: Virtual Function pool - VF Pool to set for MAC anti-spoofing 3434 * 3435 **/ 3436 void ixgbe_set_mac_anti_spoofing(struct ixgbe_hw *hw, bool enable, int vf) 3437 { 3438 int vf_target_reg = vf >> 3; 3439 int vf_target_shift = vf % 8; 3440 u32 pfvfspoof; 3441 3442 if (hw->mac.type == ixgbe_mac_82598EB) 3443 return; 3444 3445 pfvfspoof = IXGBE_READ_REG(hw, IXGBE_PFVFSPOOF(vf_target_reg)); 3446 if (enable) 3447 pfvfspoof |= BIT(vf_target_shift); 3448 else 3449 pfvfspoof &= ~BIT(vf_target_shift); 3450 IXGBE_WRITE_REG(hw, IXGBE_PFVFSPOOF(vf_target_reg), pfvfspoof); 3451 } 3452 3453 /** 3454 * ixgbe_set_vlan_anti_spoofing - Enable/Disable VLAN anti-spoofing 3455 * @hw: pointer to hardware structure 3456 * @enable: enable or disable switch for VLAN anti-spoofing 3457 * @vf: Virtual Function pool - VF Pool to set for VLAN anti-spoofing 3458 * 3459 **/ 3460 void ixgbe_set_vlan_anti_spoofing(struct ixgbe_hw *hw, bool enable, int vf) 3461 { 3462 int vf_target_reg = vf >> 3; 3463 int vf_target_shift = vf % 8 + IXGBE_SPOOF_VLANAS_SHIFT; 3464 u32 pfvfspoof; 3465 3466 if (hw->mac.type == ixgbe_mac_82598EB) 3467 return; 3468 3469 pfvfspoof = IXGBE_READ_REG(hw, IXGBE_PFVFSPOOF(vf_target_reg)); 3470 if (enable) 3471 pfvfspoof |= BIT(vf_target_shift); 3472 else 3473 pfvfspoof &= ~BIT(vf_target_shift); 3474 IXGBE_WRITE_REG(hw, IXGBE_PFVFSPOOF(vf_target_reg), pfvfspoof); 3475 } 3476 3477 /** 3478 * ixgbe_get_device_caps_generic - Get additional device capabilities 3479 * @hw: pointer to hardware structure 3480 * @device_caps: the EEPROM word with the extra device capabilities 3481 * 3482 * This function will read the EEPROM location for the device capabilities, 3483 * and return the word through device_caps. 3484 **/ 3485 s32 ixgbe_get_device_caps_generic(struct ixgbe_hw *hw, u16 *device_caps) 3486 { 3487 hw->eeprom.ops.read(hw, IXGBE_DEVICE_CAPS, device_caps); 3488 3489 return 0; 3490 } 3491 3492 /** 3493 * ixgbe_set_rxpba_generic - Initialize RX packet buffer 3494 * @hw: pointer to hardware structure 3495 * @num_pb: number of packet buffers to allocate 3496 * @headroom: reserve n KB of headroom 3497 * @strategy: packet buffer allocation strategy 3498 **/ 3499 void ixgbe_set_rxpba_generic(struct ixgbe_hw *hw, 3500 int num_pb, 3501 u32 headroom, 3502 int strategy) 3503 { 3504 u32 pbsize = hw->mac.rx_pb_size; 3505 int i = 0; 3506 u32 rxpktsize, txpktsize, txpbthresh; 3507 3508 /* Reserve headroom */ 3509 pbsize -= headroom; 3510 3511 if (!num_pb) 3512 num_pb = 1; 3513 3514 /* Divide remaining packet buffer space amongst the number 3515 * of packet buffers requested using supplied strategy. 3516 */ 3517 switch (strategy) { 3518 case (PBA_STRATEGY_WEIGHTED): 3519 /* pba_80_48 strategy weight first half of packet buffer with 3520 * 5/8 of the packet buffer space. 3521 */ 3522 rxpktsize = ((pbsize * 5 * 2) / (num_pb * 8)); 3523 pbsize -= rxpktsize * (num_pb / 2); 3524 rxpktsize <<= IXGBE_RXPBSIZE_SHIFT; 3525 for (; i < (num_pb / 2); i++) 3526 IXGBE_WRITE_REG(hw, IXGBE_RXPBSIZE(i), rxpktsize); 3527 /* fall through - configure remaining packet buffers */ 3528 case (PBA_STRATEGY_EQUAL): 3529 /* Divide the remaining Rx packet buffer evenly among the TCs */ 3530 rxpktsize = (pbsize / (num_pb - i)) << IXGBE_RXPBSIZE_SHIFT; 3531 for (; i < num_pb; i++) 3532 IXGBE_WRITE_REG(hw, IXGBE_RXPBSIZE(i), rxpktsize); 3533 break; 3534 default: 3535 break; 3536 } 3537 3538 /* 3539 * Setup Tx packet buffer and threshold equally for all TCs 3540 * TXPBTHRESH register is set in K so divide by 1024 and subtract 3541 * 10 since the largest packet we support is just over 9K. 3542 */ 3543 txpktsize = IXGBE_TXPBSIZE_MAX / num_pb; 3544 txpbthresh = (txpktsize / 1024) - IXGBE_TXPKT_SIZE_MAX; 3545 for (i = 0; i < num_pb; i++) { 3546 IXGBE_WRITE_REG(hw, IXGBE_TXPBSIZE(i), txpktsize); 3547 IXGBE_WRITE_REG(hw, IXGBE_TXPBTHRESH(i), txpbthresh); 3548 } 3549 3550 /* Clear unused TCs, if any, to zero buffer size*/ 3551 for (; i < IXGBE_MAX_PB; i++) { 3552 IXGBE_WRITE_REG(hw, IXGBE_RXPBSIZE(i), 0); 3553 IXGBE_WRITE_REG(hw, IXGBE_TXPBSIZE(i), 0); 3554 IXGBE_WRITE_REG(hw, IXGBE_TXPBTHRESH(i), 0); 3555 } 3556 } 3557 3558 /** 3559 * ixgbe_calculate_checksum - Calculate checksum for buffer 3560 * @buffer: pointer to EEPROM 3561 * @length: size of EEPROM to calculate a checksum for 3562 * 3563 * Calculates the checksum for some buffer on a specified length. The 3564 * checksum calculated is returned. 3565 **/ 3566 u8 ixgbe_calculate_checksum(u8 *buffer, u32 length) 3567 { 3568 u32 i; 3569 u8 sum = 0; 3570 3571 if (!buffer) 3572 return 0; 3573 3574 for (i = 0; i < length; i++) 3575 sum += buffer[i]; 3576 3577 return (u8) (0 - sum); 3578 } 3579 3580 /** 3581 * ixgbe_hic_unlocked - Issue command to manageability block unlocked 3582 * @hw: pointer to the HW structure 3583 * @buffer: command to write and where the return status will be placed 3584 * @length: length of buffer, must be multiple of 4 bytes 3585 * @timeout: time in ms to wait for command completion 3586 * 3587 * Communicates with the manageability block. On success return 0 3588 * else returns semaphore error when encountering an error acquiring 3589 * semaphore or IXGBE_ERR_HOST_INTERFACE_COMMAND when command fails. 3590 * 3591 * This function assumes that the IXGBE_GSSR_SW_MNG_SM semaphore is held 3592 * by the caller. 3593 **/ 3594 s32 ixgbe_hic_unlocked(struct ixgbe_hw *hw, u32 *buffer, u32 length, 3595 u32 timeout) 3596 { 3597 u32 hicr, i, fwsts; 3598 u16 dword_len; 3599 3600 if (!length || length > IXGBE_HI_MAX_BLOCK_BYTE_LENGTH) { 3601 hw_dbg(hw, "Buffer length failure buffersize-%d.\n", length); 3602 return IXGBE_ERR_HOST_INTERFACE_COMMAND; 3603 } 3604 3605 /* Set bit 9 of FWSTS clearing FW reset indication */ 3606 fwsts = IXGBE_READ_REG(hw, IXGBE_FWSTS); 3607 IXGBE_WRITE_REG(hw, IXGBE_FWSTS, fwsts | IXGBE_FWSTS_FWRI); 3608 3609 /* Check that the host interface is enabled. */ 3610 hicr = IXGBE_READ_REG(hw, IXGBE_HICR); 3611 if (!(hicr & IXGBE_HICR_EN)) { 3612 hw_dbg(hw, "IXGBE_HOST_EN bit disabled.\n"); 3613 return IXGBE_ERR_HOST_INTERFACE_COMMAND; 3614 } 3615 3616 /* Calculate length in DWORDs. We must be DWORD aligned */ 3617 if (length % sizeof(u32)) { 3618 hw_dbg(hw, "Buffer length failure, not aligned to dword"); 3619 return IXGBE_ERR_INVALID_ARGUMENT; 3620 } 3621 3622 dword_len = length >> 2; 3623 3624 /* The device driver writes the relevant command block 3625 * into the ram area. 3626 */ 3627 for (i = 0; i < dword_len; i++) 3628 IXGBE_WRITE_REG_ARRAY(hw, IXGBE_FLEX_MNG, 3629 i, (__force u32)cpu_to_le32(buffer[i])); 3630 3631 /* Setting this bit tells the ARC that a new command is pending. */ 3632 IXGBE_WRITE_REG(hw, IXGBE_HICR, hicr | IXGBE_HICR_C); 3633 3634 for (i = 0; i < timeout; i++) { 3635 hicr = IXGBE_READ_REG(hw, IXGBE_HICR); 3636 if (!(hicr & IXGBE_HICR_C)) 3637 break; 3638 usleep_range(1000, 2000); 3639 } 3640 3641 /* Check command successful completion. */ 3642 if ((timeout && i == timeout) || 3643 !(IXGBE_READ_REG(hw, IXGBE_HICR) & IXGBE_HICR_SV)) 3644 return IXGBE_ERR_HOST_INTERFACE_COMMAND; 3645 3646 return 0; 3647 } 3648 3649 /** 3650 * ixgbe_host_interface_command - Issue command to manageability block 3651 * @hw: pointer to the HW structure 3652 * @buffer: contains the command to write and where the return status will 3653 * be placed 3654 * @length: length of buffer, must be multiple of 4 bytes 3655 * @timeout: time in ms to wait for command completion 3656 * @return_data: read and return data from the buffer (true) or not (false) 3657 * Needed because FW structures are big endian and decoding of 3658 * these fields can be 8 bit or 16 bit based on command. Decoding 3659 * is not easily understood without making a table of commands. 3660 * So we will leave this up to the caller to read back the data 3661 * in these cases. 3662 * 3663 * Communicates with the manageability block. On success return 0 3664 * else return IXGBE_ERR_HOST_INTERFACE_COMMAND. 3665 **/ 3666 s32 ixgbe_host_interface_command(struct ixgbe_hw *hw, void *buffer, 3667 u32 length, u32 timeout, 3668 bool return_data) 3669 { 3670 u32 hdr_size = sizeof(struct ixgbe_hic_hdr); 3671 union { 3672 struct ixgbe_hic_hdr hdr; 3673 u32 u32arr[1]; 3674 } *bp = buffer; 3675 u16 buf_len, dword_len; 3676 s32 status; 3677 u32 bi; 3678 3679 if (!length || length > IXGBE_HI_MAX_BLOCK_BYTE_LENGTH) { 3680 hw_dbg(hw, "Buffer length failure buffersize-%d.\n", length); 3681 return IXGBE_ERR_HOST_INTERFACE_COMMAND; 3682 } 3683 /* Take management host interface semaphore */ 3684 status = hw->mac.ops.acquire_swfw_sync(hw, IXGBE_GSSR_SW_MNG_SM); 3685 if (status) 3686 return status; 3687 3688 status = ixgbe_hic_unlocked(hw, buffer, length, timeout); 3689 if (status) 3690 goto rel_out; 3691 3692 if (!return_data) 3693 goto rel_out; 3694 3695 /* Calculate length in DWORDs */ 3696 dword_len = hdr_size >> 2; 3697 3698 /* first pull in the header so we know the buffer length */ 3699 for (bi = 0; bi < dword_len; bi++) { 3700 bp->u32arr[bi] = IXGBE_READ_REG_ARRAY(hw, IXGBE_FLEX_MNG, bi); 3701 le32_to_cpus(&bp->u32arr[bi]); 3702 } 3703 3704 /* If there is any thing in data position pull it in */ 3705 buf_len = bp->hdr.buf_len; 3706 if (!buf_len) 3707 goto rel_out; 3708 3709 if (length < round_up(buf_len, 4) + hdr_size) { 3710 hw_dbg(hw, "Buffer not large enough for reply message.\n"); 3711 status = IXGBE_ERR_HOST_INTERFACE_COMMAND; 3712 goto rel_out; 3713 } 3714 3715 /* Calculate length in DWORDs, add 3 for odd lengths */ 3716 dword_len = (buf_len + 3) >> 2; 3717 3718 /* Pull in the rest of the buffer (bi is where we left off) */ 3719 for (; bi <= dword_len; bi++) { 3720 bp->u32arr[bi] = IXGBE_READ_REG_ARRAY(hw, IXGBE_FLEX_MNG, bi); 3721 le32_to_cpus(&bp->u32arr[bi]); 3722 } 3723 3724 rel_out: 3725 hw->mac.ops.release_swfw_sync(hw, IXGBE_GSSR_SW_MNG_SM); 3726 3727 return status; 3728 } 3729 3730 /** 3731 * ixgbe_set_fw_drv_ver_generic - Sends driver version to firmware 3732 * @hw: pointer to the HW structure 3733 * @maj: driver version major number 3734 * @min: driver version minor number 3735 * @build: driver version build number 3736 * @sub: driver version sub build number 3737 * @len: length of driver_ver string 3738 * @driver_ver: driver string 3739 * 3740 * Sends driver version number to firmware through the manageability 3741 * block. On success return 0 3742 * else returns IXGBE_ERR_SWFW_SYNC when encountering an error acquiring 3743 * semaphore or IXGBE_ERR_HOST_INTERFACE_COMMAND when command fails. 3744 **/ 3745 s32 ixgbe_set_fw_drv_ver_generic(struct ixgbe_hw *hw, u8 maj, u8 min, 3746 u8 build, u8 sub, __always_unused u16 len, 3747 __always_unused const char *driver_ver) 3748 { 3749 struct ixgbe_hic_drv_info fw_cmd; 3750 int i; 3751 s32 ret_val; 3752 3753 fw_cmd.hdr.cmd = FW_CEM_CMD_DRIVER_INFO; 3754 fw_cmd.hdr.buf_len = FW_CEM_CMD_DRIVER_INFO_LEN; 3755 fw_cmd.hdr.cmd_or_resp.cmd_resv = FW_CEM_CMD_RESERVED; 3756 fw_cmd.port_num = hw->bus.func; 3757 fw_cmd.ver_maj = maj; 3758 fw_cmd.ver_min = min; 3759 fw_cmd.ver_build = build; 3760 fw_cmd.ver_sub = sub; 3761 fw_cmd.hdr.checksum = 0; 3762 fw_cmd.pad = 0; 3763 fw_cmd.pad2 = 0; 3764 fw_cmd.hdr.checksum = ixgbe_calculate_checksum((u8 *)&fw_cmd, 3765 (FW_CEM_HDR_LEN + fw_cmd.hdr.buf_len)); 3766 3767 for (i = 0; i <= FW_CEM_MAX_RETRIES; i++) { 3768 ret_val = ixgbe_host_interface_command(hw, &fw_cmd, 3769 sizeof(fw_cmd), 3770 IXGBE_HI_COMMAND_TIMEOUT, 3771 true); 3772 if (ret_val != 0) 3773 continue; 3774 3775 if (fw_cmd.hdr.cmd_or_resp.ret_status == 3776 FW_CEM_RESP_STATUS_SUCCESS) 3777 ret_val = 0; 3778 else 3779 ret_val = IXGBE_ERR_HOST_INTERFACE_COMMAND; 3780 3781 break; 3782 } 3783 3784 return ret_val; 3785 } 3786 3787 /** 3788 * ixgbe_clear_tx_pending - Clear pending TX work from the PCIe fifo 3789 * @hw: pointer to the hardware structure 3790 * 3791 * The 82599 and x540 MACs can experience issues if TX work is still pending 3792 * when a reset occurs. This function prevents this by flushing the PCIe 3793 * buffers on the system. 3794 **/ 3795 void ixgbe_clear_tx_pending(struct ixgbe_hw *hw) 3796 { 3797 u32 gcr_ext, hlreg0, i, poll; 3798 u16 value; 3799 3800 /* 3801 * If double reset is not requested then all transactions should 3802 * already be clear and as such there is no work to do 3803 */ 3804 if (!(hw->mac.flags & IXGBE_FLAGS_DOUBLE_RESET_REQUIRED)) 3805 return; 3806 3807 /* 3808 * Set loopback enable to prevent any transmits from being sent 3809 * should the link come up. This assumes that the RXCTRL.RXEN bit 3810 * has already been cleared. 3811 */ 3812 hlreg0 = IXGBE_READ_REG(hw, IXGBE_HLREG0); 3813 IXGBE_WRITE_REG(hw, IXGBE_HLREG0, hlreg0 | IXGBE_HLREG0_LPBK); 3814 3815 /* wait for a last completion before clearing buffers */ 3816 IXGBE_WRITE_FLUSH(hw); 3817 usleep_range(3000, 6000); 3818 3819 /* Before proceeding, make sure that the PCIe block does not have 3820 * transactions pending. 3821 */ 3822 poll = ixgbe_pcie_timeout_poll(hw); 3823 for (i = 0; i < poll; i++) { 3824 usleep_range(100, 200); 3825 value = ixgbe_read_pci_cfg_word(hw, IXGBE_PCI_DEVICE_STATUS); 3826 if (ixgbe_removed(hw->hw_addr)) 3827 break; 3828 if (!(value & IXGBE_PCI_DEVICE_STATUS_TRANSACTION_PENDING)) 3829 break; 3830 } 3831 3832 /* initiate cleaning flow for buffers in the PCIe transaction layer */ 3833 gcr_ext = IXGBE_READ_REG(hw, IXGBE_GCR_EXT); 3834 IXGBE_WRITE_REG(hw, IXGBE_GCR_EXT, 3835 gcr_ext | IXGBE_GCR_EXT_BUFFERS_CLEAR); 3836 3837 /* Flush all writes and allow 20usec for all transactions to clear */ 3838 IXGBE_WRITE_FLUSH(hw); 3839 udelay(20); 3840 3841 /* restore previous register values */ 3842 IXGBE_WRITE_REG(hw, IXGBE_GCR_EXT, gcr_ext); 3843 IXGBE_WRITE_REG(hw, IXGBE_HLREG0, hlreg0); 3844 } 3845 3846 static const u8 ixgbe_emc_temp_data[4] = { 3847 IXGBE_EMC_INTERNAL_DATA, 3848 IXGBE_EMC_DIODE1_DATA, 3849 IXGBE_EMC_DIODE2_DATA, 3850 IXGBE_EMC_DIODE3_DATA 3851 }; 3852 static const u8 ixgbe_emc_therm_limit[4] = { 3853 IXGBE_EMC_INTERNAL_THERM_LIMIT, 3854 IXGBE_EMC_DIODE1_THERM_LIMIT, 3855 IXGBE_EMC_DIODE2_THERM_LIMIT, 3856 IXGBE_EMC_DIODE3_THERM_LIMIT 3857 }; 3858 3859 /** 3860 * ixgbe_get_ets_data - Extracts the ETS bit data 3861 * @hw: pointer to hardware structure 3862 * @ets_cfg: extected ETS data 3863 * @ets_offset: offset of ETS data 3864 * 3865 * Returns error code. 3866 **/ 3867 static s32 ixgbe_get_ets_data(struct ixgbe_hw *hw, u16 *ets_cfg, 3868 u16 *ets_offset) 3869 { 3870 s32 status; 3871 3872 status = hw->eeprom.ops.read(hw, IXGBE_ETS_CFG, ets_offset); 3873 if (status) 3874 return status; 3875 3876 if ((*ets_offset == 0x0000) || (*ets_offset == 0xFFFF)) 3877 return IXGBE_NOT_IMPLEMENTED; 3878 3879 status = hw->eeprom.ops.read(hw, *ets_offset, ets_cfg); 3880 if (status) 3881 return status; 3882 3883 if ((*ets_cfg & IXGBE_ETS_TYPE_MASK) != IXGBE_ETS_TYPE_EMC_SHIFTED) 3884 return IXGBE_NOT_IMPLEMENTED; 3885 3886 return 0; 3887 } 3888 3889 /** 3890 * ixgbe_get_thermal_sensor_data - Gathers thermal sensor data 3891 * @hw: pointer to hardware structure 3892 * 3893 * Returns the thermal sensor data structure 3894 **/ 3895 s32 ixgbe_get_thermal_sensor_data_generic(struct ixgbe_hw *hw) 3896 { 3897 s32 status; 3898 u16 ets_offset; 3899 u16 ets_cfg; 3900 u16 ets_sensor; 3901 u8 num_sensors; 3902 u8 i; 3903 struct ixgbe_thermal_sensor_data *data = &hw->mac.thermal_sensor_data; 3904 3905 /* Only support thermal sensors attached to physical port 0 */ 3906 if ((IXGBE_READ_REG(hw, IXGBE_STATUS) & IXGBE_STATUS_LAN_ID_1)) 3907 return IXGBE_NOT_IMPLEMENTED; 3908 3909 status = ixgbe_get_ets_data(hw, &ets_cfg, &ets_offset); 3910 if (status) 3911 return status; 3912 3913 num_sensors = (ets_cfg & IXGBE_ETS_NUM_SENSORS_MASK); 3914 if (num_sensors > IXGBE_MAX_SENSORS) 3915 num_sensors = IXGBE_MAX_SENSORS; 3916 3917 for (i = 0; i < num_sensors; i++) { 3918 u8 sensor_index; 3919 u8 sensor_location; 3920 3921 status = hw->eeprom.ops.read(hw, (ets_offset + 1 + i), 3922 &ets_sensor); 3923 if (status) 3924 return status; 3925 3926 sensor_index = ((ets_sensor & IXGBE_ETS_DATA_INDEX_MASK) >> 3927 IXGBE_ETS_DATA_INDEX_SHIFT); 3928 sensor_location = ((ets_sensor & IXGBE_ETS_DATA_LOC_MASK) >> 3929 IXGBE_ETS_DATA_LOC_SHIFT); 3930 3931 if (sensor_location != 0) { 3932 status = hw->phy.ops.read_i2c_byte(hw, 3933 ixgbe_emc_temp_data[sensor_index], 3934 IXGBE_I2C_THERMAL_SENSOR_ADDR, 3935 &data->sensor[i].temp); 3936 if (status) 3937 return status; 3938 } 3939 } 3940 3941 return 0; 3942 } 3943 3944 /** 3945 * ixgbe_init_thermal_sensor_thresh_generic - Inits thermal sensor thresholds 3946 * @hw: pointer to hardware structure 3947 * 3948 * Inits the thermal sensor thresholds according to the NVM map 3949 * and save off the threshold and location values into mac.thermal_sensor_data 3950 **/ 3951 s32 ixgbe_init_thermal_sensor_thresh_generic(struct ixgbe_hw *hw) 3952 { 3953 s32 status; 3954 u16 ets_offset; 3955 u16 ets_cfg; 3956 u16 ets_sensor; 3957 u8 low_thresh_delta; 3958 u8 num_sensors; 3959 u8 therm_limit; 3960 u8 i; 3961 struct ixgbe_thermal_sensor_data *data = &hw->mac.thermal_sensor_data; 3962 3963 memset(data, 0, sizeof(struct ixgbe_thermal_sensor_data)); 3964 3965 /* Only support thermal sensors attached to physical port 0 */ 3966 if ((IXGBE_READ_REG(hw, IXGBE_STATUS) & IXGBE_STATUS_LAN_ID_1)) 3967 return IXGBE_NOT_IMPLEMENTED; 3968 3969 status = ixgbe_get_ets_data(hw, &ets_cfg, &ets_offset); 3970 if (status) 3971 return status; 3972 3973 low_thresh_delta = ((ets_cfg & IXGBE_ETS_LTHRES_DELTA_MASK) >> 3974 IXGBE_ETS_LTHRES_DELTA_SHIFT); 3975 num_sensors = (ets_cfg & IXGBE_ETS_NUM_SENSORS_MASK); 3976 if (num_sensors > IXGBE_MAX_SENSORS) 3977 num_sensors = IXGBE_MAX_SENSORS; 3978 3979 for (i = 0; i < num_sensors; i++) { 3980 u8 sensor_index; 3981 u8 sensor_location; 3982 3983 if (hw->eeprom.ops.read(hw, ets_offset + 1 + i, &ets_sensor)) { 3984 hw_err(hw, "eeprom read at offset %d failed\n", 3985 ets_offset + 1 + i); 3986 continue; 3987 } 3988 sensor_index = ((ets_sensor & IXGBE_ETS_DATA_INDEX_MASK) >> 3989 IXGBE_ETS_DATA_INDEX_SHIFT); 3990 sensor_location = ((ets_sensor & IXGBE_ETS_DATA_LOC_MASK) >> 3991 IXGBE_ETS_DATA_LOC_SHIFT); 3992 therm_limit = ets_sensor & IXGBE_ETS_DATA_HTHRESH_MASK; 3993 3994 hw->phy.ops.write_i2c_byte(hw, 3995 ixgbe_emc_therm_limit[sensor_index], 3996 IXGBE_I2C_THERMAL_SENSOR_ADDR, therm_limit); 3997 3998 if (sensor_location == 0) 3999 continue; 4000 4001 data->sensor[i].location = sensor_location; 4002 data->sensor[i].caution_thresh = therm_limit; 4003 data->sensor[i].max_op_thresh = therm_limit - low_thresh_delta; 4004 } 4005 4006 return 0; 4007 } 4008 4009 /** 4010 * ixgbe_get_orom_version - Return option ROM from EEPROM 4011 * 4012 * @hw: pointer to hardware structure 4013 * @nvm_ver: pointer to output structure 4014 * 4015 * if valid option ROM version, nvm_ver->or_valid set to true 4016 * else nvm_ver->or_valid is false. 4017 **/ 4018 void ixgbe_get_orom_version(struct ixgbe_hw *hw, 4019 struct ixgbe_nvm_version *nvm_ver) 4020 { 4021 u16 offset, eeprom_cfg_blkh, eeprom_cfg_blkl; 4022 4023 nvm_ver->or_valid = false; 4024 /* Option Rom may or may not be present. Start with pointer */ 4025 hw->eeprom.ops.read(hw, NVM_OROM_OFFSET, &offset); 4026 4027 /* make sure offset is valid */ 4028 if (offset == 0x0 || offset == NVM_INVALID_PTR) 4029 return; 4030 4031 hw->eeprom.ops.read(hw, offset + NVM_OROM_BLK_HI, &eeprom_cfg_blkh); 4032 hw->eeprom.ops.read(hw, offset + NVM_OROM_BLK_LOW, &eeprom_cfg_blkl); 4033 4034 /* option rom exists and is valid */ 4035 if ((eeprom_cfg_blkl | eeprom_cfg_blkh) == 0x0 || 4036 eeprom_cfg_blkl == NVM_VER_INVALID || 4037 eeprom_cfg_blkh == NVM_VER_INVALID) 4038 return; 4039 4040 nvm_ver->or_valid = true; 4041 nvm_ver->or_major = eeprom_cfg_blkl >> NVM_OROM_SHIFT; 4042 nvm_ver->or_build = (eeprom_cfg_blkl << NVM_OROM_SHIFT) | 4043 (eeprom_cfg_blkh >> NVM_OROM_SHIFT); 4044 nvm_ver->or_patch = eeprom_cfg_blkh & NVM_OROM_PATCH_MASK; 4045 } 4046 4047 /** 4048 * ixgbe_get_oem_prod_version Etrack ID from EEPROM 4049 * 4050 * @hw: pointer to hardware structure 4051 * @nvm_ver: pointer to output structure 4052 * 4053 * if valid OEM product version, nvm_ver->oem_valid set to true 4054 * else nvm_ver->oem_valid is false. 4055 **/ 4056 void ixgbe_get_oem_prod_version(struct ixgbe_hw *hw, 4057 struct ixgbe_nvm_version *nvm_ver) 4058 { 4059 u16 rel_num, prod_ver, mod_len, cap, offset; 4060 4061 nvm_ver->oem_valid = false; 4062 hw->eeprom.ops.read(hw, NVM_OEM_PROD_VER_PTR, &offset); 4063 4064 /* Return is offset to OEM Product Version block is invalid */ 4065 if (offset == 0x0 || offset == NVM_INVALID_PTR) 4066 return; 4067 4068 /* Read product version block */ 4069 hw->eeprom.ops.read(hw, offset, &mod_len); 4070 hw->eeprom.ops.read(hw, offset + NVM_OEM_PROD_VER_CAP_OFF, &cap); 4071 4072 /* Return if OEM product version block is invalid */ 4073 if (mod_len != NVM_OEM_PROD_VER_MOD_LEN || 4074 (cap & NVM_OEM_PROD_VER_CAP_MASK) != 0x0) 4075 return; 4076 4077 hw->eeprom.ops.read(hw, offset + NVM_OEM_PROD_VER_OFF_L, &prod_ver); 4078 hw->eeprom.ops.read(hw, offset + NVM_OEM_PROD_VER_OFF_H, &rel_num); 4079 4080 /* Return if version is invalid */ 4081 if ((rel_num | prod_ver) == 0x0 || 4082 rel_num == NVM_VER_INVALID || prod_ver == NVM_VER_INVALID) 4083 return; 4084 4085 nvm_ver->oem_major = prod_ver >> NVM_VER_SHIFT; 4086 nvm_ver->oem_minor = prod_ver & NVM_VER_MASK; 4087 nvm_ver->oem_release = rel_num; 4088 nvm_ver->oem_valid = true; 4089 } 4090 4091 /** 4092 * ixgbe_get_etk_id - Return Etrack ID from EEPROM 4093 * 4094 * @hw: pointer to hardware structure 4095 * @nvm_ver: pointer to output structure 4096 * 4097 * word read errors will return 0xFFFF 4098 **/ 4099 void ixgbe_get_etk_id(struct ixgbe_hw *hw, 4100 struct ixgbe_nvm_version *nvm_ver) 4101 { 4102 u16 etk_id_l, etk_id_h; 4103 4104 if (hw->eeprom.ops.read(hw, NVM_ETK_OFF_LOW, &etk_id_l)) 4105 etk_id_l = NVM_VER_INVALID; 4106 if (hw->eeprom.ops.read(hw, NVM_ETK_OFF_HI, &etk_id_h)) 4107 etk_id_h = NVM_VER_INVALID; 4108 4109 /* The word order for the version format is determined by high order 4110 * word bit 15. 4111 */ 4112 if ((etk_id_h & NVM_ETK_VALID) == 0) { 4113 nvm_ver->etk_id = etk_id_h; 4114 nvm_ver->etk_id |= (etk_id_l << NVM_ETK_SHIFT); 4115 } else { 4116 nvm_ver->etk_id = etk_id_l; 4117 nvm_ver->etk_id |= (etk_id_h << NVM_ETK_SHIFT); 4118 } 4119 } 4120 4121 void ixgbe_disable_rx_generic(struct ixgbe_hw *hw) 4122 { 4123 u32 rxctrl; 4124 4125 rxctrl = IXGBE_READ_REG(hw, IXGBE_RXCTRL); 4126 if (rxctrl & IXGBE_RXCTRL_RXEN) { 4127 if (hw->mac.type != ixgbe_mac_82598EB) { 4128 u32 pfdtxgswc; 4129 4130 pfdtxgswc = IXGBE_READ_REG(hw, IXGBE_PFDTXGSWC); 4131 if (pfdtxgswc & IXGBE_PFDTXGSWC_VT_LBEN) { 4132 pfdtxgswc &= ~IXGBE_PFDTXGSWC_VT_LBEN; 4133 IXGBE_WRITE_REG(hw, IXGBE_PFDTXGSWC, pfdtxgswc); 4134 hw->mac.set_lben = true; 4135 } else { 4136 hw->mac.set_lben = false; 4137 } 4138 } 4139 rxctrl &= ~IXGBE_RXCTRL_RXEN; 4140 IXGBE_WRITE_REG(hw, IXGBE_RXCTRL, rxctrl); 4141 } 4142 } 4143 4144 void ixgbe_enable_rx_generic(struct ixgbe_hw *hw) 4145 { 4146 u32 rxctrl; 4147 4148 rxctrl = IXGBE_READ_REG(hw, IXGBE_RXCTRL); 4149 IXGBE_WRITE_REG(hw, IXGBE_RXCTRL, (rxctrl | IXGBE_RXCTRL_RXEN)); 4150 4151 if (hw->mac.type != ixgbe_mac_82598EB) { 4152 if (hw->mac.set_lben) { 4153 u32 pfdtxgswc; 4154 4155 pfdtxgswc = IXGBE_READ_REG(hw, IXGBE_PFDTXGSWC); 4156 pfdtxgswc |= IXGBE_PFDTXGSWC_VT_LBEN; 4157 IXGBE_WRITE_REG(hw, IXGBE_PFDTXGSWC, pfdtxgswc); 4158 hw->mac.set_lben = false; 4159 } 4160 } 4161 } 4162 4163 /** ixgbe_mng_present - returns true when management capability is present 4164 * @hw: pointer to hardware structure 4165 **/ 4166 bool ixgbe_mng_present(struct ixgbe_hw *hw) 4167 { 4168 u32 fwsm; 4169 4170 if (hw->mac.type < ixgbe_mac_82599EB) 4171 return false; 4172 4173 fwsm = IXGBE_READ_REG(hw, IXGBE_FWSM(hw)); 4174 4175 return !!(fwsm & IXGBE_FWSM_FW_MODE_PT); 4176 } 4177 4178 /** 4179 * ixgbe_setup_mac_link_multispeed_fiber - Set MAC link speed 4180 * @hw: pointer to hardware structure 4181 * @speed: new link speed 4182 * @autoneg_wait_to_complete: true when waiting for completion is needed 4183 * 4184 * Set the link speed in the MAC and/or PHY register and restarts link. 4185 */ 4186 s32 ixgbe_setup_mac_link_multispeed_fiber(struct ixgbe_hw *hw, 4187 ixgbe_link_speed speed, 4188 bool autoneg_wait_to_complete) 4189 { 4190 ixgbe_link_speed link_speed = IXGBE_LINK_SPEED_UNKNOWN; 4191 ixgbe_link_speed highest_link_speed = IXGBE_LINK_SPEED_UNKNOWN; 4192 s32 status = 0; 4193 u32 speedcnt = 0; 4194 u32 i = 0; 4195 bool autoneg, link_up = false; 4196 4197 /* Mask off requested but non-supported speeds */ 4198 status = hw->mac.ops.get_link_capabilities(hw, &link_speed, &autoneg); 4199 if (status) 4200 return status; 4201 4202 speed &= link_speed; 4203 4204 /* Try each speed one by one, highest priority first. We do this in 4205 * software because 10Gb fiber doesn't support speed autonegotiation. 4206 */ 4207 if (speed & IXGBE_LINK_SPEED_10GB_FULL) { 4208 speedcnt++; 4209 highest_link_speed = IXGBE_LINK_SPEED_10GB_FULL; 4210 4211 /* Set the module link speed */ 4212 switch (hw->phy.media_type) { 4213 case ixgbe_media_type_fiber: 4214 hw->mac.ops.set_rate_select_speed(hw, 4215 IXGBE_LINK_SPEED_10GB_FULL); 4216 break; 4217 case ixgbe_media_type_fiber_qsfp: 4218 /* QSFP module automatically detects MAC link speed */ 4219 break; 4220 default: 4221 hw_dbg(hw, "Unexpected media type\n"); 4222 break; 4223 } 4224 4225 /* Allow module to change analog characteristics (1G->10G) */ 4226 msleep(40); 4227 4228 status = hw->mac.ops.setup_mac_link(hw, 4229 IXGBE_LINK_SPEED_10GB_FULL, 4230 autoneg_wait_to_complete); 4231 if (status) 4232 return status; 4233 4234 /* Flap the Tx laser if it has not already been done */ 4235 if (hw->mac.ops.flap_tx_laser) 4236 hw->mac.ops.flap_tx_laser(hw); 4237 4238 /* Wait for the controller to acquire link. Per IEEE 802.3ap, 4239 * Section 73.10.2, we may have to wait up to 500ms if KR is 4240 * attempted. 82599 uses the same timing for 10g SFI. 4241 */ 4242 for (i = 0; i < 5; i++) { 4243 /* Wait for the link partner to also set speed */ 4244 msleep(100); 4245 4246 /* If we have link, just jump out */ 4247 status = hw->mac.ops.check_link(hw, &link_speed, 4248 &link_up, false); 4249 if (status) 4250 return status; 4251 4252 if (link_up) 4253 goto out; 4254 } 4255 } 4256 4257 if (speed & IXGBE_LINK_SPEED_1GB_FULL) { 4258 speedcnt++; 4259 if (highest_link_speed == IXGBE_LINK_SPEED_UNKNOWN) 4260 highest_link_speed = IXGBE_LINK_SPEED_1GB_FULL; 4261 4262 /* Set the module link speed */ 4263 switch (hw->phy.media_type) { 4264 case ixgbe_media_type_fiber: 4265 hw->mac.ops.set_rate_select_speed(hw, 4266 IXGBE_LINK_SPEED_1GB_FULL); 4267 break; 4268 case ixgbe_media_type_fiber_qsfp: 4269 /* QSFP module automatically detects link speed */ 4270 break; 4271 default: 4272 hw_dbg(hw, "Unexpected media type\n"); 4273 break; 4274 } 4275 4276 /* Allow module to change analog characteristics (10G->1G) */ 4277 msleep(40); 4278 4279 status = hw->mac.ops.setup_mac_link(hw, 4280 IXGBE_LINK_SPEED_1GB_FULL, 4281 autoneg_wait_to_complete); 4282 if (status) 4283 return status; 4284 4285 /* Flap the Tx laser if it has not already been done */ 4286 if (hw->mac.ops.flap_tx_laser) 4287 hw->mac.ops.flap_tx_laser(hw); 4288 4289 /* Wait for the link partner to also set speed */ 4290 msleep(100); 4291 4292 /* If we have link, just jump out */ 4293 status = hw->mac.ops.check_link(hw, &link_speed, &link_up, 4294 false); 4295 if (status) 4296 return status; 4297 4298 if (link_up) 4299 goto out; 4300 } 4301 4302 /* We didn't get link. Configure back to the highest speed we tried, 4303 * (if there was more than one). We call ourselves back with just the 4304 * single highest speed that the user requested. 4305 */ 4306 if (speedcnt > 1) 4307 status = ixgbe_setup_mac_link_multispeed_fiber(hw, 4308 highest_link_speed, 4309 autoneg_wait_to_complete); 4310 4311 out: 4312 /* Set autoneg_advertised value based on input link speed */ 4313 hw->phy.autoneg_advertised = 0; 4314 4315 if (speed & IXGBE_LINK_SPEED_10GB_FULL) 4316 hw->phy.autoneg_advertised |= IXGBE_LINK_SPEED_10GB_FULL; 4317 4318 if (speed & IXGBE_LINK_SPEED_1GB_FULL) 4319 hw->phy.autoneg_advertised |= IXGBE_LINK_SPEED_1GB_FULL; 4320 4321 return status; 4322 } 4323 4324 /** 4325 * ixgbe_set_soft_rate_select_speed - Set module link speed 4326 * @hw: pointer to hardware structure 4327 * @speed: link speed to set 4328 * 4329 * Set module link speed via the soft rate select. 4330 */ 4331 void ixgbe_set_soft_rate_select_speed(struct ixgbe_hw *hw, 4332 ixgbe_link_speed speed) 4333 { 4334 s32 status; 4335 u8 rs, eeprom_data; 4336 4337 switch (speed) { 4338 case IXGBE_LINK_SPEED_10GB_FULL: 4339 /* one bit mask same as setting on */ 4340 rs = IXGBE_SFF_SOFT_RS_SELECT_10G; 4341 break; 4342 case IXGBE_LINK_SPEED_1GB_FULL: 4343 rs = IXGBE_SFF_SOFT_RS_SELECT_1G; 4344 break; 4345 default: 4346 hw_dbg(hw, "Invalid fixed module speed\n"); 4347 return; 4348 } 4349 4350 /* Set RS0 */ 4351 status = hw->phy.ops.read_i2c_byte(hw, IXGBE_SFF_SFF_8472_OSCB, 4352 IXGBE_I2C_EEPROM_DEV_ADDR2, 4353 &eeprom_data); 4354 if (status) { 4355 hw_dbg(hw, "Failed to read Rx Rate Select RS0\n"); 4356 return; 4357 } 4358 4359 eeprom_data = (eeprom_data & ~IXGBE_SFF_SOFT_RS_SELECT_MASK) | rs; 4360 4361 status = hw->phy.ops.write_i2c_byte(hw, IXGBE_SFF_SFF_8472_OSCB, 4362 IXGBE_I2C_EEPROM_DEV_ADDR2, 4363 eeprom_data); 4364 if (status) { 4365 hw_dbg(hw, "Failed to write Rx Rate Select RS0\n"); 4366 return; 4367 } 4368 4369 /* Set RS1 */ 4370 status = hw->phy.ops.read_i2c_byte(hw, IXGBE_SFF_SFF_8472_ESCB, 4371 IXGBE_I2C_EEPROM_DEV_ADDR2, 4372 &eeprom_data); 4373 if (status) { 4374 hw_dbg(hw, "Failed to read Rx Rate Select RS1\n"); 4375 return; 4376 } 4377 4378 eeprom_data = (eeprom_data & ~IXGBE_SFF_SOFT_RS_SELECT_MASK) | rs; 4379 4380 status = hw->phy.ops.write_i2c_byte(hw, IXGBE_SFF_SFF_8472_ESCB, 4381 IXGBE_I2C_EEPROM_DEV_ADDR2, 4382 eeprom_data); 4383 if (status) { 4384 hw_dbg(hw, "Failed to write Rx Rate Select RS1\n"); 4385 return; 4386 } 4387 } 4388