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