1 /*- 2 * Copyright 2021 Intel Corp 3 * Copyright 2021 Rubicon Communications, LLC (Netgate) 4 * SPDX-License-Identifier: BSD-3-Clause 5 */ 6 7 #include <sys/cdefs.h> 8 __FBSDID("$FreeBSD$"); 9 10 #include "igc_api.h" 11 12 static void igc_config_collision_dist_generic(struct igc_hw *hw); 13 14 /** 15 * igc_init_mac_ops_generic - Initialize MAC function pointers 16 * @hw: pointer to the HW structure 17 * 18 * Setups up the function pointers to no-op functions 19 **/ 20 void igc_init_mac_ops_generic(struct igc_hw *hw) 21 { 22 struct igc_mac_info *mac = &hw->mac; 23 DEBUGFUNC("igc_init_mac_ops_generic"); 24 25 /* General Setup */ 26 mac->ops.init_params = igc_null_ops_generic; 27 mac->ops.config_collision_dist = igc_config_collision_dist_generic; 28 mac->ops.rar_set = igc_rar_set_generic; 29 } 30 31 /** 32 * igc_null_ops_generic - No-op function, returns 0 33 * @hw: pointer to the HW structure 34 **/ 35 s32 igc_null_ops_generic(struct igc_hw IGC_UNUSEDARG *hw) 36 { 37 DEBUGFUNC("igc_null_ops_generic"); 38 return IGC_SUCCESS; 39 } 40 41 /** 42 * igc_null_mac_generic - No-op function, return void 43 * @hw: pointer to the HW structure 44 **/ 45 void igc_null_mac_generic(struct igc_hw IGC_UNUSEDARG *hw) 46 { 47 DEBUGFUNC("igc_null_mac_generic"); 48 return; 49 } 50 51 /** 52 * igc_null_link_info - No-op function, return 0 53 * @hw: pointer to the HW structure 54 * @s: dummy variable 55 * @d: dummy variable 56 **/ 57 s32 igc_null_link_info(struct igc_hw IGC_UNUSEDARG *hw, 58 u16 IGC_UNUSEDARG *s, u16 IGC_UNUSEDARG *d) 59 { 60 DEBUGFUNC("igc_null_link_info"); 61 return IGC_SUCCESS; 62 } 63 64 /** 65 * igc_null_mng_mode - No-op function, return false 66 * @hw: pointer to the HW structure 67 **/ 68 bool igc_null_mng_mode(struct igc_hw IGC_UNUSEDARG *hw) 69 { 70 DEBUGFUNC("igc_null_mng_mode"); 71 return false; 72 } 73 74 /** 75 * igc_null_update_mc - No-op function, return void 76 * @hw: pointer to the HW structure 77 * @h: dummy variable 78 * @a: dummy variable 79 **/ 80 void igc_null_update_mc(struct igc_hw IGC_UNUSEDARG *hw, 81 u8 IGC_UNUSEDARG *h, u32 IGC_UNUSEDARG a) 82 { 83 DEBUGFUNC("igc_null_update_mc"); 84 return; 85 } 86 87 /** 88 * igc_null_write_vfta - No-op function, return void 89 * @hw: pointer to the HW structure 90 * @a: dummy variable 91 * @b: dummy variable 92 **/ 93 void igc_null_write_vfta(struct igc_hw IGC_UNUSEDARG *hw, 94 u32 IGC_UNUSEDARG a, u32 IGC_UNUSEDARG b) 95 { 96 DEBUGFUNC("igc_null_write_vfta"); 97 return; 98 } 99 100 /** 101 * igc_null_rar_set - No-op function, return 0 102 * @hw: pointer to the HW structure 103 * @h: dummy variable 104 * @a: dummy variable 105 **/ 106 int igc_null_rar_set(struct igc_hw IGC_UNUSEDARG *hw, 107 u8 IGC_UNUSEDARG *h, u32 IGC_UNUSEDARG a) 108 { 109 DEBUGFUNC("igc_null_rar_set"); 110 return IGC_SUCCESS; 111 } 112 113 /** 114 * igc_set_lan_id_single_port - Set LAN id for a single port device 115 * @hw: pointer to the HW structure 116 * 117 * Sets the LAN function id to zero for a single port device. 118 **/ 119 void igc_set_lan_id_single_port(struct igc_hw *hw) 120 { 121 struct igc_bus_info *bus = &hw->bus; 122 123 bus->func = 0; 124 } 125 126 /** 127 * igc_clear_vfta_generic - Clear VLAN filter table 128 * @hw: pointer to the HW structure 129 * 130 * Clears the register array which contains the VLAN filter table by 131 * setting all the values to 0. 132 **/ 133 void igc_clear_vfta_generic(struct igc_hw *hw) 134 { 135 u32 offset; 136 137 DEBUGFUNC("igc_clear_vfta_generic"); 138 139 for (offset = 0; offset < IGC_VLAN_FILTER_TBL_SIZE; offset++) { 140 IGC_WRITE_REG_ARRAY(hw, IGC_VFTA, offset, 0); 141 IGC_WRITE_FLUSH(hw); 142 } 143 } 144 145 /** 146 * igc_write_vfta_generic - Write value to VLAN filter table 147 * @hw: pointer to the HW structure 148 * @offset: register offset in VLAN filter table 149 * @value: register value written to VLAN filter table 150 * 151 * Writes value at the given offset in the register array which stores 152 * the VLAN filter table. 153 **/ 154 void igc_write_vfta_generic(struct igc_hw *hw, u32 offset, u32 value) 155 { 156 DEBUGFUNC("igc_write_vfta_generic"); 157 158 IGC_WRITE_REG_ARRAY(hw, IGC_VFTA, offset, value); 159 IGC_WRITE_FLUSH(hw); 160 } 161 162 /** 163 * igc_init_rx_addrs_generic - Initialize receive address's 164 * @hw: pointer to the HW structure 165 * @rar_count: receive address registers 166 * 167 * Setup the receive address registers by setting the base receive address 168 * register to the devices MAC address and clearing all the other receive 169 * address registers to 0. 170 **/ 171 void igc_init_rx_addrs_generic(struct igc_hw *hw, u16 rar_count) 172 { 173 u32 i; 174 u8 mac_addr[ETH_ADDR_LEN] = {0}; 175 176 DEBUGFUNC("igc_init_rx_addrs_generic"); 177 178 /* Setup the receive address */ 179 DEBUGOUT("Programming MAC Address into RAR[0]\n"); 180 181 hw->mac.ops.rar_set(hw, hw->mac.addr, 0); 182 183 /* Zero out the other (rar_entry_count - 1) receive addresses */ 184 DEBUGOUT1("Clearing RAR[1-%u]\n", rar_count-1); 185 for (i = 1; i < rar_count; i++) 186 hw->mac.ops.rar_set(hw, mac_addr, i); 187 } 188 189 /** 190 * igc_check_alt_mac_addr_generic - Check for alternate MAC addr 191 * @hw: pointer to the HW structure 192 * 193 * Checks the nvm for an alternate MAC address. An alternate MAC address 194 * can be setup by pre-boot software and must be treated like a permanent 195 * address and must override the actual permanent MAC address. If an 196 * alternate MAC address is found it is programmed into RAR0, replacing 197 * the permanent address that was installed into RAR0 by the Si on reset. 198 * This function will return SUCCESS unless it encounters an error while 199 * reading the EEPROM. 200 **/ 201 s32 igc_check_alt_mac_addr_generic(struct igc_hw *hw) 202 { 203 u32 i; 204 s32 ret_val; 205 u16 offset, nvm_alt_mac_addr_offset, nvm_data; 206 u8 alt_mac_addr[ETH_ADDR_LEN]; 207 208 DEBUGFUNC("igc_check_alt_mac_addr_generic"); 209 210 ret_val = hw->nvm.ops.read(hw, NVM_COMPAT, 1, &nvm_data); 211 if (ret_val) 212 return ret_val; 213 214 215 ret_val = hw->nvm.ops.read(hw, NVM_ALT_MAC_ADDR_PTR, 1, 216 &nvm_alt_mac_addr_offset); 217 if (ret_val) { 218 DEBUGOUT("NVM Read Error\n"); 219 return ret_val; 220 } 221 222 if ((nvm_alt_mac_addr_offset == 0xFFFF) || 223 (nvm_alt_mac_addr_offset == 0x0000)) 224 /* There is no Alternate MAC Address */ 225 return IGC_SUCCESS; 226 227 if (hw->bus.func == IGC_FUNC_1) 228 nvm_alt_mac_addr_offset += IGC_ALT_MAC_ADDRESS_OFFSET_LAN1; 229 for (i = 0; i < ETH_ADDR_LEN; i += 2) { 230 offset = nvm_alt_mac_addr_offset + (i >> 1); 231 ret_val = hw->nvm.ops.read(hw, offset, 1, &nvm_data); 232 if (ret_val) { 233 DEBUGOUT("NVM Read Error\n"); 234 return ret_val; 235 } 236 237 alt_mac_addr[i] = (u8)(nvm_data & 0xFF); 238 alt_mac_addr[i + 1] = (u8)(nvm_data >> 8); 239 } 240 241 /* if multicast bit is set, the alternate address will not be used */ 242 if (alt_mac_addr[0] & 0x01) { 243 DEBUGOUT("Ignoring Alternate Mac Address with MC bit set\n"); 244 return IGC_SUCCESS; 245 } 246 247 /* We have a valid alternate MAC address, and we want to treat it the 248 * same as the normal permanent MAC address stored by the HW into the 249 * RAR. Do this by mapping this address into RAR0. 250 */ 251 hw->mac.ops.rar_set(hw, alt_mac_addr, 0); 252 253 return IGC_SUCCESS; 254 } 255 256 /** 257 * igc_rar_set_generic - Set receive address register 258 * @hw: pointer to the HW structure 259 * @addr: pointer to the receive address 260 * @index: receive address array register 261 * 262 * Sets the receive address array register at index to the address passed 263 * in by addr. 264 **/ 265 int igc_rar_set_generic(struct igc_hw *hw, u8 *addr, u32 index) 266 { 267 u32 rar_low, rar_high; 268 269 DEBUGFUNC("igc_rar_set_generic"); 270 271 /* HW expects these in little endian so we reverse the byte order 272 * from network order (big endian) to little endian 273 */ 274 rar_low = ((u32) addr[0] | ((u32) addr[1] << 8) | 275 ((u32) addr[2] << 16) | ((u32) addr[3] << 24)); 276 277 rar_high = ((u32) addr[4] | ((u32) addr[5] << 8)); 278 279 /* If MAC address zero, no need to set the AV bit */ 280 if (rar_low || rar_high) 281 rar_high |= IGC_RAH_AV; 282 283 /* Some bridges will combine consecutive 32-bit writes into 284 * a single burst write, which will malfunction on some parts. 285 * The flushes avoid this. 286 */ 287 IGC_WRITE_REG(hw, IGC_RAL(index), rar_low); 288 IGC_WRITE_FLUSH(hw); 289 IGC_WRITE_REG(hw, IGC_RAH(index), rar_high); 290 IGC_WRITE_FLUSH(hw); 291 292 return IGC_SUCCESS; 293 } 294 295 /** 296 * igc_hash_mc_addr_generic - Generate a multicast hash value 297 * @hw: pointer to the HW structure 298 * @mc_addr: pointer to a multicast address 299 * 300 * Generates a multicast address hash value which is used to determine 301 * the multicast filter table array address and new table value. 302 **/ 303 u32 igc_hash_mc_addr_generic(struct igc_hw *hw, u8 *mc_addr) 304 { 305 u32 hash_value, hash_mask; 306 u8 bit_shift = 0; 307 308 DEBUGFUNC("igc_hash_mc_addr_generic"); 309 310 /* Register count multiplied by bits per register */ 311 hash_mask = (hw->mac.mta_reg_count * 32) - 1; 312 313 /* For a mc_filter_type of 0, bit_shift is the number of left-shifts 314 * where 0xFF would still fall within the hash mask. 315 */ 316 while (hash_mask >> bit_shift != 0xFF) 317 bit_shift++; 318 319 /* The portion of the address that is used for the hash table 320 * is determined by the mc_filter_type setting. 321 * The algorithm is such that there is a total of 8 bits of shifting. 322 * The bit_shift for a mc_filter_type of 0 represents the number of 323 * left-shifts where the MSB of mc_addr[5] would still fall within 324 * the hash_mask. Case 0 does this exactly. Since there are a total 325 * of 8 bits of shifting, then mc_addr[4] will shift right the 326 * remaining number of bits. Thus 8 - bit_shift. The rest of the 327 * cases are a variation of this algorithm...essentially raising the 328 * number of bits to shift mc_addr[5] left, while still keeping the 329 * 8-bit shifting total. 330 * 331 * For example, given the following Destination MAC Address and an 332 * mta register count of 128 (thus a 4096-bit vector and 0xFFF mask), 333 * we can see that the bit_shift for case 0 is 4. These are the hash 334 * values resulting from each mc_filter_type... 335 * [0] [1] [2] [3] [4] [5] 336 * 01 AA 00 12 34 56 337 * LSB MSB 338 * 339 * case 0: hash_value = ((0x34 >> 4) | (0x56 << 4)) & 0xFFF = 0x563 340 * case 1: hash_value = ((0x34 >> 3) | (0x56 << 5)) & 0xFFF = 0xAC6 341 * case 2: hash_value = ((0x34 >> 2) | (0x56 << 6)) & 0xFFF = 0x163 342 * case 3: hash_value = ((0x34 >> 0) | (0x56 << 8)) & 0xFFF = 0x634 343 */ 344 switch (hw->mac.mc_filter_type) { 345 default: 346 case 0: 347 break; 348 case 1: 349 bit_shift += 1; 350 break; 351 case 2: 352 bit_shift += 2; 353 break; 354 case 3: 355 bit_shift += 4; 356 break; 357 } 358 359 hash_value = hash_mask & (((mc_addr[4] >> (8 - bit_shift)) | 360 (((u16) mc_addr[5]) << bit_shift))); 361 362 return hash_value; 363 } 364 365 /** 366 * igc_update_mc_addr_list_generic - Update Multicast addresses 367 * @hw: pointer to the HW structure 368 * @mc_addr_list: array of multicast addresses to program 369 * @mc_addr_count: number of multicast addresses to program 370 * 371 * Updates entire Multicast Table Array. 372 * The caller must have a packed mc_addr_list of multicast addresses. 373 **/ 374 void igc_update_mc_addr_list_generic(struct igc_hw *hw, 375 u8 *mc_addr_list, u32 mc_addr_count) 376 { 377 u32 hash_value, hash_bit, hash_reg; 378 int i; 379 380 DEBUGFUNC("igc_update_mc_addr_list_generic"); 381 382 /* clear mta_shadow */ 383 memset(&hw->mac.mta_shadow, 0, sizeof(hw->mac.mta_shadow)); 384 385 /* update mta_shadow from mc_addr_list */ 386 for (i = 0; (u32) i < mc_addr_count; i++) { 387 hash_value = igc_hash_mc_addr_generic(hw, mc_addr_list); 388 389 hash_reg = (hash_value >> 5) & (hw->mac.mta_reg_count - 1); 390 hash_bit = hash_value & 0x1F; 391 392 hw->mac.mta_shadow[hash_reg] |= (1 << hash_bit); 393 mc_addr_list += (ETH_ADDR_LEN); 394 } 395 396 /* replace the entire MTA table */ 397 for (i = hw->mac.mta_reg_count - 1; i >= 0; i--) 398 IGC_WRITE_REG_ARRAY(hw, IGC_MTA, i, hw->mac.mta_shadow[i]); 399 IGC_WRITE_FLUSH(hw); 400 } 401 402 /** 403 * igc_clear_hw_cntrs_base_generic - Clear base hardware counters 404 * @hw: pointer to the HW structure 405 * 406 * Clears the base hardware counters by reading the counter registers. 407 **/ 408 void igc_clear_hw_cntrs_base_generic(struct igc_hw *hw) 409 { 410 DEBUGFUNC("igc_clear_hw_cntrs_base_generic"); 411 412 IGC_READ_REG(hw, IGC_CRCERRS); 413 IGC_READ_REG(hw, IGC_MPC); 414 IGC_READ_REG(hw, IGC_SCC); 415 IGC_READ_REG(hw, IGC_ECOL); 416 IGC_READ_REG(hw, IGC_MCC); 417 IGC_READ_REG(hw, IGC_LATECOL); 418 IGC_READ_REG(hw, IGC_COLC); 419 IGC_READ_REG(hw, IGC_RERC); 420 IGC_READ_REG(hw, IGC_DC); 421 IGC_READ_REG(hw, IGC_RLEC); 422 IGC_READ_REG(hw, IGC_XONRXC); 423 IGC_READ_REG(hw, IGC_XONTXC); 424 IGC_READ_REG(hw, IGC_XOFFRXC); 425 IGC_READ_REG(hw, IGC_XOFFTXC); 426 IGC_READ_REG(hw, IGC_FCRUC); 427 IGC_READ_REG(hw, IGC_GPRC); 428 IGC_READ_REG(hw, IGC_BPRC); 429 IGC_READ_REG(hw, IGC_MPRC); 430 IGC_READ_REG(hw, IGC_GPTC); 431 IGC_READ_REG(hw, IGC_GORCL); 432 IGC_READ_REG(hw, IGC_GORCH); 433 IGC_READ_REG(hw, IGC_GOTCL); 434 IGC_READ_REG(hw, IGC_GOTCH); 435 IGC_READ_REG(hw, IGC_RNBC); 436 IGC_READ_REG(hw, IGC_RUC); 437 IGC_READ_REG(hw, IGC_RFC); 438 IGC_READ_REG(hw, IGC_ROC); 439 IGC_READ_REG(hw, IGC_RJC); 440 IGC_READ_REG(hw, IGC_TORL); 441 IGC_READ_REG(hw, IGC_TORH); 442 IGC_READ_REG(hw, IGC_TOTL); 443 IGC_READ_REG(hw, IGC_TOTH); 444 IGC_READ_REG(hw, IGC_TPR); 445 IGC_READ_REG(hw, IGC_TPT); 446 IGC_READ_REG(hw, IGC_MPTC); 447 IGC_READ_REG(hw, IGC_BPTC); 448 IGC_READ_REG(hw, IGC_TLPIC); 449 IGC_READ_REG(hw, IGC_RLPIC); 450 IGC_READ_REG(hw, IGC_RXDMTC); 451 } 452 453 /** 454 * igc_check_for_copper_link_generic - Check for link (Copper) 455 * @hw: pointer to the HW structure 456 * 457 * Checks to see of the link status of the hardware has changed. If a 458 * change in link status has been detected, then we read the PHY registers 459 * to get the current speed/duplex if link exists. 460 **/ 461 s32 igc_check_for_copper_link_generic(struct igc_hw *hw) 462 { 463 struct igc_mac_info *mac = &hw->mac; 464 s32 ret_val; 465 bool link = false; 466 467 DEBUGFUNC("igc_check_for_copper_link"); 468 469 /* We only want to go out to the PHY registers to see if Auto-Neg 470 * has completed and/or if our link status has changed. The 471 * get_link_status flag is set upon receiving a Link Status 472 * Change or Rx Sequence Error interrupt. 473 */ 474 if (!mac->get_link_status) 475 return IGC_SUCCESS; 476 477 /* First we want to see if the MII Status Register reports 478 * link. If so, then we want to get the current speed/duplex 479 * of the PHY. 480 */ 481 ret_val = igc_phy_has_link_generic(hw, 1, 0, &link); 482 if (ret_val) 483 return ret_val; 484 485 if (!link) 486 return IGC_SUCCESS; /* No link detected */ 487 488 mac->get_link_status = false; 489 490 /* Check if there was DownShift, must be checked 491 * immediately after link-up 492 */ 493 igc_check_downshift_generic(hw); 494 495 /* If we are forcing speed/duplex, then we simply return since 496 * we have already determined whether we have link or not. 497 */ 498 if (!mac->autoneg) 499 return -IGC_ERR_CONFIG; 500 501 /* Auto-Neg is enabled. Auto Speed Detection takes care 502 * of MAC speed/duplex configuration. So we only need to 503 * configure Collision Distance in the MAC. 504 */ 505 mac->ops.config_collision_dist(hw); 506 507 /* Configure Flow Control now that Auto-Neg has completed. 508 * First, we need to restore the desired flow control 509 * settings because we may have had to re-autoneg with a 510 * different link partner. 511 */ 512 ret_val = igc_config_fc_after_link_up_generic(hw); 513 if (ret_val) 514 DEBUGOUT("Error configuring flow control\n"); 515 516 return ret_val; 517 } 518 519 /** 520 * igc_setup_link_generic - Setup flow control and link settings 521 * @hw: pointer to the HW structure 522 * 523 * Determines which flow control settings to use, then configures flow 524 * control. Calls the appropriate media-specific link configuration 525 * function. Assuming the adapter has a valid link partner, a valid link 526 * should be established. Assumes the hardware has previously been reset 527 * and the transmitter and receiver are not enabled. 528 **/ 529 s32 igc_setup_link_generic(struct igc_hw *hw) 530 { 531 s32 ret_val; 532 533 DEBUGFUNC("igc_setup_link_generic"); 534 535 /* In the case of the phy reset being blocked, we already have a link. 536 * We do not need to set it up again. 537 */ 538 if (hw->phy.ops.check_reset_block && hw->phy.ops.check_reset_block(hw)) 539 return IGC_SUCCESS; 540 541 /* If requested flow control is set to default, set flow control 542 * for both 'rx' and 'tx' pause frames. 543 */ 544 if (hw->fc.requested_mode == igc_fc_default) { 545 hw->fc.requested_mode = igc_fc_full; 546 } 547 548 /* Save off the requested flow control mode for use later. Depending 549 * on the link partner's capabilities, we may or may not use this mode. 550 */ 551 hw->fc.current_mode = hw->fc.requested_mode; 552 553 DEBUGOUT1("After fix-ups FlowControl is now = %x\n", 554 hw->fc.current_mode); 555 556 /* Call the necessary media_type subroutine to configure the link. */ 557 ret_val = hw->mac.ops.setup_physical_interface(hw); 558 if (ret_val) 559 return ret_val; 560 561 /* Initialize the flow control address, type, and PAUSE timer 562 * registers to their default values. This is done even if flow 563 * control is disabled, because it does not hurt anything to 564 * initialize these registers. 565 */ 566 DEBUGOUT("Initializing the Flow Control address, type and timer regs\n"); 567 IGC_WRITE_REG(hw, IGC_FCT, FLOW_CONTROL_TYPE); 568 IGC_WRITE_REG(hw, IGC_FCAH, FLOW_CONTROL_ADDRESS_HIGH); 569 IGC_WRITE_REG(hw, IGC_FCAL, FLOW_CONTROL_ADDRESS_LOW); 570 571 IGC_WRITE_REG(hw, IGC_FCTTV, hw->fc.pause_time); 572 573 return igc_set_fc_watermarks_generic(hw); 574 } 575 576 /** 577 * igc_config_collision_dist_generic - Configure collision distance 578 * @hw: pointer to the HW structure 579 * 580 * Configures the collision distance to the default value and is used 581 * during link setup. 582 **/ 583 static void igc_config_collision_dist_generic(struct igc_hw *hw) 584 { 585 u32 tctl; 586 587 DEBUGFUNC("igc_config_collision_dist_generic"); 588 589 tctl = IGC_READ_REG(hw, IGC_TCTL); 590 591 tctl &= ~IGC_TCTL_COLD; 592 tctl |= IGC_COLLISION_DISTANCE << IGC_COLD_SHIFT; 593 594 IGC_WRITE_REG(hw, IGC_TCTL, tctl); 595 IGC_WRITE_FLUSH(hw); 596 } 597 598 /** 599 * igc_set_fc_watermarks_generic - Set flow control high/low watermarks 600 * @hw: pointer to the HW structure 601 * 602 * Sets the flow control high/low threshold (watermark) registers. If 603 * flow control XON frame transmission is enabled, then set XON frame 604 * transmission as well. 605 **/ 606 s32 igc_set_fc_watermarks_generic(struct igc_hw *hw) 607 { 608 u32 fcrtl = 0, fcrth = 0; 609 610 DEBUGFUNC("igc_set_fc_watermarks_generic"); 611 612 /* Set the flow control receive threshold registers. Normally, 613 * these registers will be set to a default threshold that may be 614 * adjusted later by the driver's runtime code. However, if the 615 * ability to transmit pause frames is not enabled, then these 616 * registers will be set to 0. 617 */ 618 if (hw->fc.current_mode & igc_fc_tx_pause) { 619 /* We need to set up the Receive Threshold high and low water 620 * marks as well as (optionally) enabling the transmission of 621 * XON frames. 622 */ 623 fcrtl = hw->fc.low_water; 624 if (hw->fc.send_xon) 625 fcrtl |= IGC_FCRTL_XONE; 626 627 fcrth = hw->fc.high_water; 628 } 629 IGC_WRITE_REG(hw, IGC_FCRTL, fcrtl); 630 IGC_WRITE_REG(hw, IGC_FCRTH, fcrth); 631 632 return IGC_SUCCESS; 633 } 634 635 /** 636 * igc_force_mac_fc_generic - Force the MAC's flow control settings 637 * @hw: pointer to the HW structure 638 * 639 * Force the MAC's flow control settings. Sets the TFCE and RFCE bits in the 640 * device control register to reflect the adapter settings. TFCE and RFCE 641 * need to be explicitly set by software when a copper PHY is used because 642 * autonegotiation is managed by the PHY rather than the MAC. Software must 643 * also configure these bits when link is forced on a fiber connection. 644 **/ 645 s32 igc_force_mac_fc_generic(struct igc_hw *hw) 646 { 647 u32 ctrl; 648 649 DEBUGFUNC("igc_force_mac_fc_generic"); 650 651 ctrl = IGC_READ_REG(hw, IGC_CTRL); 652 653 /* Because we didn't get link via the internal auto-negotiation 654 * mechanism (we either forced link or we got link via PHY 655 * auto-neg), we have to manually enable/disable transmit an 656 * receive flow control. 657 * 658 * The "Case" statement below enables/disable flow control 659 * according to the "hw->fc.current_mode" parameter. 660 * 661 * The possible values of the "fc" parameter are: 662 * 0: Flow control is completely disabled 663 * 1: Rx flow control is enabled (we can receive pause 664 * frames but not send pause frames). 665 * 2: Tx flow control is enabled (we can send pause frames 666 * frames but we do not receive pause frames). 667 * 3: Both Rx and Tx flow control (symmetric) is enabled. 668 * other: No other values should be possible at this point. 669 */ 670 DEBUGOUT1("hw->fc.current_mode = %u\n", hw->fc.current_mode); 671 672 switch (hw->fc.current_mode) { 673 case igc_fc_none: 674 ctrl &= (~(IGC_CTRL_TFCE | IGC_CTRL_RFCE)); 675 break; 676 case igc_fc_rx_pause: 677 ctrl &= (~IGC_CTRL_TFCE); 678 ctrl |= IGC_CTRL_RFCE; 679 break; 680 case igc_fc_tx_pause: 681 ctrl &= (~IGC_CTRL_RFCE); 682 ctrl |= IGC_CTRL_TFCE; 683 break; 684 case igc_fc_full: 685 ctrl |= (IGC_CTRL_TFCE | IGC_CTRL_RFCE); 686 break; 687 default: 688 DEBUGOUT("Flow control param set incorrectly\n"); 689 return -IGC_ERR_CONFIG; 690 } 691 692 IGC_WRITE_REG(hw, IGC_CTRL, ctrl); 693 694 return IGC_SUCCESS; 695 } 696 697 /** 698 * igc_config_fc_after_link_up_generic - Configures flow control after link 699 * @hw: pointer to the HW structure 700 * 701 * Checks the status of auto-negotiation after link up to ensure that the 702 * speed and duplex were not forced. If the link needed to be forced, then 703 * flow control needs to be forced also. If auto-negotiation is enabled 704 * and did not fail, then we configure flow control based on our link 705 * partner. 706 **/ 707 s32 igc_config_fc_after_link_up_generic(struct igc_hw *hw) 708 { 709 struct igc_mac_info *mac = &hw->mac; 710 s32 ret_val = IGC_SUCCESS; 711 u16 mii_status_reg, mii_nway_adv_reg, mii_nway_lp_ability_reg; 712 u16 speed, duplex; 713 714 DEBUGFUNC("igc_config_fc_after_link_up_generic"); 715 716 if (ret_val) { 717 DEBUGOUT("Error forcing flow control settings\n"); 718 return ret_val; 719 } 720 721 /* Check for the case where we have copper media and auto-neg is 722 * enabled. In this case, we need to check and see if Auto-Neg 723 * has completed, and if so, how the PHY and link partner has 724 * flow control configured. 725 */ 726 if (mac->autoneg) { 727 /* Read the MII Status Register and check to see if AutoNeg 728 * has completed. We read this twice because this reg has 729 * some "sticky" (latched) bits. 730 */ 731 ret_val = hw->phy.ops.read_reg(hw, PHY_STATUS, &mii_status_reg); 732 if (ret_val) 733 return ret_val; 734 ret_val = hw->phy.ops.read_reg(hw, PHY_STATUS, &mii_status_reg); 735 if (ret_val) 736 return ret_val; 737 738 if (!(mii_status_reg & MII_SR_AUTONEG_COMPLETE)) { 739 DEBUGOUT("Copper PHY and Auto Neg has not completed.\n"); 740 return ret_val; 741 } 742 743 /* The AutoNeg process has completed, so we now need to 744 * read both the Auto Negotiation Advertisement 745 * Register (Address 4) and the Auto_Negotiation Base 746 * Page Ability Register (Address 5) to determine how 747 * flow control was negotiated. 748 */ 749 ret_val = hw->phy.ops.read_reg(hw, PHY_AUTONEG_ADV, 750 &mii_nway_adv_reg); 751 if (ret_val) 752 return ret_val; 753 ret_val = hw->phy.ops.read_reg(hw, PHY_LP_ABILITY, 754 &mii_nway_lp_ability_reg); 755 if (ret_val) 756 return ret_val; 757 758 /* Two bits in the Auto Negotiation Advertisement Register 759 * (Address 4) and two bits in the Auto Negotiation Base 760 * Page Ability Register (Address 5) determine flow control 761 * for both the PHY and the link partner. The following 762 * table, taken out of the IEEE 802.3ab/D6.0 dated March 25, 763 * 1999, describes these PAUSE resolution bits and how flow 764 * control is determined based upon these settings. 765 * NOTE: DC = Don't Care 766 * 767 * LOCAL DEVICE | LINK PARTNER 768 * PAUSE | ASM_DIR | PAUSE | ASM_DIR | NIC Resolution 769 *-------|---------|-------|---------|-------------------- 770 * 0 | 0 | DC | DC | igc_fc_none 771 * 0 | 1 | 0 | DC | igc_fc_none 772 * 0 | 1 | 1 | 0 | igc_fc_none 773 * 0 | 1 | 1 | 1 | igc_fc_tx_pause 774 * 1 | 0 | 0 | DC | igc_fc_none 775 * 1 | DC | 1 | DC | igc_fc_full 776 * 1 | 1 | 0 | 0 | igc_fc_none 777 * 1 | 1 | 0 | 1 | igc_fc_rx_pause 778 * 779 * Are both PAUSE bits set to 1? If so, this implies 780 * Symmetric Flow Control is enabled at both ends. The 781 * ASM_DIR bits are irrelevant per the spec. 782 * 783 * For Symmetric Flow Control: 784 * 785 * LOCAL DEVICE | LINK PARTNER 786 * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result 787 *-------|---------|-------|---------|-------------------- 788 * 1 | DC | 1 | DC | IGC_fc_full 789 * 790 */ 791 if ((mii_nway_adv_reg & NWAY_AR_PAUSE) && 792 (mii_nway_lp_ability_reg & NWAY_LPAR_PAUSE)) { 793 /* Now we need to check if the user selected Rx ONLY 794 * of pause frames. In this case, we had to advertise 795 * FULL flow control because we could not advertise Rx 796 * ONLY. Hence, we must now check to see if we need to 797 * turn OFF the TRANSMISSION of PAUSE frames. 798 */ 799 if (hw->fc.requested_mode == igc_fc_full) { 800 hw->fc.current_mode = igc_fc_full; 801 DEBUGOUT("Flow Control = FULL.\n"); 802 } else { 803 hw->fc.current_mode = igc_fc_rx_pause; 804 DEBUGOUT("Flow Control = Rx PAUSE frames only.\n"); 805 } 806 } 807 /* For receiving PAUSE frames ONLY. 808 * 809 * LOCAL DEVICE | LINK PARTNER 810 * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result 811 *-------|---------|-------|---------|-------------------- 812 * 0 | 1 | 1 | 1 | igc_fc_tx_pause 813 */ 814 else if (!(mii_nway_adv_reg & NWAY_AR_PAUSE) && 815 (mii_nway_adv_reg & NWAY_AR_ASM_DIR) && 816 (mii_nway_lp_ability_reg & NWAY_LPAR_PAUSE) && 817 (mii_nway_lp_ability_reg & NWAY_LPAR_ASM_DIR)) { 818 hw->fc.current_mode = igc_fc_tx_pause; 819 DEBUGOUT("Flow Control = Tx PAUSE frames only.\n"); 820 } 821 /* For transmitting PAUSE frames ONLY. 822 * 823 * LOCAL DEVICE | LINK PARTNER 824 * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result 825 *-------|---------|-------|---------|-------------------- 826 * 1 | 1 | 0 | 1 | igc_fc_rx_pause 827 */ 828 else if ((mii_nway_adv_reg & NWAY_AR_PAUSE) && 829 (mii_nway_adv_reg & NWAY_AR_ASM_DIR) && 830 !(mii_nway_lp_ability_reg & NWAY_LPAR_PAUSE) && 831 (mii_nway_lp_ability_reg & NWAY_LPAR_ASM_DIR)) { 832 hw->fc.current_mode = igc_fc_rx_pause; 833 DEBUGOUT("Flow Control = Rx PAUSE frames only.\n"); 834 } else { 835 /* Per the IEEE spec, at this point flow control 836 * should be disabled. 837 */ 838 hw->fc.current_mode = igc_fc_none; 839 DEBUGOUT("Flow Control = NONE.\n"); 840 } 841 842 /* Now we need to do one last check... If we auto- 843 * negotiated to HALF DUPLEX, flow control should not be 844 * enabled per IEEE 802.3 spec. 845 */ 846 ret_val = mac->ops.get_link_up_info(hw, &speed, &duplex); 847 if (ret_val) { 848 DEBUGOUT("Error getting link speed and duplex\n"); 849 return ret_val; 850 } 851 852 if (duplex == HALF_DUPLEX) 853 hw->fc.current_mode = igc_fc_none; 854 855 /* Now we call a subroutine to actually force the MAC 856 * controller to use the correct flow control settings. 857 */ 858 ret_val = igc_force_mac_fc_generic(hw); 859 if (ret_val) { 860 DEBUGOUT("Error forcing flow control settings\n"); 861 return ret_val; 862 } 863 } 864 865 return IGC_SUCCESS; 866 } 867 868 /** 869 * igc_get_speed_and_duplex_copper_generic - Retrieve current speed/duplex 870 * @hw: pointer to the HW structure 871 * @speed: stores the current speed 872 * @duplex: stores the current duplex 873 * 874 * Read the status register for the current speed/duplex and store the current 875 * speed and duplex for copper connections. 876 **/ 877 s32 igc_get_speed_and_duplex_copper_generic(struct igc_hw *hw, u16 *speed, 878 u16 *duplex) 879 { 880 u32 status; 881 882 DEBUGFUNC("igc_get_speed_and_duplex_copper_generic"); 883 884 status = IGC_READ_REG(hw, IGC_STATUS); 885 if (status & IGC_STATUS_SPEED_1000) { 886 /* For I225, STATUS will indicate 1G speed in both 1 Gbps 887 * and 2.5 Gbps link modes. An additional bit is used 888 * to differentiate between 1 Gbps and 2.5 Gbps. 889 */ 890 if ((hw->mac.type == igc_i225) && 891 (status & IGC_STATUS_SPEED_2500)) { 892 *speed = SPEED_2500; 893 DEBUGOUT("2500 Mbs, "); 894 } else { 895 *speed = SPEED_1000; 896 DEBUGOUT("1000 Mbs, "); 897 } 898 } else if (status & IGC_STATUS_SPEED_100) { 899 *speed = SPEED_100; 900 DEBUGOUT("100 Mbs, "); 901 } else { 902 *speed = SPEED_10; 903 DEBUGOUT("10 Mbs, "); 904 } 905 906 if (status & IGC_STATUS_FD) { 907 *duplex = FULL_DUPLEX; 908 DEBUGOUT("Full Duplex\n"); 909 } else { 910 *duplex = HALF_DUPLEX; 911 DEBUGOUT("Half Duplex\n"); 912 } 913 914 return IGC_SUCCESS; 915 } 916 917 /** 918 * igc_get_hw_semaphore_generic - Acquire hardware semaphore 919 * @hw: pointer to the HW structure 920 * 921 * Acquire the HW semaphore to access the PHY or NVM 922 **/ 923 s32 igc_get_hw_semaphore_generic(struct igc_hw *hw) 924 { 925 u32 swsm; 926 s32 timeout = hw->nvm.word_size + 1; 927 s32 i = 0; 928 929 DEBUGFUNC("igc_get_hw_semaphore_generic"); 930 931 /* Get the SW semaphore */ 932 while (i < timeout) { 933 swsm = IGC_READ_REG(hw, IGC_SWSM); 934 if (!(swsm & IGC_SWSM_SMBI)) 935 break; 936 937 usec_delay(50); 938 i++; 939 } 940 941 if (i == timeout) { 942 DEBUGOUT("Driver can't access device - SMBI bit is set.\n"); 943 return -IGC_ERR_NVM; 944 } 945 946 /* Get the FW semaphore. */ 947 for (i = 0; i < timeout; i++) { 948 swsm = IGC_READ_REG(hw, IGC_SWSM); 949 IGC_WRITE_REG(hw, IGC_SWSM, swsm | IGC_SWSM_SWESMBI); 950 951 /* Semaphore acquired if bit latched */ 952 if (IGC_READ_REG(hw, IGC_SWSM) & IGC_SWSM_SWESMBI) 953 break; 954 955 usec_delay(50); 956 } 957 958 if (i == timeout) { 959 /* Release semaphores */ 960 igc_put_hw_semaphore_generic(hw); 961 DEBUGOUT("Driver can't access the NVM\n"); 962 return -IGC_ERR_NVM; 963 } 964 965 return IGC_SUCCESS; 966 } 967 968 /** 969 * igc_put_hw_semaphore_generic - Release hardware semaphore 970 * @hw: pointer to the HW structure 971 * 972 * Release hardware semaphore used to access the PHY or NVM 973 **/ 974 void igc_put_hw_semaphore_generic(struct igc_hw *hw) 975 { 976 u32 swsm; 977 978 DEBUGFUNC("igc_put_hw_semaphore_generic"); 979 980 swsm = IGC_READ_REG(hw, IGC_SWSM); 981 982 swsm &= ~(IGC_SWSM_SMBI | IGC_SWSM_SWESMBI); 983 984 IGC_WRITE_REG(hw, IGC_SWSM, swsm); 985 } 986 987 /** 988 * igc_get_auto_rd_done_generic - Check for auto read completion 989 * @hw: pointer to the HW structure 990 * 991 * Check EEPROM for Auto Read done bit. 992 **/ 993 s32 igc_get_auto_rd_done_generic(struct igc_hw *hw) 994 { 995 s32 i = 0; 996 997 DEBUGFUNC("igc_get_auto_rd_done_generic"); 998 999 while (i < AUTO_READ_DONE_TIMEOUT) { 1000 if (IGC_READ_REG(hw, IGC_EECD) & IGC_EECD_AUTO_RD) 1001 break; 1002 msec_delay(1); 1003 i++; 1004 } 1005 1006 if (i == AUTO_READ_DONE_TIMEOUT) { 1007 DEBUGOUT("Auto read by HW from NVM has not completed.\n"); 1008 return -IGC_ERR_RESET; 1009 } 1010 1011 return IGC_SUCCESS; 1012 } 1013 1014 /** 1015 * igc_disable_pcie_master_generic - Disables PCI-express master access 1016 * @hw: pointer to the HW structure 1017 * 1018 * Returns IGC_SUCCESS if successful, else returns -10 1019 * (-IGC_ERR_MASTER_REQUESTS_PENDING) if master disable bit has not caused 1020 * the master requests to be disabled. 1021 * 1022 * Disables PCI-Express master access and verifies there are no pending 1023 * requests. 1024 **/ 1025 s32 igc_disable_pcie_master_generic(struct igc_hw *hw) 1026 { 1027 u32 ctrl; 1028 s32 timeout = MASTER_DISABLE_TIMEOUT; 1029 1030 DEBUGFUNC("igc_disable_pcie_master_generic"); 1031 1032 ctrl = IGC_READ_REG(hw, IGC_CTRL); 1033 ctrl |= IGC_CTRL_GIO_MASTER_DISABLE; 1034 IGC_WRITE_REG(hw, IGC_CTRL, ctrl); 1035 1036 while (timeout) { 1037 if (!(IGC_READ_REG(hw, IGC_STATUS) & 1038 IGC_STATUS_GIO_MASTER_ENABLE)) 1039 break; 1040 usec_delay(100); 1041 timeout--; 1042 } 1043 1044 if (!timeout) { 1045 DEBUGOUT("Master requests are pending.\n"); 1046 return -IGC_ERR_MASTER_REQUESTS_PENDING; 1047 } 1048 1049 return IGC_SUCCESS; 1050 } 1051