1 /****************************************************************************** 2 SPDX-License-Identifier: BSD-3-Clause 3 4 Copyright (c) 2001-2015, Intel Corporation 5 All rights reserved. 6 7 Redistribution and use in source and binary forms, with or without 8 modification, are permitted provided that the following conditions are met: 9 10 1. Redistributions of source code must retain the above copyright notice, 11 this list of conditions and the following disclaimer. 12 13 2. Redistributions in binary form must reproduce the above copyright 14 notice, this list of conditions and the following disclaimer in the 15 documentation and/or other materials provided with the distribution. 16 17 3. Neither the name of the Intel Corporation nor the names of its 18 contributors may be used to endorse or promote products derived from 19 this software without specific prior written permission. 20 21 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 22 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 23 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 24 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 25 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 26 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 27 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 28 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 29 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 30 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 31 POSSIBILITY OF SUCH DAMAGE. 32 33 ******************************************************************************/ 34 /*$FreeBSD$*/ 35 36 #include "e1000_api.h" 37 38 static s32 e1000_validate_mdi_setting_generic(struct e1000_hw *hw); 39 static void e1000_set_lan_id_multi_port_pcie(struct e1000_hw *hw); 40 static void e1000_config_collision_dist_generic(struct e1000_hw *hw); 41 static int e1000_rar_set_generic(struct e1000_hw *hw, u8 *addr, u32 index); 42 43 /** 44 * e1000_init_mac_ops_generic - Initialize MAC function pointers 45 * @hw: pointer to the HW structure 46 * 47 * Setups up the function pointers to no-op functions 48 **/ 49 void e1000_init_mac_ops_generic(struct e1000_hw *hw) 50 { 51 struct e1000_mac_info *mac = &hw->mac; 52 DEBUGFUNC("e1000_init_mac_ops_generic"); 53 54 /* General Setup */ 55 mac->ops.init_params = e1000_null_ops_generic; 56 mac->ops.init_hw = e1000_null_ops_generic; 57 mac->ops.reset_hw = e1000_null_ops_generic; 58 mac->ops.setup_physical_interface = e1000_null_ops_generic; 59 mac->ops.get_bus_info = e1000_null_ops_generic; 60 mac->ops.set_lan_id = e1000_set_lan_id_multi_port_pcie; 61 mac->ops.read_mac_addr = e1000_read_mac_addr_generic; 62 mac->ops.config_collision_dist = e1000_config_collision_dist_generic; 63 mac->ops.clear_hw_cntrs = e1000_null_mac_generic; 64 /* LED */ 65 mac->ops.cleanup_led = e1000_null_ops_generic; 66 mac->ops.setup_led = e1000_null_ops_generic; 67 mac->ops.blink_led = e1000_null_ops_generic; 68 mac->ops.led_on = e1000_null_ops_generic; 69 mac->ops.led_off = e1000_null_ops_generic; 70 /* LINK */ 71 mac->ops.setup_link = e1000_null_ops_generic; 72 mac->ops.get_link_up_info = e1000_null_link_info; 73 mac->ops.check_for_link = e1000_null_ops_generic; 74 mac->ops.set_obff_timer = e1000_null_set_obff_timer; 75 /* Management */ 76 mac->ops.check_mng_mode = e1000_null_mng_mode; 77 /* VLAN, MC, etc. */ 78 mac->ops.update_mc_addr_list = e1000_null_update_mc; 79 mac->ops.clear_vfta = e1000_null_mac_generic; 80 mac->ops.write_vfta = e1000_null_write_vfta; 81 mac->ops.rar_set = e1000_rar_set_generic; 82 mac->ops.validate_mdi_setting = e1000_validate_mdi_setting_generic; 83 } 84 85 /** 86 * e1000_null_ops_generic - No-op function, returns 0 87 * @hw: pointer to the HW structure 88 **/ 89 s32 e1000_null_ops_generic(struct e1000_hw E1000_UNUSEDARG *hw) 90 { 91 DEBUGFUNC("e1000_null_ops_generic"); 92 return E1000_SUCCESS; 93 } 94 95 /** 96 * e1000_null_mac_generic - No-op function, return void 97 * @hw: pointer to the HW structure 98 **/ 99 void e1000_null_mac_generic(struct e1000_hw E1000_UNUSEDARG *hw) 100 { 101 DEBUGFUNC("e1000_null_mac_generic"); 102 return; 103 } 104 105 /** 106 * e1000_null_link_info - No-op function, return 0 107 * @hw: pointer to the HW structure 108 **/ 109 s32 e1000_null_link_info(struct e1000_hw E1000_UNUSEDARG *hw, 110 u16 E1000_UNUSEDARG *s, u16 E1000_UNUSEDARG *d) 111 { 112 DEBUGFUNC("e1000_null_link_info"); 113 return E1000_SUCCESS; 114 } 115 116 /** 117 * e1000_null_mng_mode - No-op function, return FALSE 118 * @hw: pointer to the HW structure 119 **/ 120 bool e1000_null_mng_mode(struct e1000_hw E1000_UNUSEDARG *hw) 121 { 122 DEBUGFUNC("e1000_null_mng_mode"); 123 return FALSE; 124 } 125 126 /** 127 * e1000_null_update_mc - No-op function, return void 128 * @hw: pointer to the HW structure 129 **/ 130 void e1000_null_update_mc(struct e1000_hw E1000_UNUSEDARG *hw, 131 u8 E1000_UNUSEDARG *h, u32 E1000_UNUSEDARG a) 132 { 133 DEBUGFUNC("e1000_null_update_mc"); 134 return; 135 } 136 137 /** 138 * e1000_null_write_vfta - No-op function, return void 139 * @hw: pointer to the HW structure 140 **/ 141 void e1000_null_write_vfta(struct e1000_hw E1000_UNUSEDARG *hw, 142 u32 E1000_UNUSEDARG a, u32 E1000_UNUSEDARG b) 143 { 144 DEBUGFUNC("e1000_null_write_vfta"); 145 return; 146 } 147 148 /** 149 * e1000_null_rar_set - No-op function, return 0 150 * @hw: pointer to the HW structure 151 **/ 152 int e1000_null_rar_set(struct e1000_hw E1000_UNUSEDARG *hw, 153 u8 E1000_UNUSEDARG *h, u32 E1000_UNUSEDARG a) 154 { 155 DEBUGFUNC("e1000_null_rar_set"); 156 return E1000_SUCCESS; 157 } 158 159 /** 160 * e1000_null_set_obff_timer - No-op function, return 0 161 * @hw: pointer to the HW structure 162 **/ 163 s32 e1000_null_set_obff_timer(struct e1000_hw E1000_UNUSEDARG *hw, 164 u32 E1000_UNUSEDARG a) 165 { 166 DEBUGFUNC("e1000_null_set_obff_timer"); 167 return E1000_SUCCESS; 168 } 169 170 /** 171 * e1000_get_bus_info_pci_generic - Get PCI(x) bus information 172 * @hw: pointer to the HW structure 173 * 174 * Determines and stores the system bus information for a particular 175 * network interface. The following bus information is determined and stored: 176 * bus speed, bus width, type (PCI/PCIx), and PCI(-x) function. 177 **/ 178 s32 e1000_get_bus_info_pci_generic(struct e1000_hw *hw) 179 { 180 struct e1000_mac_info *mac = &hw->mac; 181 struct e1000_bus_info *bus = &hw->bus; 182 u32 status = E1000_READ_REG(hw, E1000_STATUS); 183 s32 ret_val = E1000_SUCCESS; 184 185 DEBUGFUNC("e1000_get_bus_info_pci_generic"); 186 187 /* PCI or PCI-X? */ 188 bus->type = (status & E1000_STATUS_PCIX_MODE) 189 ? e1000_bus_type_pcix 190 : e1000_bus_type_pci; 191 192 /* Bus speed */ 193 if (bus->type == e1000_bus_type_pci) { 194 bus->speed = (status & E1000_STATUS_PCI66) 195 ? e1000_bus_speed_66 196 : e1000_bus_speed_33; 197 } else { 198 switch (status & E1000_STATUS_PCIX_SPEED) { 199 case E1000_STATUS_PCIX_SPEED_66: 200 bus->speed = e1000_bus_speed_66; 201 break; 202 case E1000_STATUS_PCIX_SPEED_100: 203 bus->speed = e1000_bus_speed_100; 204 break; 205 case E1000_STATUS_PCIX_SPEED_133: 206 bus->speed = e1000_bus_speed_133; 207 break; 208 default: 209 bus->speed = e1000_bus_speed_reserved; 210 break; 211 } 212 } 213 214 /* Bus width */ 215 bus->width = (status & E1000_STATUS_BUS64) 216 ? e1000_bus_width_64 217 : e1000_bus_width_32; 218 219 /* Which PCI(-X) function? */ 220 mac->ops.set_lan_id(hw); 221 222 return ret_val; 223 } 224 225 /** 226 * e1000_get_bus_info_pcie_generic - Get PCIe bus information 227 * @hw: pointer to the HW structure 228 * 229 * Determines and stores the system bus information for a particular 230 * network interface. The following bus information is determined and stored: 231 * bus speed, bus width, type (PCIe), and PCIe function. 232 **/ 233 s32 e1000_get_bus_info_pcie_generic(struct e1000_hw *hw) 234 { 235 struct e1000_mac_info *mac = &hw->mac; 236 struct e1000_bus_info *bus = &hw->bus; 237 s32 ret_val; 238 u16 pcie_link_status; 239 240 DEBUGFUNC("e1000_get_bus_info_pcie_generic"); 241 242 bus->type = e1000_bus_type_pci_express; 243 244 ret_val = e1000_read_pcie_cap_reg(hw, PCIE_LINK_STATUS, 245 &pcie_link_status); 246 if (ret_val) { 247 bus->width = e1000_bus_width_unknown; 248 bus->speed = e1000_bus_speed_unknown; 249 } else { 250 switch (pcie_link_status & PCIE_LINK_SPEED_MASK) { 251 case PCIE_LINK_SPEED_2500: 252 bus->speed = e1000_bus_speed_2500; 253 break; 254 case PCIE_LINK_SPEED_5000: 255 bus->speed = e1000_bus_speed_5000; 256 break; 257 default: 258 bus->speed = e1000_bus_speed_unknown; 259 break; 260 } 261 262 bus->width = (enum e1000_bus_width)((pcie_link_status & 263 PCIE_LINK_WIDTH_MASK) >> PCIE_LINK_WIDTH_SHIFT); 264 } 265 266 mac->ops.set_lan_id(hw); 267 268 return E1000_SUCCESS; 269 } 270 271 /** 272 * e1000_set_lan_id_multi_port_pcie - Set LAN id for PCIe multiple port devices 273 * 274 * @hw: pointer to the HW structure 275 * 276 * Determines the LAN function id by reading memory-mapped registers 277 * and swaps the port value if requested. 278 **/ 279 static void e1000_set_lan_id_multi_port_pcie(struct e1000_hw *hw) 280 { 281 struct e1000_bus_info *bus = &hw->bus; 282 u32 reg; 283 284 /* The status register reports the correct function number 285 * for the device regardless of function swap state. 286 */ 287 reg = E1000_READ_REG(hw, E1000_STATUS); 288 bus->func = (reg & E1000_STATUS_FUNC_MASK) >> E1000_STATUS_FUNC_SHIFT; 289 } 290 291 /** 292 * e1000_set_lan_id_multi_port_pci - Set LAN id for PCI multiple port devices 293 * @hw: pointer to the HW structure 294 * 295 * Determines the LAN function id by reading PCI config space. 296 **/ 297 void e1000_set_lan_id_multi_port_pci(struct e1000_hw *hw) 298 { 299 struct e1000_bus_info *bus = &hw->bus; 300 u16 pci_header_type; 301 u32 status; 302 303 e1000_read_pci_cfg(hw, PCI_HEADER_TYPE_REGISTER, &pci_header_type); 304 if (pci_header_type & PCI_HEADER_TYPE_MULTIFUNC) { 305 status = E1000_READ_REG(hw, E1000_STATUS); 306 bus->func = (status & E1000_STATUS_FUNC_MASK) 307 >> E1000_STATUS_FUNC_SHIFT; 308 } else { 309 bus->func = 0; 310 } 311 } 312 313 /** 314 * e1000_set_lan_id_single_port - Set LAN id for a single port device 315 * @hw: pointer to the HW structure 316 * 317 * Sets the LAN function id to zero for a single port device. 318 **/ 319 void e1000_set_lan_id_single_port(struct e1000_hw *hw) 320 { 321 struct e1000_bus_info *bus = &hw->bus; 322 323 bus->func = 0; 324 } 325 326 /** 327 * e1000_clear_vfta_generic - Clear VLAN filter table 328 * @hw: pointer to the HW structure 329 * 330 * Clears the register array which contains the VLAN filter table by 331 * setting all the values to 0. 332 **/ 333 void e1000_clear_vfta_generic(struct e1000_hw *hw) 334 { 335 u32 offset; 336 337 DEBUGFUNC("e1000_clear_vfta_generic"); 338 339 for (offset = 0; offset < E1000_VLAN_FILTER_TBL_SIZE; offset++) { 340 E1000_WRITE_REG_ARRAY(hw, E1000_VFTA, offset, 0); 341 E1000_WRITE_FLUSH(hw); 342 } 343 } 344 345 /** 346 * e1000_write_vfta_generic - Write value to VLAN filter table 347 * @hw: pointer to the HW structure 348 * @offset: register offset in VLAN filter table 349 * @value: register value written to VLAN filter table 350 * 351 * Writes value at the given offset in the register array which stores 352 * the VLAN filter table. 353 **/ 354 void e1000_write_vfta_generic(struct e1000_hw *hw, u32 offset, u32 value) 355 { 356 DEBUGFUNC("e1000_write_vfta_generic"); 357 358 E1000_WRITE_REG_ARRAY(hw, E1000_VFTA, offset, value); 359 E1000_WRITE_FLUSH(hw); 360 } 361 362 /** 363 * e1000_init_rx_addrs_generic - Initialize receive address's 364 * @hw: pointer to the HW structure 365 * @rar_count: receive address registers 366 * 367 * Setup the receive address registers by setting the base receive address 368 * register to the devices MAC address and clearing all the other receive 369 * address registers to 0. 370 **/ 371 void e1000_init_rx_addrs_generic(struct e1000_hw *hw, u16 rar_count) 372 { 373 u32 i; 374 u8 mac_addr[ETH_ADDR_LEN] = {0}; 375 376 DEBUGFUNC("e1000_init_rx_addrs_generic"); 377 378 /* Setup the receive address */ 379 DEBUGOUT("Programming MAC Address into RAR[0]\n"); 380 381 hw->mac.ops.rar_set(hw, hw->mac.addr, 0); 382 383 /* Zero out the other (rar_entry_count - 1) receive addresses */ 384 DEBUGOUT1("Clearing RAR[1-%u]\n", rar_count-1); 385 for (i = 1; i < rar_count; i++) 386 hw->mac.ops.rar_set(hw, mac_addr, i); 387 } 388 389 /** 390 * e1000_check_alt_mac_addr_generic - Check for alternate MAC addr 391 * @hw: pointer to the HW structure 392 * 393 * Checks the nvm for an alternate MAC address. An alternate MAC address 394 * can be setup by pre-boot software and must be treated like a permanent 395 * address and must override the actual permanent MAC address. If an 396 * alternate MAC address is found it is programmed into RAR0, replacing 397 * the permanent address that was installed into RAR0 by the Si on reset. 398 * This function will return SUCCESS unless it encounters an error while 399 * reading the EEPROM. 400 **/ 401 s32 e1000_check_alt_mac_addr_generic(struct e1000_hw *hw) 402 { 403 u32 i; 404 s32 ret_val; 405 u16 offset, nvm_alt_mac_addr_offset, nvm_data; 406 u8 alt_mac_addr[ETH_ADDR_LEN]; 407 408 DEBUGFUNC("e1000_check_alt_mac_addr_generic"); 409 410 ret_val = hw->nvm.ops.read(hw, NVM_COMPAT, 1, &nvm_data); 411 if (ret_val) 412 return ret_val; 413 414 /* not supported on older hardware or 82573 */ 415 if ((hw->mac.type < e1000_82571) || (hw->mac.type == e1000_82573)) 416 return E1000_SUCCESS; 417 418 /* Alternate MAC address is handled by the option ROM for 82580 419 * and newer. SW support not required. 420 */ 421 if (hw->mac.type >= e1000_82580) 422 return E1000_SUCCESS; 423 424 ret_val = hw->nvm.ops.read(hw, NVM_ALT_MAC_ADDR_PTR, 1, 425 &nvm_alt_mac_addr_offset); 426 if (ret_val) { 427 DEBUGOUT("NVM Read Error\n"); 428 return ret_val; 429 } 430 431 if ((nvm_alt_mac_addr_offset == 0xFFFF) || 432 (nvm_alt_mac_addr_offset == 0x0000)) 433 /* There is no Alternate MAC Address */ 434 return E1000_SUCCESS; 435 436 if (hw->bus.func == E1000_FUNC_1) 437 nvm_alt_mac_addr_offset += E1000_ALT_MAC_ADDRESS_OFFSET_LAN1; 438 if (hw->bus.func == E1000_FUNC_2) 439 nvm_alt_mac_addr_offset += E1000_ALT_MAC_ADDRESS_OFFSET_LAN2; 440 441 if (hw->bus.func == E1000_FUNC_3) 442 nvm_alt_mac_addr_offset += E1000_ALT_MAC_ADDRESS_OFFSET_LAN3; 443 for (i = 0; i < ETH_ADDR_LEN; i += 2) { 444 offset = nvm_alt_mac_addr_offset + (i >> 1); 445 ret_val = hw->nvm.ops.read(hw, offset, 1, &nvm_data); 446 if (ret_val) { 447 DEBUGOUT("NVM Read Error\n"); 448 return ret_val; 449 } 450 451 alt_mac_addr[i] = (u8)(nvm_data & 0xFF); 452 alt_mac_addr[i + 1] = (u8)(nvm_data >> 8); 453 } 454 455 /* if multicast bit is set, the alternate address will not be used */ 456 if (alt_mac_addr[0] & 0x01) { 457 DEBUGOUT("Ignoring Alternate Mac Address with MC bit set\n"); 458 return E1000_SUCCESS; 459 } 460 461 /* We have a valid alternate MAC address, and we want to treat it the 462 * same as the normal permanent MAC address stored by the HW into the 463 * RAR. Do this by mapping this address into RAR0. 464 */ 465 hw->mac.ops.rar_set(hw, alt_mac_addr, 0); 466 467 return E1000_SUCCESS; 468 } 469 470 /** 471 * e1000_rar_set_generic - Set receive address register 472 * @hw: pointer to the HW structure 473 * @addr: pointer to the receive address 474 * @index: receive address array register 475 * 476 * Sets the receive address array register at index to the address passed 477 * in by addr. 478 **/ 479 static int e1000_rar_set_generic(struct e1000_hw *hw, u8 *addr, u32 index) 480 { 481 u32 rar_low, rar_high; 482 483 DEBUGFUNC("e1000_rar_set_generic"); 484 485 /* HW expects these in little endian so we reverse the byte order 486 * from network order (big endian) to little endian 487 */ 488 rar_low = ((u32) addr[0] | ((u32) addr[1] << 8) | 489 ((u32) addr[2] << 16) | ((u32) addr[3] << 24)); 490 491 rar_high = ((u32) addr[4] | ((u32) addr[5] << 8)); 492 493 /* If MAC address zero, no need to set the AV bit */ 494 if (rar_low || rar_high) 495 rar_high |= E1000_RAH_AV; 496 497 /* Some bridges will combine consecutive 32-bit writes into 498 * a single burst write, which will malfunction on some parts. 499 * The flushes avoid this. 500 */ 501 E1000_WRITE_REG(hw, E1000_RAL(index), rar_low); 502 E1000_WRITE_FLUSH(hw); 503 E1000_WRITE_REG(hw, E1000_RAH(index), rar_high); 504 E1000_WRITE_FLUSH(hw); 505 506 return E1000_SUCCESS; 507 } 508 509 /** 510 * e1000_hash_mc_addr_generic - Generate a multicast hash value 511 * @hw: pointer to the HW structure 512 * @mc_addr: pointer to a multicast address 513 * 514 * Generates a multicast address hash value which is used to determine 515 * the multicast filter table array address and new table value. 516 **/ 517 u32 e1000_hash_mc_addr_generic(struct e1000_hw *hw, u8 *mc_addr) 518 { 519 u32 hash_value, hash_mask; 520 u8 bit_shift = 0; 521 522 DEBUGFUNC("e1000_hash_mc_addr_generic"); 523 524 /* Register count multiplied by bits per register */ 525 hash_mask = (hw->mac.mta_reg_count * 32) - 1; 526 527 /* For a mc_filter_type of 0, bit_shift is the number of left-shifts 528 * where 0xFF would still fall within the hash mask. 529 */ 530 while (hash_mask >> bit_shift != 0xFF) 531 bit_shift++; 532 533 /* The portion of the address that is used for the hash table 534 * is determined by the mc_filter_type setting. 535 * The algorithm is such that there is a total of 8 bits of shifting. 536 * The bit_shift for a mc_filter_type of 0 represents the number of 537 * left-shifts where the MSB of mc_addr[5] would still fall within 538 * the hash_mask. Case 0 does this exactly. Since there are a total 539 * of 8 bits of shifting, then mc_addr[4] will shift right the 540 * remaining number of bits. Thus 8 - bit_shift. The rest of the 541 * cases are a variation of this algorithm...essentially raising the 542 * number of bits to shift mc_addr[5] left, while still keeping the 543 * 8-bit shifting total. 544 * 545 * For example, given the following Destination MAC Address and an 546 * mta register count of 128 (thus a 4096-bit vector and 0xFFF mask), 547 * we can see that the bit_shift for case 0 is 4. These are the hash 548 * values resulting from each mc_filter_type... 549 * [0] [1] [2] [3] [4] [5] 550 * 01 AA 00 12 34 56 551 * LSB MSB 552 * 553 * case 0: hash_value = ((0x34 >> 4) | (0x56 << 4)) & 0xFFF = 0x563 554 * case 1: hash_value = ((0x34 >> 3) | (0x56 << 5)) & 0xFFF = 0xAC6 555 * case 2: hash_value = ((0x34 >> 2) | (0x56 << 6)) & 0xFFF = 0x163 556 * case 3: hash_value = ((0x34 >> 0) | (0x56 << 8)) & 0xFFF = 0x634 557 */ 558 switch (hw->mac.mc_filter_type) { 559 default: 560 case 0: 561 break; 562 case 1: 563 bit_shift += 1; 564 break; 565 case 2: 566 bit_shift += 2; 567 break; 568 case 3: 569 bit_shift += 4; 570 break; 571 } 572 573 hash_value = hash_mask & (((mc_addr[4] >> (8 - bit_shift)) | 574 (((u16) mc_addr[5]) << bit_shift))); 575 576 return hash_value; 577 } 578 579 /** 580 * e1000_update_mc_addr_list_generic - Update Multicast addresses 581 * @hw: pointer to the HW structure 582 * @mc_addr_list: array of multicast addresses to program 583 * @mc_addr_count: number of multicast addresses to program 584 * 585 * Updates entire Multicast Table Array. 586 * The caller must have a packed mc_addr_list of multicast addresses. 587 **/ 588 void e1000_update_mc_addr_list_generic(struct e1000_hw *hw, 589 u8 *mc_addr_list, u32 mc_addr_count) 590 { 591 u32 hash_value, hash_bit, hash_reg; 592 int i; 593 594 DEBUGFUNC("e1000_update_mc_addr_list_generic"); 595 596 /* clear mta_shadow */ 597 memset(&hw->mac.mta_shadow, 0, sizeof(hw->mac.mta_shadow)); 598 599 /* update mta_shadow from mc_addr_list */ 600 for (i = 0; (u32) i < mc_addr_count; i++) { 601 hash_value = e1000_hash_mc_addr_generic(hw, mc_addr_list); 602 603 hash_reg = (hash_value >> 5) & (hw->mac.mta_reg_count - 1); 604 hash_bit = hash_value & 0x1F; 605 606 hw->mac.mta_shadow[hash_reg] |= (1 << hash_bit); 607 mc_addr_list += (ETH_ADDR_LEN); 608 } 609 610 /* replace the entire MTA table */ 611 for (i = hw->mac.mta_reg_count - 1; i >= 0; i--) 612 E1000_WRITE_REG_ARRAY(hw, E1000_MTA, i, hw->mac.mta_shadow[i]); 613 E1000_WRITE_FLUSH(hw); 614 } 615 616 /** 617 * e1000_pcix_mmrbc_workaround_generic - Fix incorrect MMRBC value 618 * @hw: pointer to the HW structure 619 * 620 * In certain situations, a system BIOS may report that the PCIx maximum 621 * memory read byte count (MMRBC) value is higher than than the actual 622 * value. We check the PCIx command register with the current PCIx status 623 * register. 624 **/ 625 void e1000_pcix_mmrbc_workaround_generic(struct e1000_hw *hw) 626 { 627 u16 cmd_mmrbc; 628 u16 pcix_cmd; 629 u16 pcix_stat_hi_word; 630 u16 stat_mmrbc; 631 632 DEBUGFUNC("e1000_pcix_mmrbc_workaround_generic"); 633 634 /* Workaround for PCI-X issue when BIOS sets MMRBC incorrectly */ 635 if (hw->bus.type != e1000_bus_type_pcix) 636 return; 637 638 e1000_read_pci_cfg(hw, PCIX_COMMAND_REGISTER, &pcix_cmd); 639 e1000_read_pci_cfg(hw, PCIX_STATUS_REGISTER_HI, &pcix_stat_hi_word); 640 cmd_mmrbc = (pcix_cmd & PCIX_COMMAND_MMRBC_MASK) >> 641 PCIX_COMMAND_MMRBC_SHIFT; 642 stat_mmrbc = (pcix_stat_hi_word & PCIX_STATUS_HI_MMRBC_MASK) >> 643 PCIX_STATUS_HI_MMRBC_SHIFT; 644 if (stat_mmrbc == PCIX_STATUS_HI_MMRBC_4K) 645 stat_mmrbc = PCIX_STATUS_HI_MMRBC_2K; 646 if (cmd_mmrbc > stat_mmrbc) { 647 pcix_cmd &= ~PCIX_COMMAND_MMRBC_MASK; 648 pcix_cmd |= stat_mmrbc << PCIX_COMMAND_MMRBC_SHIFT; 649 e1000_write_pci_cfg(hw, PCIX_COMMAND_REGISTER, &pcix_cmd); 650 } 651 } 652 653 /** 654 * e1000_clear_hw_cntrs_base_generic - Clear base hardware counters 655 * @hw: pointer to the HW structure 656 * 657 * Clears the base hardware counters by reading the counter registers. 658 **/ 659 void e1000_clear_hw_cntrs_base_generic(struct e1000_hw *hw) 660 { 661 DEBUGFUNC("e1000_clear_hw_cntrs_base_generic"); 662 663 E1000_READ_REG(hw, E1000_CRCERRS); 664 E1000_READ_REG(hw, E1000_SYMERRS); 665 E1000_READ_REG(hw, E1000_MPC); 666 E1000_READ_REG(hw, E1000_SCC); 667 E1000_READ_REG(hw, E1000_ECOL); 668 E1000_READ_REG(hw, E1000_MCC); 669 E1000_READ_REG(hw, E1000_LATECOL); 670 E1000_READ_REG(hw, E1000_COLC); 671 E1000_READ_REG(hw, E1000_DC); 672 E1000_READ_REG(hw, E1000_SEC); 673 E1000_READ_REG(hw, E1000_RLEC); 674 E1000_READ_REG(hw, E1000_XONRXC); 675 E1000_READ_REG(hw, E1000_XONTXC); 676 E1000_READ_REG(hw, E1000_XOFFRXC); 677 E1000_READ_REG(hw, E1000_XOFFTXC); 678 E1000_READ_REG(hw, E1000_FCRUC); 679 E1000_READ_REG(hw, E1000_GPRC); 680 E1000_READ_REG(hw, E1000_BPRC); 681 E1000_READ_REG(hw, E1000_MPRC); 682 E1000_READ_REG(hw, E1000_GPTC); 683 E1000_READ_REG(hw, E1000_GORCL); 684 E1000_READ_REG(hw, E1000_GORCH); 685 E1000_READ_REG(hw, E1000_GOTCL); 686 E1000_READ_REG(hw, E1000_GOTCH); 687 E1000_READ_REG(hw, E1000_RNBC); 688 E1000_READ_REG(hw, E1000_RUC); 689 E1000_READ_REG(hw, E1000_RFC); 690 E1000_READ_REG(hw, E1000_ROC); 691 E1000_READ_REG(hw, E1000_RJC); 692 E1000_READ_REG(hw, E1000_TORL); 693 E1000_READ_REG(hw, E1000_TORH); 694 E1000_READ_REG(hw, E1000_TOTL); 695 E1000_READ_REG(hw, E1000_TOTH); 696 E1000_READ_REG(hw, E1000_TPR); 697 E1000_READ_REG(hw, E1000_TPT); 698 E1000_READ_REG(hw, E1000_MPTC); 699 E1000_READ_REG(hw, E1000_BPTC); 700 } 701 702 /** 703 * e1000_check_for_copper_link_generic - Check for link (Copper) 704 * @hw: pointer to the HW structure 705 * 706 * Checks to see of the link status of the hardware has changed. If a 707 * change in link status has been detected, then we read the PHY registers 708 * to get the current speed/duplex if link exists. 709 **/ 710 s32 e1000_check_for_copper_link_generic(struct e1000_hw *hw) 711 { 712 struct e1000_mac_info *mac = &hw->mac; 713 s32 ret_val; 714 bool link; 715 716 DEBUGFUNC("e1000_check_for_copper_link"); 717 718 /* We only want to go out to the PHY registers to see if Auto-Neg 719 * has completed and/or if our link status has changed. The 720 * get_link_status flag is set upon receiving a Link Status 721 * Change or Rx Sequence Error interrupt. 722 */ 723 if (!mac->get_link_status) 724 return E1000_SUCCESS; 725 726 /* First we want to see if the MII Status Register reports 727 * link. If so, then we want to get the current speed/duplex 728 * of the PHY. 729 */ 730 ret_val = e1000_phy_has_link_generic(hw, 1, 0, &link); 731 if (ret_val) 732 return ret_val; 733 734 if (!link) 735 return E1000_SUCCESS; /* No link detected */ 736 737 mac->get_link_status = FALSE; 738 739 /* Check if there was DownShift, must be checked 740 * immediately after link-up 741 */ 742 e1000_check_downshift_generic(hw); 743 744 /* If we are forcing speed/duplex, then we simply return since 745 * we have already determined whether we have link or not. 746 */ 747 if (!mac->autoneg) 748 return -E1000_ERR_CONFIG; 749 750 /* Auto-Neg is enabled. Auto Speed Detection takes care 751 * of MAC speed/duplex configuration. So we only need to 752 * configure Collision Distance in the MAC. 753 */ 754 mac->ops.config_collision_dist(hw); 755 756 /* Configure Flow Control now that Auto-Neg has completed. 757 * First, we need to restore the desired flow control 758 * settings because we may have had to re-autoneg with a 759 * different link partner. 760 */ 761 ret_val = e1000_config_fc_after_link_up_generic(hw); 762 if (ret_val) 763 DEBUGOUT("Error configuring flow control\n"); 764 765 return ret_val; 766 } 767 768 /** 769 * e1000_check_for_fiber_link_generic - Check for link (Fiber) 770 * @hw: pointer to the HW structure 771 * 772 * Checks for link up on the hardware. If link is not up and we have 773 * a signal, then we need to force link up. 774 **/ 775 s32 e1000_check_for_fiber_link_generic(struct e1000_hw *hw) 776 { 777 struct e1000_mac_info *mac = &hw->mac; 778 u32 rxcw; 779 u32 ctrl; 780 u32 status; 781 s32 ret_val; 782 783 DEBUGFUNC("e1000_check_for_fiber_link_generic"); 784 785 ctrl = E1000_READ_REG(hw, E1000_CTRL); 786 status = E1000_READ_REG(hw, E1000_STATUS); 787 rxcw = E1000_READ_REG(hw, E1000_RXCW); 788 789 /* If we don't have link (auto-negotiation failed or link partner 790 * cannot auto-negotiate), the cable is plugged in (we have signal), 791 * and our link partner is not trying to auto-negotiate with us (we 792 * are receiving idles or data), we need to force link up. We also 793 * need to give auto-negotiation time to complete, in case the cable 794 * was just plugged in. The autoneg_failed flag does this. 795 */ 796 /* (ctrl & E1000_CTRL_SWDPIN1) == 1 == have signal */ 797 if ((ctrl & E1000_CTRL_SWDPIN1) && !(status & E1000_STATUS_LU) && 798 !(rxcw & E1000_RXCW_C)) { 799 if (!mac->autoneg_failed) { 800 mac->autoneg_failed = TRUE; 801 return E1000_SUCCESS; 802 } 803 DEBUGOUT("NOT Rx'ing /C/, disable AutoNeg and force link.\n"); 804 805 /* Disable auto-negotiation in the TXCW register */ 806 E1000_WRITE_REG(hw, E1000_TXCW, (mac->txcw & ~E1000_TXCW_ANE)); 807 808 /* Force link-up and also force full-duplex. */ 809 ctrl = E1000_READ_REG(hw, E1000_CTRL); 810 ctrl |= (E1000_CTRL_SLU | E1000_CTRL_FD); 811 E1000_WRITE_REG(hw, E1000_CTRL, ctrl); 812 813 /* Configure Flow Control after forcing link up. */ 814 ret_val = e1000_config_fc_after_link_up_generic(hw); 815 if (ret_val) { 816 DEBUGOUT("Error configuring flow control\n"); 817 return ret_val; 818 } 819 } else if ((ctrl & E1000_CTRL_SLU) && (rxcw & E1000_RXCW_C)) { 820 /* If we are forcing link and we are receiving /C/ ordered 821 * sets, re-enable auto-negotiation in the TXCW register 822 * and disable forced link in the Device Control register 823 * in an attempt to auto-negotiate with our link partner. 824 */ 825 DEBUGOUT("Rx'ing /C/, enable AutoNeg and stop forcing link.\n"); 826 E1000_WRITE_REG(hw, E1000_TXCW, mac->txcw); 827 E1000_WRITE_REG(hw, E1000_CTRL, (ctrl & ~E1000_CTRL_SLU)); 828 829 mac->serdes_has_link = TRUE; 830 } 831 832 return E1000_SUCCESS; 833 } 834 835 /** 836 * e1000_check_for_serdes_link_generic - Check for link (Serdes) 837 * @hw: pointer to the HW structure 838 * 839 * Checks for link up on the hardware. If link is not up and we have 840 * a signal, then we need to force link up. 841 **/ 842 s32 e1000_check_for_serdes_link_generic(struct e1000_hw *hw) 843 { 844 struct e1000_mac_info *mac = &hw->mac; 845 u32 rxcw; 846 u32 ctrl; 847 u32 status; 848 s32 ret_val; 849 850 DEBUGFUNC("e1000_check_for_serdes_link_generic"); 851 852 ctrl = E1000_READ_REG(hw, E1000_CTRL); 853 status = E1000_READ_REG(hw, E1000_STATUS); 854 rxcw = E1000_READ_REG(hw, E1000_RXCW); 855 856 /* If we don't have link (auto-negotiation failed or link partner 857 * cannot auto-negotiate), and our link partner is not trying to 858 * auto-negotiate with us (we are receiving idles or data), 859 * we need to force link up. We also need to give auto-negotiation 860 * time to complete. 861 */ 862 /* (ctrl & E1000_CTRL_SWDPIN1) == 1 == have signal */ 863 if (!(status & E1000_STATUS_LU) && !(rxcw & E1000_RXCW_C)) { 864 if (!mac->autoneg_failed) { 865 mac->autoneg_failed = TRUE; 866 return E1000_SUCCESS; 867 } 868 DEBUGOUT("NOT Rx'ing /C/, disable AutoNeg and force link.\n"); 869 870 /* Disable auto-negotiation in the TXCW register */ 871 E1000_WRITE_REG(hw, E1000_TXCW, (mac->txcw & ~E1000_TXCW_ANE)); 872 873 /* Force link-up and also force full-duplex. */ 874 ctrl = E1000_READ_REG(hw, E1000_CTRL); 875 ctrl |= (E1000_CTRL_SLU | E1000_CTRL_FD); 876 E1000_WRITE_REG(hw, E1000_CTRL, ctrl); 877 878 /* Configure Flow Control after forcing link up. */ 879 ret_val = e1000_config_fc_after_link_up_generic(hw); 880 if (ret_val) { 881 DEBUGOUT("Error configuring flow control\n"); 882 return ret_val; 883 } 884 } else if ((ctrl & E1000_CTRL_SLU) && (rxcw & E1000_RXCW_C)) { 885 /* If we are forcing link and we are receiving /C/ ordered 886 * sets, re-enable auto-negotiation in the TXCW register 887 * and disable forced link in the Device Control register 888 * in an attempt to auto-negotiate with our link partner. 889 */ 890 DEBUGOUT("Rx'ing /C/, enable AutoNeg and stop forcing link.\n"); 891 E1000_WRITE_REG(hw, E1000_TXCW, mac->txcw); 892 E1000_WRITE_REG(hw, E1000_CTRL, (ctrl & ~E1000_CTRL_SLU)); 893 894 mac->serdes_has_link = TRUE; 895 } else if (!(E1000_TXCW_ANE & E1000_READ_REG(hw, E1000_TXCW))) { 896 /* If we force link for non-auto-negotiation switch, check 897 * link status based on MAC synchronization for internal 898 * serdes media type. 899 */ 900 /* SYNCH bit and IV bit are sticky. */ 901 usec_delay(10); 902 rxcw = E1000_READ_REG(hw, E1000_RXCW); 903 if (rxcw & E1000_RXCW_SYNCH) { 904 if (!(rxcw & E1000_RXCW_IV)) { 905 mac->serdes_has_link = TRUE; 906 DEBUGOUT("SERDES: Link up - forced.\n"); 907 } 908 } else { 909 mac->serdes_has_link = FALSE; 910 DEBUGOUT("SERDES: Link down - force failed.\n"); 911 } 912 } 913 914 if (E1000_TXCW_ANE & E1000_READ_REG(hw, E1000_TXCW)) { 915 status = E1000_READ_REG(hw, E1000_STATUS); 916 if (status & E1000_STATUS_LU) { 917 /* SYNCH bit and IV bit are sticky, so reread rxcw. */ 918 usec_delay(10); 919 rxcw = E1000_READ_REG(hw, E1000_RXCW); 920 if (rxcw & E1000_RXCW_SYNCH) { 921 if (!(rxcw & E1000_RXCW_IV)) { 922 mac->serdes_has_link = TRUE; 923 DEBUGOUT("SERDES: Link up - autoneg completed successfully.\n"); 924 } else { 925 mac->serdes_has_link = FALSE; 926 DEBUGOUT("SERDES: Link down - invalid codewords detected in autoneg.\n"); 927 } 928 } else { 929 mac->serdes_has_link = FALSE; 930 DEBUGOUT("SERDES: Link down - no sync.\n"); 931 } 932 } else { 933 mac->serdes_has_link = FALSE; 934 DEBUGOUT("SERDES: Link down - autoneg failed\n"); 935 } 936 } 937 938 return E1000_SUCCESS; 939 } 940 941 /** 942 * e1000_set_default_fc_generic - Set flow control default values 943 * @hw: pointer to the HW structure 944 * 945 * Read the EEPROM for the default values for flow control and store the 946 * values. 947 **/ 948 s32 e1000_set_default_fc_generic(struct e1000_hw *hw) 949 { 950 s32 ret_val; 951 u16 nvm_data; 952 u16 nvm_offset = 0; 953 954 DEBUGFUNC("e1000_set_default_fc_generic"); 955 956 /* Read and store word 0x0F of the EEPROM. This word contains bits 957 * that determine the hardware's default PAUSE (flow control) mode, 958 * a bit that determines whether the HW defaults to enabling or 959 * disabling auto-negotiation, and the direction of the 960 * SW defined pins. If there is no SW over-ride of the flow 961 * control setting, then the variable hw->fc will 962 * be initialized based on a value in the EEPROM. 963 */ 964 if (hw->mac.type == e1000_i350) { 965 nvm_offset = NVM_82580_LAN_FUNC_OFFSET(hw->bus.func); 966 ret_val = hw->nvm.ops.read(hw, 967 NVM_INIT_CONTROL2_REG + 968 nvm_offset, 969 1, &nvm_data); 970 } else { 971 ret_val = hw->nvm.ops.read(hw, 972 NVM_INIT_CONTROL2_REG, 973 1, &nvm_data); 974 } 975 976 977 if (ret_val) { 978 DEBUGOUT("NVM Read Error\n"); 979 return ret_val; 980 } 981 982 if (!(nvm_data & NVM_WORD0F_PAUSE_MASK)) 983 hw->fc.requested_mode = e1000_fc_none; 984 else if ((nvm_data & NVM_WORD0F_PAUSE_MASK) == 985 NVM_WORD0F_ASM_DIR) 986 hw->fc.requested_mode = e1000_fc_tx_pause; 987 else 988 hw->fc.requested_mode = e1000_fc_full; 989 990 return E1000_SUCCESS; 991 } 992 993 /** 994 * e1000_setup_link_generic - Setup flow control and link settings 995 * @hw: pointer to the HW structure 996 * 997 * Determines which flow control settings to use, then configures flow 998 * control. Calls the appropriate media-specific link configuration 999 * function. Assuming the adapter has a valid link partner, a valid link 1000 * should be established. Assumes the hardware has previously been reset 1001 * and the transmitter and receiver are not enabled. 1002 **/ 1003 s32 e1000_setup_link_generic(struct e1000_hw *hw) 1004 { 1005 s32 ret_val; 1006 1007 DEBUGFUNC("e1000_setup_link_generic"); 1008 1009 /* In the case of the phy reset being blocked, we already have a link. 1010 * We do not need to set it up again. 1011 */ 1012 if (hw->phy.ops.check_reset_block && hw->phy.ops.check_reset_block(hw)) 1013 return E1000_SUCCESS; 1014 1015 /* If requested flow control is set to default, set flow control 1016 * based on the EEPROM flow control settings. 1017 */ 1018 if (hw->fc.requested_mode == e1000_fc_default) { 1019 ret_val = e1000_set_default_fc_generic(hw); 1020 if (ret_val) 1021 return ret_val; 1022 } 1023 1024 /* Save off the requested flow control mode for use later. Depending 1025 * on the link partner's capabilities, we may or may not use this mode. 1026 */ 1027 hw->fc.current_mode = hw->fc.requested_mode; 1028 1029 DEBUGOUT1("After fix-ups FlowControl is now = %x\n", 1030 hw->fc.current_mode); 1031 1032 /* Call the necessary media_type subroutine to configure the link. */ 1033 ret_val = hw->mac.ops.setup_physical_interface(hw); 1034 if (ret_val) 1035 return ret_val; 1036 1037 /* Initialize the flow control address, type, and PAUSE timer 1038 * registers to their default values. This is done even if flow 1039 * control is disabled, because it does not hurt anything to 1040 * initialize these registers. 1041 */ 1042 DEBUGOUT("Initializing the Flow Control address, type and timer regs\n"); 1043 E1000_WRITE_REG(hw, E1000_FCT, FLOW_CONTROL_TYPE); 1044 E1000_WRITE_REG(hw, E1000_FCAH, FLOW_CONTROL_ADDRESS_HIGH); 1045 E1000_WRITE_REG(hw, E1000_FCAL, FLOW_CONTROL_ADDRESS_LOW); 1046 1047 E1000_WRITE_REG(hw, E1000_FCTTV, hw->fc.pause_time); 1048 1049 return e1000_set_fc_watermarks_generic(hw); 1050 } 1051 1052 /** 1053 * e1000_commit_fc_settings_generic - Configure flow control 1054 * @hw: pointer to the HW structure 1055 * 1056 * Write the flow control settings to the Transmit Config Word Register (TXCW) 1057 * base on the flow control settings in e1000_mac_info. 1058 **/ 1059 s32 e1000_commit_fc_settings_generic(struct e1000_hw *hw) 1060 { 1061 struct e1000_mac_info *mac = &hw->mac; 1062 u32 txcw; 1063 1064 DEBUGFUNC("e1000_commit_fc_settings_generic"); 1065 1066 /* Check for a software override of the flow control settings, and 1067 * setup the device accordingly. If auto-negotiation is enabled, then 1068 * software will have to set the "PAUSE" bits to the correct value in 1069 * the Transmit Config Word Register (TXCW) and re-start auto- 1070 * negotiation. However, if auto-negotiation is disabled, then 1071 * software will have to manually configure the two flow control enable 1072 * bits in the CTRL register. 1073 * 1074 * The possible values of the "fc" parameter are: 1075 * 0: Flow control is completely disabled 1076 * 1: Rx flow control is enabled (we can receive pause frames, 1077 * but not send pause frames). 1078 * 2: Tx flow control is enabled (we can send pause frames but we 1079 * do not support receiving pause frames). 1080 * 3: Both Rx and Tx flow control (symmetric) are enabled. 1081 */ 1082 switch (hw->fc.current_mode) { 1083 case e1000_fc_none: 1084 /* Flow control completely disabled by a software over-ride. */ 1085 txcw = (E1000_TXCW_ANE | E1000_TXCW_FD); 1086 break; 1087 case e1000_fc_rx_pause: 1088 /* Rx Flow control is enabled and Tx Flow control is disabled 1089 * by a software over-ride. Since there really isn't a way to 1090 * advertise that we are capable of Rx Pause ONLY, we will 1091 * advertise that we support both symmetric and asymmetric Rx 1092 * PAUSE. Later, we will disable the adapter's ability to send 1093 * PAUSE frames. 1094 */ 1095 txcw = (E1000_TXCW_ANE | E1000_TXCW_FD | E1000_TXCW_PAUSE_MASK); 1096 break; 1097 case e1000_fc_tx_pause: 1098 /* Tx Flow control is enabled, and Rx Flow control is disabled, 1099 * by a software over-ride. 1100 */ 1101 txcw = (E1000_TXCW_ANE | E1000_TXCW_FD | E1000_TXCW_ASM_DIR); 1102 break; 1103 case e1000_fc_full: 1104 /* Flow control (both Rx and Tx) is enabled by a software 1105 * over-ride. 1106 */ 1107 txcw = (E1000_TXCW_ANE | E1000_TXCW_FD | E1000_TXCW_PAUSE_MASK); 1108 break; 1109 default: 1110 DEBUGOUT("Flow control param set incorrectly\n"); 1111 return -E1000_ERR_CONFIG; 1112 break; 1113 } 1114 1115 E1000_WRITE_REG(hw, E1000_TXCW, txcw); 1116 mac->txcw = txcw; 1117 1118 return E1000_SUCCESS; 1119 } 1120 1121 /** 1122 * e1000_poll_fiber_serdes_link_generic - Poll for link up 1123 * @hw: pointer to the HW structure 1124 * 1125 * Polls for link up by reading the status register, if link fails to come 1126 * up with auto-negotiation, then the link is forced if a signal is detected. 1127 **/ 1128 s32 e1000_poll_fiber_serdes_link_generic(struct e1000_hw *hw) 1129 { 1130 struct e1000_mac_info *mac = &hw->mac; 1131 u32 i, status; 1132 s32 ret_val; 1133 1134 DEBUGFUNC("e1000_poll_fiber_serdes_link_generic"); 1135 1136 /* If we have a signal (the cable is plugged in, or assumed TRUE for 1137 * serdes media) then poll for a "Link-Up" indication in the Device 1138 * Status Register. Time-out if a link isn't seen in 500 milliseconds 1139 * seconds (Auto-negotiation should complete in less than 500 1140 * milliseconds even if the other end is doing it in SW). 1141 */ 1142 for (i = 0; i < FIBER_LINK_UP_LIMIT; i++) { 1143 msec_delay(10); 1144 status = E1000_READ_REG(hw, E1000_STATUS); 1145 if (status & E1000_STATUS_LU) 1146 break; 1147 } 1148 if (i == FIBER_LINK_UP_LIMIT) { 1149 DEBUGOUT("Never got a valid link from auto-neg!!!\n"); 1150 mac->autoneg_failed = TRUE; 1151 /* AutoNeg failed to achieve a link, so we'll call 1152 * mac->check_for_link. This routine will force the 1153 * link up if we detect a signal. This will allow us to 1154 * communicate with non-autonegotiating link partners. 1155 */ 1156 ret_val = mac->ops.check_for_link(hw); 1157 if (ret_val) { 1158 DEBUGOUT("Error while checking for link\n"); 1159 return ret_val; 1160 } 1161 mac->autoneg_failed = FALSE; 1162 } else { 1163 mac->autoneg_failed = FALSE; 1164 DEBUGOUT("Valid Link Found\n"); 1165 } 1166 1167 return E1000_SUCCESS; 1168 } 1169 1170 /** 1171 * e1000_setup_fiber_serdes_link_generic - Setup link for fiber/serdes 1172 * @hw: pointer to the HW structure 1173 * 1174 * Configures collision distance and flow control for fiber and serdes 1175 * links. Upon successful setup, poll for link. 1176 **/ 1177 s32 e1000_setup_fiber_serdes_link_generic(struct e1000_hw *hw) 1178 { 1179 u32 ctrl; 1180 s32 ret_val; 1181 1182 DEBUGFUNC("e1000_setup_fiber_serdes_link_generic"); 1183 1184 ctrl = E1000_READ_REG(hw, E1000_CTRL); 1185 1186 /* Take the link out of reset */ 1187 ctrl &= ~E1000_CTRL_LRST; 1188 1189 hw->mac.ops.config_collision_dist(hw); 1190 1191 ret_val = e1000_commit_fc_settings_generic(hw); 1192 if (ret_val) 1193 return ret_val; 1194 1195 /* Since auto-negotiation is enabled, take the link out of reset (the 1196 * link will be in reset, because we previously reset the chip). This 1197 * will restart auto-negotiation. If auto-negotiation is successful 1198 * then the link-up status bit will be set and the flow control enable 1199 * bits (RFCE and TFCE) will be set according to their negotiated value. 1200 */ 1201 DEBUGOUT("Auto-negotiation enabled\n"); 1202 1203 E1000_WRITE_REG(hw, E1000_CTRL, ctrl); 1204 E1000_WRITE_FLUSH(hw); 1205 msec_delay(1); 1206 1207 /* For these adapters, the SW definable pin 1 is set when the optics 1208 * detect a signal. If we have a signal, then poll for a "Link-Up" 1209 * indication. 1210 */ 1211 if (hw->phy.media_type == e1000_media_type_internal_serdes || 1212 (E1000_READ_REG(hw, E1000_CTRL) & E1000_CTRL_SWDPIN1)) { 1213 ret_val = e1000_poll_fiber_serdes_link_generic(hw); 1214 } else { 1215 DEBUGOUT("No signal detected\n"); 1216 } 1217 1218 return ret_val; 1219 } 1220 1221 /** 1222 * e1000_config_collision_dist_generic - Configure collision distance 1223 * @hw: pointer to the HW structure 1224 * 1225 * Configures the collision distance to the default value and is used 1226 * during link setup. 1227 **/ 1228 static void e1000_config_collision_dist_generic(struct e1000_hw *hw) 1229 { 1230 u32 tctl; 1231 1232 DEBUGFUNC("e1000_config_collision_dist_generic"); 1233 1234 tctl = E1000_READ_REG(hw, E1000_TCTL); 1235 1236 tctl &= ~E1000_TCTL_COLD; 1237 tctl |= E1000_COLLISION_DISTANCE << E1000_COLD_SHIFT; 1238 1239 E1000_WRITE_REG(hw, E1000_TCTL, tctl); 1240 E1000_WRITE_FLUSH(hw); 1241 } 1242 1243 /** 1244 * e1000_set_fc_watermarks_generic - Set flow control high/low watermarks 1245 * @hw: pointer to the HW structure 1246 * 1247 * Sets the flow control high/low threshold (watermark) registers. If 1248 * flow control XON frame transmission is enabled, then set XON frame 1249 * transmission as well. 1250 **/ 1251 s32 e1000_set_fc_watermarks_generic(struct e1000_hw *hw) 1252 { 1253 u32 fcrtl = 0, fcrth = 0; 1254 1255 DEBUGFUNC("e1000_set_fc_watermarks_generic"); 1256 1257 /* Set the flow control receive threshold registers. Normally, 1258 * these registers will be set to a default threshold that may be 1259 * adjusted later by the driver's runtime code. However, if the 1260 * ability to transmit pause frames is not enabled, then these 1261 * registers will be set to 0. 1262 */ 1263 if (hw->fc.current_mode & e1000_fc_tx_pause) { 1264 /* We need to set up the Receive Threshold high and low water 1265 * marks as well as (optionally) enabling the transmission of 1266 * XON frames. 1267 */ 1268 fcrtl = hw->fc.low_water; 1269 if (hw->fc.send_xon) 1270 fcrtl |= E1000_FCRTL_XONE; 1271 1272 fcrth = hw->fc.high_water; 1273 } 1274 E1000_WRITE_REG(hw, E1000_FCRTL, fcrtl); 1275 E1000_WRITE_REG(hw, E1000_FCRTH, fcrth); 1276 1277 return E1000_SUCCESS; 1278 } 1279 1280 /** 1281 * e1000_force_mac_fc_generic - Force the MAC's flow control settings 1282 * @hw: pointer to the HW structure 1283 * 1284 * Force the MAC's flow control settings. Sets the TFCE and RFCE bits in the 1285 * device control register to reflect the adapter settings. TFCE and RFCE 1286 * need to be explicitly set by software when a copper PHY is used because 1287 * autonegotiation is managed by the PHY rather than the MAC. Software must 1288 * also configure these bits when link is forced on a fiber connection. 1289 **/ 1290 s32 e1000_force_mac_fc_generic(struct e1000_hw *hw) 1291 { 1292 u32 ctrl; 1293 1294 DEBUGFUNC("e1000_force_mac_fc_generic"); 1295 1296 ctrl = E1000_READ_REG(hw, E1000_CTRL); 1297 1298 /* Because we didn't get link via the internal auto-negotiation 1299 * mechanism (we either forced link or we got link via PHY 1300 * auto-neg), we have to manually enable/disable transmit an 1301 * receive flow control. 1302 * 1303 * The "Case" statement below enables/disable flow control 1304 * according to the "hw->fc.current_mode" parameter. 1305 * 1306 * The possible values of the "fc" parameter are: 1307 * 0: Flow control is completely disabled 1308 * 1: Rx flow control is enabled (we can receive pause 1309 * frames but not send pause frames). 1310 * 2: Tx flow control is enabled (we can send pause frames 1311 * frames but we do not receive pause frames). 1312 * 3: Both Rx and Tx flow control (symmetric) is enabled. 1313 * other: No other values should be possible at this point. 1314 */ 1315 DEBUGOUT1("hw->fc.current_mode = %u\n", hw->fc.current_mode); 1316 1317 switch (hw->fc.current_mode) { 1318 case e1000_fc_none: 1319 ctrl &= (~(E1000_CTRL_TFCE | E1000_CTRL_RFCE)); 1320 break; 1321 case e1000_fc_rx_pause: 1322 ctrl &= (~E1000_CTRL_TFCE); 1323 ctrl |= E1000_CTRL_RFCE; 1324 break; 1325 case e1000_fc_tx_pause: 1326 ctrl &= (~E1000_CTRL_RFCE); 1327 ctrl |= E1000_CTRL_TFCE; 1328 break; 1329 case e1000_fc_full: 1330 ctrl |= (E1000_CTRL_TFCE | E1000_CTRL_RFCE); 1331 break; 1332 default: 1333 DEBUGOUT("Flow control param set incorrectly\n"); 1334 return -E1000_ERR_CONFIG; 1335 } 1336 1337 E1000_WRITE_REG(hw, E1000_CTRL, ctrl); 1338 1339 return E1000_SUCCESS; 1340 } 1341 1342 /** 1343 * e1000_config_fc_after_link_up_generic - Configures flow control after link 1344 * @hw: pointer to the HW structure 1345 * 1346 * Checks the status of auto-negotiation after link up to ensure that the 1347 * speed and duplex were not forced. If the link needed to be forced, then 1348 * flow control needs to be forced also. If auto-negotiation is enabled 1349 * and did not fail, then we configure flow control based on our link 1350 * partner. 1351 **/ 1352 s32 e1000_config_fc_after_link_up_generic(struct e1000_hw *hw) 1353 { 1354 struct e1000_mac_info *mac = &hw->mac; 1355 s32 ret_val = E1000_SUCCESS; 1356 u32 pcs_status_reg, pcs_adv_reg, pcs_lp_ability_reg, pcs_ctrl_reg; 1357 u16 mii_status_reg, mii_nway_adv_reg, mii_nway_lp_ability_reg; 1358 u16 speed, duplex; 1359 1360 DEBUGFUNC("e1000_config_fc_after_link_up_generic"); 1361 1362 /* Check for the case where we have fiber media and auto-neg failed 1363 * so we had to force link. In this case, we need to force the 1364 * configuration of the MAC to match the "fc" parameter. 1365 */ 1366 if (mac->autoneg_failed) { 1367 if (hw->phy.media_type == e1000_media_type_fiber || 1368 hw->phy.media_type == e1000_media_type_internal_serdes) 1369 ret_val = e1000_force_mac_fc_generic(hw); 1370 } else { 1371 if (hw->phy.media_type == e1000_media_type_copper) 1372 ret_val = e1000_force_mac_fc_generic(hw); 1373 } 1374 1375 if (ret_val) { 1376 DEBUGOUT("Error forcing flow control settings\n"); 1377 return ret_val; 1378 } 1379 1380 /* Check for the case where we have copper media and auto-neg is 1381 * enabled. In this case, we need to check and see if Auto-Neg 1382 * has completed, and if so, how the PHY and link partner has 1383 * flow control configured. 1384 */ 1385 if ((hw->phy.media_type == e1000_media_type_copper) && mac->autoneg) { 1386 /* Read the MII Status Register and check to see if AutoNeg 1387 * has completed. We read this twice because this reg has 1388 * some "sticky" (latched) bits. 1389 */ 1390 ret_val = hw->phy.ops.read_reg(hw, PHY_STATUS, &mii_status_reg); 1391 if (ret_val) 1392 return ret_val; 1393 ret_val = hw->phy.ops.read_reg(hw, PHY_STATUS, &mii_status_reg); 1394 if (ret_val) 1395 return ret_val; 1396 1397 if (!(mii_status_reg & MII_SR_AUTONEG_COMPLETE)) { 1398 DEBUGOUT("Copper PHY and Auto Neg has not completed.\n"); 1399 return ret_val; 1400 } 1401 1402 /* The AutoNeg process has completed, so we now need to 1403 * read both the Auto Negotiation Advertisement 1404 * Register (Address 4) and the Auto_Negotiation Base 1405 * Page Ability Register (Address 5) to determine how 1406 * flow control was negotiated. 1407 */ 1408 ret_val = hw->phy.ops.read_reg(hw, PHY_AUTONEG_ADV, 1409 &mii_nway_adv_reg); 1410 if (ret_val) 1411 return ret_val; 1412 ret_val = hw->phy.ops.read_reg(hw, PHY_LP_ABILITY, 1413 &mii_nway_lp_ability_reg); 1414 if (ret_val) 1415 return ret_val; 1416 1417 /* Two bits in the Auto Negotiation Advertisement Register 1418 * (Address 4) and two bits in the Auto Negotiation Base 1419 * Page Ability Register (Address 5) determine flow control 1420 * for both the PHY and the link partner. The following 1421 * table, taken out of the IEEE 802.3ab/D6.0 dated March 25, 1422 * 1999, describes these PAUSE resolution bits and how flow 1423 * control is determined based upon these settings. 1424 * NOTE: DC = Don't Care 1425 * 1426 * LOCAL DEVICE | LINK PARTNER 1427 * PAUSE | ASM_DIR | PAUSE | ASM_DIR | NIC Resolution 1428 *-------|---------|-------|---------|-------------------- 1429 * 0 | 0 | DC | DC | e1000_fc_none 1430 * 0 | 1 | 0 | DC | e1000_fc_none 1431 * 0 | 1 | 1 | 0 | e1000_fc_none 1432 * 0 | 1 | 1 | 1 | e1000_fc_tx_pause 1433 * 1 | 0 | 0 | DC | e1000_fc_none 1434 * 1 | DC | 1 | DC | e1000_fc_full 1435 * 1 | 1 | 0 | 0 | e1000_fc_none 1436 * 1 | 1 | 0 | 1 | e1000_fc_rx_pause 1437 * 1438 * Are both PAUSE bits set to 1? If so, this implies 1439 * Symmetric Flow Control is enabled at both ends. The 1440 * ASM_DIR bits are irrelevant per the spec. 1441 * 1442 * For Symmetric Flow Control: 1443 * 1444 * LOCAL DEVICE | LINK PARTNER 1445 * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result 1446 *-------|---------|-------|---------|-------------------- 1447 * 1 | DC | 1 | DC | E1000_fc_full 1448 * 1449 */ 1450 if ((mii_nway_adv_reg & NWAY_AR_PAUSE) && 1451 (mii_nway_lp_ability_reg & NWAY_LPAR_PAUSE)) { 1452 /* Now we need to check if the user selected Rx ONLY 1453 * of pause frames. In this case, we had to advertise 1454 * FULL flow control because we could not advertise Rx 1455 * ONLY. Hence, we must now check to see if we need to 1456 * turn OFF the TRANSMISSION of PAUSE frames. 1457 */ 1458 if (hw->fc.requested_mode == e1000_fc_full) { 1459 hw->fc.current_mode = e1000_fc_full; 1460 DEBUGOUT("Flow Control = FULL.\n"); 1461 } else { 1462 hw->fc.current_mode = e1000_fc_rx_pause; 1463 DEBUGOUT("Flow Control = Rx PAUSE frames only.\n"); 1464 } 1465 } 1466 /* For receiving PAUSE frames ONLY. 1467 * 1468 * LOCAL DEVICE | LINK PARTNER 1469 * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result 1470 *-------|---------|-------|---------|-------------------- 1471 * 0 | 1 | 1 | 1 | e1000_fc_tx_pause 1472 */ 1473 else if (!(mii_nway_adv_reg & NWAY_AR_PAUSE) && 1474 (mii_nway_adv_reg & NWAY_AR_ASM_DIR) && 1475 (mii_nway_lp_ability_reg & NWAY_LPAR_PAUSE) && 1476 (mii_nway_lp_ability_reg & NWAY_LPAR_ASM_DIR)) { 1477 hw->fc.current_mode = e1000_fc_tx_pause; 1478 DEBUGOUT("Flow Control = Tx PAUSE frames only.\n"); 1479 } 1480 /* For transmitting PAUSE frames ONLY. 1481 * 1482 * LOCAL DEVICE | LINK PARTNER 1483 * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result 1484 *-------|---------|-------|---------|-------------------- 1485 * 1 | 1 | 0 | 1 | e1000_fc_rx_pause 1486 */ 1487 else if ((mii_nway_adv_reg & NWAY_AR_PAUSE) && 1488 (mii_nway_adv_reg & NWAY_AR_ASM_DIR) && 1489 !(mii_nway_lp_ability_reg & NWAY_LPAR_PAUSE) && 1490 (mii_nway_lp_ability_reg & NWAY_LPAR_ASM_DIR)) { 1491 hw->fc.current_mode = e1000_fc_rx_pause; 1492 DEBUGOUT("Flow Control = Rx PAUSE frames only.\n"); 1493 } else { 1494 /* Per the IEEE spec, at this point flow control 1495 * should be disabled. 1496 */ 1497 hw->fc.current_mode = e1000_fc_none; 1498 DEBUGOUT("Flow Control = NONE.\n"); 1499 } 1500 1501 /* Now we need to do one last check... If we auto- 1502 * negotiated to HALF DUPLEX, flow control should not be 1503 * enabled per IEEE 802.3 spec. 1504 */ 1505 ret_val = mac->ops.get_link_up_info(hw, &speed, &duplex); 1506 if (ret_val) { 1507 DEBUGOUT("Error getting link speed and duplex\n"); 1508 return ret_val; 1509 } 1510 1511 if (duplex == HALF_DUPLEX) 1512 hw->fc.current_mode = e1000_fc_none; 1513 1514 /* Now we call a subroutine to actually force the MAC 1515 * controller to use the correct flow control settings. 1516 */ 1517 ret_val = e1000_force_mac_fc_generic(hw); 1518 if (ret_val) { 1519 DEBUGOUT("Error forcing flow control settings\n"); 1520 return ret_val; 1521 } 1522 } 1523 1524 /* Check for the case where we have SerDes media and auto-neg is 1525 * enabled. In this case, we need to check and see if Auto-Neg 1526 * has completed, and if so, how the PHY and link partner has 1527 * flow control configured. 1528 */ 1529 if ((hw->phy.media_type == e1000_media_type_internal_serdes) && 1530 mac->autoneg) { 1531 /* Read the PCS_LSTS and check to see if AutoNeg 1532 * has completed. 1533 */ 1534 pcs_status_reg = E1000_READ_REG(hw, E1000_PCS_LSTAT); 1535 1536 if (!(pcs_status_reg & E1000_PCS_LSTS_AN_COMPLETE)) { 1537 DEBUGOUT("PCS Auto Neg has not completed.\n"); 1538 return ret_val; 1539 } 1540 1541 /* The AutoNeg process has completed, so we now need to 1542 * read both the Auto Negotiation Advertisement 1543 * Register (PCS_ANADV) and the Auto_Negotiation Base 1544 * Page Ability Register (PCS_LPAB) to determine how 1545 * flow control was negotiated. 1546 */ 1547 pcs_adv_reg = E1000_READ_REG(hw, E1000_PCS_ANADV); 1548 pcs_lp_ability_reg = E1000_READ_REG(hw, E1000_PCS_LPAB); 1549 1550 /* Two bits in the Auto Negotiation Advertisement Register 1551 * (PCS_ANADV) and two bits in the Auto Negotiation Base 1552 * Page Ability Register (PCS_LPAB) determine flow control 1553 * for both the PHY and the link partner. The following 1554 * table, taken out of the IEEE 802.3ab/D6.0 dated March 25, 1555 * 1999, describes these PAUSE resolution bits and how flow 1556 * control is determined based upon these settings. 1557 * NOTE: DC = Don't Care 1558 * 1559 * LOCAL DEVICE | LINK PARTNER 1560 * PAUSE | ASM_DIR | PAUSE | ASM_DIR | NIC Resolution 1561 *-------|---------|-------|---------|-------------------- 1562 * 0 | 0 | DC | DC | e1000_fc_none 1563 * 0 | 1 | 0 | DC | e1000_fc_none 1564 * 0 | 1 | 1 | 0 | e1000_fc_none 1565 * 0 | 1 | 1 | 1 | e1000_fc_tx_pause 1566 * 1 | 0 | 0 | DC | e1000_fc_none 1567 * 1 | DC | 1 | DC | e1000_fc_full 1568 * 1 | 1 | 0 | 0 | e1000_fc_none 1569 * 1 | 1 | 0 | 1 | e1000_fc_rx_pause 1570 * 1571 * Are both PAUSE bits set to 1? If so, this implies 1572 * Symmetric Flow Control is enabled at both ends. The 1573 * ASM_DIR bits are irrelevant per the spec. 1574 * 1575 * For Symmetric Flow Control: 1576 * 1577 * LOCAL DEVICE | LINK PARTNER 1578 * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result 1579 *-------|---------|-------|---------|-------------------- 1580 * 1 | DC | 1 | DC | e1000_fc_full 1581 * 1582 */ 1583 if ((pcs_adv_reg & E1000_TXCW_PAUSE) && 1584 (pcs_lp_ability_reg & E1000_TXCW_PAUSE)) { 1585 /* Now we need to check if the user selected Rx ONLY 1586 * of pause frames. In this case, we had to advertise 1587 * FULL flow control because we could not advertise Rx 1588 * ONLY. Hence, we must now check to see if we need to 1589 * turn OFF the TRANSMISSION of PAUSE frames. 1590 */ 1591 if (hw->fc.requested_mode == e1000_fc_full) { 1592 hw->fc.current_mode = e1000_fc_full; 1593 DEBUGOUT("Flow Control = FULL.\n"); 1594 } else { 1595 hw->fc.current_mode = e1000_fc_rx_pause; 1596 DEBUGOUT("Flow Control = Rx PAUSE frames only.\n"); 1597 } 1598 } 1599 /* For receiving PAUSE frames ONLY. 1600 * 1601 * LOCAL DEVICE | LINK PARTNER 1602 * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result 1603 *-------|---------|-------|---------|-------------------- 1604 * 0 | 1 | 1 | 1 | e1000_fc_tx_pause 1605 */ 1606 else if (!(pcs_adv_reg & E1000_TXCW_PAUSE) && 1607 (pcs_adv_reg & E1000_TXCW_ASM_DIR) && 1608 (pcs_lp_ability_reg & E1000_TXCW_PAUSE) && 1609 (pcs_lp_ability_reg & E1000_TXCW_ASM_DIR)) { 1610 hw->fc.current_mode = e1000_fc_tx_pause; 1611 DEBUGOUT("Flow Control = Tx PAUSE frames only.\n"); 1612 } 1613 /* For transmitting PAUSE frames ONLY. 1614 * 1615 * LOCAL DEVICE | LINK PARTNER 1616 * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result 1617 *-------|---------|-------|---------|-------------------- 1618 * 1 | 1 | 0 | 1 | e1000_fc_rx_pause 1619 */ 1620 else if ((pcs_adv_reg & E1000_TXCW_PAUSE) && 1621 (pcs_adv_reg & E1000_TXCW_ASM_DIR) && 1622 !(pcs_lp_ability_reg & E1000_TXCW_PAUSE) && 1623 (pcs_lp_ability_reg & E1000_TXCW_ASM_DIR)) { 1624 hw->fc.current_mode = e1000_fc_rx_pause; 1625 DEBUGOUT("Flow Control = Rx PAUSE frames only.\n"); 1626 } else { 1627 /* Per the IEEE spec, at this point flow control 1628 * should be disabled. 1629 */ 1630 hw->fc.current_mode = e1000_fc_none; 1631 DEBUGOUT("Flow Control = NONE.\n"); 1632 } 1633 1634 /* Now we call a subroutine to actually force the MAC 1635 * controller to use the correct flow control settings. 1636 */ 1637 pcs_ctrl_reg = E1000_READ_REG(hw, E1000_PCS_LCTL); 1638 pcs_ctrl_reg |= E1000_PCS_LCTL_FORCE_FCTRL; 1639 E1000_WRITE_REG(hw, E1000_PCS_LCTL, pcs_ctrl_reg); 1640 1641 ret_val = e1000_force_mac_fc_generic(hw); 1642 if (ret_val) { 1643 DEBUGOUT("Error forcing flow control settings\n"); 1644 return ret_val; 1645 } 1646 } 1647 1648 return E1000_SUCCESS; 1649 } 1650 1651 /** 1652 * e1000_get_speed_and_duplex_copper_generic - Retrieve current speed/duplex 1653 * @hw: pointer to the HW structure 1654 * @speed: stores the current speed 1655 * @duplex: stores the current duplex 1656 * 1657 * Read the status register for the current speed/duplex and store the current 1658 * speed and duplex for copper connections. 1659 **/ 1660 s32 e1000_get_speed_and_duplex_copper_generic(struct e1000_hw *hw, u16 *speed, 1661 u16 *duplex) 1662 { 1663 u32 status; 1664 1665 DEBUGFUNC("e1000_get_speed_and_duplex_copper_generic"); 1666 1667 status = E1000_READ_REG(hw, E1000_STATUS); 1668 if (status & E1000_STATUS_SPEED_1000) { 1669 *speed = SPEED_1000; 1670 DEBUGOUT("1000 Mbs, "); 1671 } else if (status & E1000_STATUS_SPEED_100) { 1672 *speed = SPEED_100; 1673 DEBUGOUT("100 Mbs, "); 1674 } else { 1675 *speed = SPEED_10; 1676 DEBUGOUT("10 Mbs, "); 1677 } 1678 1679 if (status & E1000_STATUS_FD) { 1680 *duplex = FULL_DUPLEX; 1681 DEBUGOUT("Full Duplex\n"); 1682 } else { 1683 *duplex = HALF_DUPLEX; 1684 DEBUGOUT("Half Duplex\n"); 1685 } 1686 1687 return E1000_SUCCESS; 1688 } 1689 1690 /** 1691 * e1000_get_speed_and_duplex_fiber_generic - Retrieve current speed/duplex 1692 * @hw: pointer to the HW structure 1693 * @speed: stores the current speed 1694 * @duplex: stores the current duplex 1695 * 1696 * Sets the speed and duplex to gigabit full duplex (the only possible option) 1697 * for fiber/serdes links. 1698 **/ 1699 s32 e1000_get_speed_and_duplex_fiber_serdes_generic(struct e1000_hw E1000_UNUSEDARG *hw, 1700 u16 *speed, u16 *duplex) 1701 { 1702 DEBUGFUNC("e1000_get_speed_and_duplex_fiber_serdes_generic"); 1703 1704 *speed = SPEED_1000; 1705 *duplex = FULL_DUPLEX; 1706 1707 return E1000_SUCCESS; 1708 } 1709 1710 /** 1711 * e1000_get_hw_semaphore_generic - Acquire hardware semaphore 1712 * @hw: pointer to the HW structure 1713 * 1714 * Acquire the HW semaphore to access the PHY or NVM 1715 **/ 1716 s32 e1000_get_hw_semaphore_generic(struct e1000_hw *hw) 1717 { 1718 u32 swsm; 1719 s32 timeout = hw->nvm.word_size + 1; 1720 s32 i = 0; 1721 1722 DEBUGFUNC("e1000_get_hw_semaphore_generic"); 1723 1724 /* Get the SW semaphore */ 1725 while (i < timeout) { 1726 swsm = E1000_READ_REG(hw, E1000_SWSM); 1727 if (!(swsm & E1000_SWSM_SMBI)) 1728 break; 1729 1730 usec_delay(50); 1731 i++; 1732 } 1733 1734 if (i == timeout) { 1735 DEBUGOUT("Driver can't access device - SMBI bit is set.\n"); 1736 return -E1000_ERR_NVM; 1737 } 1738 1739 /* Get the FW semaphore. */ 1740 for (i = 0; i < timeout; i++) { 1741 swsm = E1000_READ_REG(hw, E1000_SWSM); 1742 E1000_WRITE_REG(hw, E1000_SWSM, swsm | E1000_SWSM_SWESMBI); 1743 1744 /* Semaphore acquired if bit latched */ 1745 if (E1000_READ_REG(hw, E1000_SWSM) & E1000_SWSM_SWESMBI) 1746 break; 1747 1748 usec_delay(50); 1749 } 1750 1751 if (i == timeout) { 1752 /* Release semaphores */ 1753 e1000_put_hw_semaphore_generic(hw); 1754 DEBUGOUT("Driver can't access the NVM\n"); 1755 return -E1000_ERR_NVM; 1756 } 1757 1758 return E1000_SUCCESS; 1759 } 1760 1761 /** 1762 * e1000_put_hw_semaphore_generic - Release hardware semaphore 1763 * @hw: pointer to the HW structure 1764 * 1765 * Release hardware semaphore used to access the PHY or NVM 1766 **/ 1767 void e1000_put_hw_semaphore_generic(struct e1000_hw *hw) 1768 { 1769 u32 swsm; 1770 1771 DEBUGFUNC("e1000_put_hw_semaphore_generic"); 1772 1773 swsm = E1000_READ_REG(hw, E1000_SWSM); 1774 1775 swsm &= ~(E1000_SWSM_SMBI | E1000_SWSM_SWESMBI); 1776 1777 E1000_WRITE_REG(hw, E1000_SWSM, swsm); 1778 } 1779 1780 /** 1781 * e1000_get_auto_rd_done_generic - Check for auto read completion 1782 * @hw: pointer to the HW structure 1783 * 1784 * Check EEPROM for Auto Read done bit. 1785 **/ 1786 s32 e1000_get_auto_rd_done_generic(struct e1000_hw *hw) 1787 { 1788 s32 i = 0; 1789 1790 DEBUGFUNC("e1000_get_auto_rd_done_generic"); 1791 1792 while (i < AUTO_READ_DONE_TIMEOUT) { 1793 if (E1000_READ_REG(hw, E1000_EECD) & E1000_EECD_AUTO_RD) 1794 break; 1795 msec_delay(1); 1796 i++; 1797 } 1798 1799 if (i == AUTO_READ_DONE_TIMEOUT) { 1800 DEBUGOUT("Auto read by HW from NVM has not completed.\n"); 1801 return -E1000_ERR_RESET; 1802 } 1803 1804 return E1000_SUCCESS; 1805 } 1806 1807 /** 1808 * e1000_valid_led_default_generic - Verify a valid default LED config 1809 * @hw: pointer to the HW structure 1810 * @data: pointer to the NVM (EEPROM) 1811 * 1812 * Read the EEPROM for the current default LED configuration. If the 1813 * LED configuration is not valid, set to a valid LED configuration. 1814 **/ 1815 s32 e1000_valid_led_default_generic(struct e1000_hw *hw, u16 *data) 1816 { 1817 s32 ret_val; 1818 1819 DEBUGFUNC("e1000_valid_led_default_generic"); 1820 1821 ret_val = hw->nvm.ops.read(hw, NVM_ID_LED_SETTINGS, 1, data); 1822 if (ret_val) { 1823 DEBUGOUT("NVM Read Error\n"); 1824 return ret_val; 1825 } 1826 1827 if (*data == ID_LED_RESERVED_0000 || *data == ID_LED_RESERVED_FFFF) 1828 *data = ID_LED_DEFAULT; 1829 1830 return E1000_SUCCESS; 1831 } 1832 1833 /** 1834 * e1000_id_led_init_generic - 1835 * @hw: pointer to the HW structure 1836 * 1837 **/ 1838 s32 e1000_id_led_init_generic(struct e1000_hw *hw) 1839 { 1840 struct e1000_mac_info *mac = &hw->mac; 1841 s32 ret_val; 1842 const u32 ledctl_mask = 0x000000FF; 1843 const u32 ledctl_on = E1000_LEDCTL_MODE_LED_ON; 1844 const u32 ledctl_off = E1000_LEDCTL_MODE_LED_OFF; 1845 u16 data, i, temp; 1846 const u16 led_mask = 0x0F; 1847 1848 DEBUGFUNC("e1000_id_led_init_generic"); 1849 1850 ret_val = hw->nvm.ops.valid_led_default(hw, &data); 1851 if (ret_val) 1852 return ret_val; 1853 1854 mac->ledctl_default = E1000_READ_REG(hw, E1000_LEDCTL); 1855 mac->ledctl_mode1 = mac->ledctl_default; 1856 mac->ledctl_mode2 = mac->ledctl_default; 1857 1858 for (i = 0; i < 4; i++) { 1859 temp = (data >> (i << 2)) & led_mask; 1860 switch (temp) { 1861 case ID_LED_ON1_DEF2: 1862 case ID_LED_ON1_ON2: 1863 case ID_LED_ON1_OFF2: 1864 mac->ledctl_mode1 &= ~(ledctl_mask << (i << 3)); 1865 mac->ledctl_mode1 |= ledctl_on << (i << 3); 1866 break; 1867 case ID_LED_OFF1_DEF2: 1868 case ID_LED_OFF1_ON2: 1869 case ID_LED_OFF1_OFF2: 1870 mac->ledctl_mode1 &= ~(ledctl_mask << (i << 3)); 1871 mac->ledctl_mode1 |= ledctl_off << (i << 3); 1872 break; 1873 default: 1874 /* Do nothing */ 1875 break; 1876 } 1877 switch (temp) { 1878 case ID_LED_DEF1_ON2: 1879 case ID_LED_ON1_ON2: 1880 case ID_LED_OFF1_ON2: 1881 mac->ledctl_mode2 &= ~(ledctl_mask << (i << 3)); 1882 mac->ledctl_mode2 |= ledctl_on << (i << 3); 1883 break; 1884 case ID_LED_DEF1_OFF2: 1885 case ID_LED_ON1_OFF2: 1886 case ID_LED_OFF1_OFF2: 1887 mac->ledctl_mode2 &= ~(ledctl_mask << (i << 3)); 1888 mac->ledctl_mode2 |= ledctl_off << (i << 3); 1889 break; 1890 default: 1891 /* Do nothing */ 1892 break; 1893 } 1894 } 1895 1896 return E1000_SUCCESS; 1897 } 1898 1899 /** 1900 * e1000_setup_led_generic - Configures SW controllable LED 1901 * @hw: pointer to the HW structure 1902 * 1903 * This prepares the SW controllable LED for use and saves the current state 1904 * of the LED so it can be later restored. 1905 **/ 1906 s32 e1000_setup_led_generic(struct e1000_hw *hw) 1907 { 1908 u32 ledctl; 1909 1910 DEBUGFUNC("e1000_setup_led_generic"); 1911 1912 if (hw->mac.ops.setup_led != e1000_setup_led_generic) 1913 return -E1000_ERR_CONFIG; 1914 1915 if (hw->phy.media_type == e1000_media_type_fiber) { 1916 ledctl = E1000_READ_REG(hw, E1000_LEDCTL); 1917 hw->mac.ledctl_default = ledctl; 1918 /* Turn off LED0 */ 1919 ledctl &= ~(E1000_LEDCTL_LED0_IVRT | E1000_LEDCTL_LED0_BLINK | 1920 E1000_LEDCTL_LED0_MODE_MASK); 1921 ledctl |= (E1000_LEDCTL_MODE_LED_OFF << 1922 E1000_LEDCTL_LED0_MODE_SHIFT); 1923 E1000_WRITE_REG(hw, E1000_LEDCTL, ledctl); 1924 } else if (hw->phy.media_type == e1000_media_type_copper) { 1925 E1000_WRITE_REG(hw, E1000_LEDCTL, hw->mac.ledctl_mode1); 1926 } 1927 1928 return E1000_SUCCESS; 1929 } 1930 1931 /** 1932 * e1000_cleanup_led_generic - Set LED config to default operation 1933 * @hw: pointer to the HW structure 1934 * 1935 * Remove the current LED configuration and set the LED configuration 1936 * to the default value, saved from the EEPROM. 1937 **/ 1938 s32 e1000_cleanup_led_generic(struct e1000_hw *hw) 1939 { 1940 DEBUGFUNC("e1000_cleanup_led_generic"); 1941 1942 E1000_WRITE_REG(hw, E1000_LEDCTL, hw->mac.ledctl_default); 1943 return E1000_SUCCESS; 1944 } 1945 1946 /** 1947 * e1000_blink_led_generic - Blink LED 1948 * @hw: pointer to the HW structure 1949 * 1950 * Blink the LEDs which are set to be on. 1951 **/ 1952 s32 e1000_blink_led_generic(struct e1000_hw *hw) 1953 { 1954 u32 ledctl_blink = 0; 1955 u32 i; 1956 1957 DEBUGFUNC("e1000_blink_led_generic"); 1958 1959 if (hw->phy.media_type == e1000_media_type_fiber) { 1960 /* always blink LED0 for PCI-E fiber */ 1961 ledctl_blink = E1000_LEDCTL_LED0_BLINK | 1962 (E1000_LEDCTL_MODE_LED_ON << E1000_LEDCTL_LED0_MODE_SHIFT); 1963 } else { 1964 /* Set the blink bit for each LED that's "on" (0x0E) 1965 * (or "off" if inverted) in ledctl_mode2. The blink 1966 * logic in hardware only works when mode is set to "on" 1967 * so it must be changed accordingly when the mode is 1968 * "off" and inverted. 1969 */ 1970 ledctl_blink = hw->mac.ledctl_mode2; 1971 for (i = 0; i < 32; i += 8) { 1972 u32 mode = (hw->mac.ledctl_mode2 >> i) & 1973 E1000_LEDCTL_LED0_MODE_MASK; 1974 u32 led_default = hw->mac.ledctl_default >> i; 1975 1976 if ((!(led_default & E1000_LEDCTL_LED0_IVRT) && 1977 (mode == E1000_LEDCTL_MODE_LED_ON)) || 1978 ((led_default & E1000_LEDCTL_LED0_IVRT) && 1979 (mode == E1000_LEDCTL_MODE_LED_OFF))) { 1980 ledctl_blink &= 1981 ~(E1000_LEDCTL_LED0_MODE_MASK << i); 1982 ledctl_blink |= (E1000_LEDCTL_LED0_BLINK | 1983 E1000_LEDCTL_MODE_LED_ON) << i; 1984 } 1985 } 1986 } 1987 1988 E1000_WRITE_REG(hw, E1000_LEDCTL, ledctl_blink); 1989 1990 return E1000_SUCCESS; 1991 } 1992 1993 /** 1994 * e1000_led_on_generic - Turn LED on 1995 * @hw: pointer to the HW structure 1996 * 1997 * Turn LED on. 1998 **/ 1999 s32 e1000_led_on_generic(struct e1000_hw *hw) 2000 { 2001 u32 ctrl; 2002 2003 DEBUGFUNC("e1000_led_on_generic"); 2004 2005 switch (hw->phy.media_type) { 2006 case e1000_media_type_fiber: 2007 ctrl = E1000_READ_REG(hw, E1000_CTRL); 2008 ctrl &= ~E1000_CTRL_SWDPIN0; 2009 ctrl |= E1000_CTRL_SWDPIO0; 2010 E1000_WRITE_REG(hw, E1000_CTRL, ctrl); 2011 break; 2012 case e1000_media_type_copper: 2013 E1000_WRITE_REG(hw, E1000_LEDCTL, hw->mac.ledctl_mode2); 2014 break; 2015 default: 2016 break; 2017 } 2018 2019 return E1000_SUCCESS; 2020 } 2021 2022 /** 2023 * e1000_led_off_generic - Turn LED off 2024 * @hw: pointer to the HW structure 2025 * 2026 * Turn LED off. 2027 **/ 2028 s32 e1000_led_off_generic(struct e1000_hw *hw) 2029 { 2030 u32 ctrl; 2031 2032 DEBUGFUNC("e1000_led_off_generic"); 2033 2034 switch (hw->phy.media_type) { 2035 case e1000_media_type_fiber: 2036 ctrl = E1000_READ_REG(hw, E1000_CTRL); 2037 ctrl |= E1000_CTRL_SWDPIN0; 2038 ctrl |= E1000_CTRL_SWDPIO0; 2039 E1000_WRITE_REG(hw, E1000_CTRL, ctrl); 2040 break; 2041 case e1000_media_type_copper: 2042 E1000_WRITE_REG(hw, E1000_LEDCTL, hw->mac.ledctl_mode1); 2043 break; 2044 default: 2045 break; 2046 } 2047 2048 return E1000_SUCCESS; 2049 } 2050 2051 /** 2052 * e1000_set_pcie_no_snoop_generic - Set PCI-express capabilities 2053 * @hw: pointer to the HW structure 2054 * @no_snoop: bitmap of snoop events 2055 * 2056 * Set the PCI-express register to snoop for events enabled in 'no_snoop'. 2057 **/ 2058 void e1000_set_pcie_no_snoop_generic(struct e1000_hw *hw, u32 no_snoop) 2059 { 2060 u32 gcr; 2061 2062 DEBUGFUNC("e1000_set_pcie_no_snoop_generic"); 2063 2064 if (hw->bus.type != e1000_bus_type_pci_express) 2065 return; 2066 2067 if (no_snoop) { 2068 gcr = E1000_READ_REG(hw, E1000_GCR); 2069 gcr &= ~(PCIE_NO_SNOOP_ALL); 2070 gcr |= no_snoop; 2071 E1000_WRITE_REG(hw, E1000_GCR, gcr); 2072 } 2073 } 2074 2075 /** 2076 * e1000_disable_pcie_master_generic - Disables PCI-express master access 2077 * @hw: pointer to the HW structure 2078 * 2079 * Returns E1000_SUCCESS if successful, else returns -10 2080 * (-E1000_ERR_MASTER_REQUESTS_PENDING) if master disable bit has not caused 2081 * the master requests to be disabled. 2082 * 2083 * Disables PCI-Express master access and verifies there are no pending 2084 * requests. 2085 **/ 2086 s32 e1000_disable_pcie_master_generic(struct e1000_hw *hw) 2087 { 2088 u32 ctrl; 2089 s32 timeout = MASTER_DISABLE_TIMEOUT; 2090 2091 DEBUGFUNC("e1000_disable_pcie_master_generic"); 2092 2093 if (hw->bus.type != e1000_bus_type_pci_express) 2094 return E1000_SUCCESS; 2095 2096 ctrl = E1000_READ_REG(hw, E1000_CTRL); 2097 ctrl |= E1000_CTRL_GIO_MASTER_DISABLE; 2098 E1000_WRITE_REG(hw, E1000_CTRL, ctrl); 2099 2100 while (timeout) { 2101 if (!(E1000_READ_REG(hw, E1000_STATUS) & 2102 E1000_STATUS_GIO_MASTER_ENABLE) || 2103 E1000_REMOVED(hw->hw_addr)) 2104 break; 2105 usec_delay(100); 2106 timeout--; 2107 } 2108 2109 if (!timeout) { 2110 DEBUGOUT("Master requests are pending.\n"); 2111 return -E1000_ERR_MASTER_REQUESTS_PENDING; 2112 } 2113 2114 return E1000_SUCCESS; 2115 } 2116 2117 /** 2118 * e1000_reset_adaptive_generic - Reset Adaptive Interframe Spacing 2119 * @hw: pointer to the HW structure 2120 * 2121 * Reset the Adaptive Interframe Spacing throttle to default values. 2122 **/ 2123 void e1000_reset_adaptive_generic(struct e1000_hw *hw) 2124 { 2125 struct e1000_mac_info *mac = &hw->mac; 2126 2127 DEBUGFUNC("e1000_reset_adaptive_generic"); 2128 2129 if (!mac->adaptive_ifs) { 2130 DEBUGOUT("Not in Adaptive IFS mode!\n"); 2131 return; 2132 } 2133 2134 mac->current_ifs_val = 0; 2135 mac->ifs_min_val = IFS_MIN; 2136 mac->ifs_max_val = IFS_MAX; 2137 mac->ifs_step_size = IFS_STEP; 2138 mac->ifs_ratio = IFS_RATIO; 2139 2140 mac->in_ifs_mode = FALSE; 2141 E1000_WRITE_REG(hw, E1000_AIT, 0); 2142 } 2143 2144 /** 2145 * e1000_update_adaptive_generic - Update Adaptive Interframe Spacing 2146 * @hw: pointer to the HW structure 2147 * 2148 * Update the Adaptive Interframe Spacing Throttle value based on the 2149 * time between transmitted packets and time between collisions. 2150 **/ 2151 void e1000_update_adaptive_generic(struct e1000_hw *hw) 2152 { 2153 struct e1000_mac_info *mac = &hw->mac; 2154 2155 DEBUGFUNC("e1000_update_adaptive_generic"); 2156 2157 if (!mac->adaptive_ifs) { 2158 DEBUGOUT("Not in Adaptive IFS mode!\n"); 2159 return; 2160 } 2161 2162 if ((mac->collision_delta * mac->ifs_ratio) > mac->tx_packet_delta) { 2163 if (mac->tx_packet_delta > MIN_NUM_XMITS) { 2164 mac->in_ifs_mode = TRUE; 2165 if (mac->current_ifs_val < mac->ifs_max_val) { 2166 if (!mac->current_ifs_val) 2167 mac->current_ifs_val = mac->ifs_min_val; 2168 else 2169 mac->current_ifs_val += 2170 mac->ifs_step_size; 2171 E1000_WRITE_REG(hw, E1000_AIT, 2172 mac->current_ifs_val); 2173 } 2174 } 2175 } else { 2176 if (mac->in_ifs_mode && 2177 (mac->tx_packet_delta <= MIN_NUM_XMITS)) { 2178 mac->current_ifs_val = 0; 2179 mac->in_ifs_mode = FALSE; 2180 E1000_WRITE_REG(hw, E1000_AIT, 0); 2181 } 2182 } 2183 } 2184 2185 /** 2186 * e1000_validate_mdi_setting_generic - Verify MDI/MDIx settings 2187 * @hw: pointer to the HW structure 2188 * 2189 * Verify that when not using auto-negotiation that MDI/MDIx is correctly 2190 * set, which is forced to MDI mode only. 2191 **/ 2192 static s32 e1000_validate_mdi_setting_generic(struct e1000_hw *hw) 2193 { 2194 DEBUGFUNC("e1000_validate_mdi_setting_generic"); 2195 2196 if (!hw->mac.autoneg && (hw->phy.mdix == 0 || hw->phy.mdix == 3)) { 2197 DEBUGOUT("Invalid MDI setting detected\n"); 2198 hw->phy.mdix = 1; 2199 return -E1000_ERR_CONFIG; 2200 } 2201 2202 return E1000_SUCCESS; 2203 } 2204 2205 /** 2206 * e1000_validate_mdi_setting_crossover_generic - Verify MDI/MDIx settings 2207 * @hw: pointer to the HW structure 2208 * 2209 * Validate the MDI/MDIx setting, allowing for auto-crossover during forced 2210 * operation. 2211 **/ 2212 s32 e1000_validate_mdi_setting_crossover_generic(struct e1000_hw E1000_UNUSEDARG *hw) 2213 { 2214 DEBUGFUNC("e1000_validate_mdi_setting_crossover_generic"); 2215 2216 return E1000_SUCCESS; 2217 } 2218 2219 /** 2220 * e1000_write_8bit_ctrl_reg_generic - Write a 8bit CTRL register 2221 * @hw: pointer to the HW structure 2222 * @reg: 32bit register offset such as E1000_SCTL 2223 * @offset: register offset to write to 2224 * @data: data to write at register offset 2225 * 2226 * Writes an address/data control type register. There are several of these 2227 * and they all have the format address << 8 | data and bit 31 is polled for 2228 * completion. 2229 **/ 2230 s32 e1000_write_8bit_ctrl_reg_generic(struct e1000_hw *hw, u32 reg, 2231 u32 offset, u8 data) 2232 { 2233 u32 i, regvalue = 0; 2234 2235 DEBUGFUNC("e1000_write_8bit_ctrl_reg_generic"); 2236 2237 /* Set up the address and data */ 2238 regvalue = ((u32)data) | (offset << E1000_GEN_CTL_ADDRESS_SHIFT); 2239 E1000_WRITE_REG(hw, reg, regvalue); 2240 2241 /* Poll the ready bit to see if the MDI read completed */ 2242 for (i = 0; i < E1000_GEN_POLL_TIMEOUT; i++) { 2243 usec_delay(5); 2244 regvalue = E1000_READ_REG(hw, reg); 2245 if (regvalue & E1000_GEN_CTL_READY) 2246 break; 2247 } 2248 if (!(regvalue & E1000_GEN_CTL_READY)) { 2249 DEBUGOUT1("Reg %08x did not indicate ready\n", reg); 2250 return -E1000_ERR_PHY; 2251 } 2252 2253 return E1000_SUCCESS; 2254 } 2255