1 /****************************************************************************** 2 3 Copyright (c) 2001-2010, Intel Corporation 4 All rights reserved. 5 6 Redistribution and use in source and binary forms, with or without 7 modification, are permitted provided that the following conditions are met: 8 9 1. Redistributions of source code must retain the above copyright notice, 10 this list of conditions and the following disclaimer. 11 12 2. Redistributions in binary form must reproduce the above copyright 13 notice, this list of conditions and the following disclaimer in the 14 documentation and/or other materials provided with the distribution. 15 16 3. Neither the name of the Intel Corporation nor the names of its 17 contributors may be used to endorse or promote products derived from 18 this software without specific prior written permission. 19 20 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 21 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 22 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 23 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 24 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 25 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 26 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 27 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 28 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 29 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 30 POSSIBILITY OF SUCH DAMAGE. 31 32 ******************************************************************************/ 33 /*$FreeBSD$*/ 34 35 #include "e1000_api.h" 36 37 /** 38 * e1000_init_mac_params - Initialize MAC function pointers 39 * @hw: pointer to the HW structure 40 * 41 * This function initializes the function pointers for the MAC 42 * set of functions. Called by drivers or by e1000_setup_init_funcs. 43 **/ 44 s32 e1000_init_mac_params(struct e1000_hw *hw) 45 { 46 s32 ret_val = E1000_SUCCESS; 47 48 if (hw->mac.ops.init_params) { 49 ret_val = hw->mac.ops.init_params(hw); 50 if (ret_val) { 51 DEBUGOUT("MAC Initialization Error\n"); 52 goto out; 53 } 54 } else { 55 DEBUGOUT("mac.init_mac_params was NULL\n"); 56 ret_val = -E1000_ERR_CONFIG; 57 } 58 59 out: 60 return ret_val; 61 } 62 63 /** 64 * e1000_init_nvm_params - Initialize NVM function pointers 65 * @hw: pointer to the HW structure 66 * 67 * This function initializes the function pointers for the NVM 68 * set of functions. Called by drivers or by e1000_setup_init_funcs. 69 **/ 70 s32 e1000_init_nvm_params(struct e1000_hw *hw) 71 { 72 s32 ret_val = E1000_SUCCESS; 73 74 if (hw->nvm.ops.init_params) { 75 ret_val = hw->nvm.ops.init_params(hw); 76 if (ret_val) { 77 DEBUGOUT("NVM Initialization Error\n"); 78 goto out; 79 } 80 } else { 81 DEBUGOUT("nvm.init_nvm_params was NULL\n"); 82 ret_val = -E1000_ERR_CONFIG; 83 } 84 85 out: 86 return ret_val; 87 } 88 89 /** 90 * e1000_init_phy_params - Initialize PHY function pointers 91 * @hw: pointer to the HW structure 92 * 93 * This function initializes the function pointers for the PHY 94 * set of functions. Called by drivers or by e1000_setup_init_funcs. 95 **/ 96 s32 e1000_init_phy_params(struct e1000_hw *hw) 97 { 98 s32 ret_val = E1000_SUCCESS; 99 100 if (hw->phy.ops.init_params) { 101 ret_val = hw->phy.ops.init_params(hw); 102 if (ret_val) { 103 DEBUGOUT("PHY Initialization Error\n"); 104 goto out; 105 } 106 } else { 107 DEBUGOUT("phy.init_phy_params was NULL\n"); 108 ret_val = -E1000_ERR_CONFIG; 109 } 110 111 out: 112 return ret_val; 113 } 114 115 /** 116 * e1000_init_mbx_params - Initialize mailbox function pointers 117 * @hw: pointer to the HW structure 118 * 119 * This function initializes the function pointers for the PHY 120 * set of functions. Called by drivers or by e1000_setup_init_funcs. 121 **/ 122 s32 e1000_init_mbx_params(struct e1000_hw *hw) 123 { 124 s32 ret_val = E1000_SUCCESS; 125 126 if (hw->mbx.ops.init_params) { 127 ret_val = hw->mbx.ops.init_params(hw); 128 if (ret_val) { 129 DEBUGOUT("Mailbox Initialization Error\n"); 130 goto out; 131 } 132 } else { 133 DEBUGOUT("mbx.init_mbx_params was NULL\n"); 134 ret_val = -E1000_ERR_CONFIG; 135 } 136 137 out: 138 return ret_val; 139 } 140 141 /** 142 * e1000_set_mac_type - Sets MAC type 143 * @hw: pointer to the HW structure 144 * 145 * This function sets the mac type of the adapter based on the 146 * device ID stored in the hw structure. 147 * MUST BE FIRST FUNCTION CALLED (explicitly or through 148 * e1000_setup_init_funcs()). 149 **/ 150 s32 e1000_set_mac_type(struct e1000_hw *hw) 151 { 152 struct e1000_mac_info *mac = &hw->mac; 153 s32 ret_val = E1000_SUCCESS; 154 155 DEBUGFUNC("e1000_set_mac_type"); 156 157 switch (hw->device_id) { 158 case E1000_DEV_ID_82542: 159 mac->type = e1000_82542; 160 break; 161 case E1000_DEV_ID_82543GC_FIBER: 162 case E1000_DEV_ID_82543GC_COPPER: 163 mac->type = e1000_82543; 164 break; 165 case E1000_DEV_ID_82544EI_COPPER: 166 case E1000_DEV_ID_82544EI_FIBER: 167 case E1000_DEV_ID_82544GC_COPPER: 168 case E1000_DEV_ID_82544GC_LOM: 169 mac->type = e1000_82544; 170 break; 171 case E1000_DEV_ID_82540EM: 172 case E1000_DEV_ID_82540EM_LOM: 173 case E1000_DEV_ID_82540EP: 174 case E1000_DEV_ID_82540EP_LOM: 175 case E1000_DEV_ID_82540EP_LP: 176 mac->type = e1000_82540; 177 break; 178 case E1000_DEV_ID_82545EM_COPPER: 179 case E1000_DEV_ID_82545EM_FIBER: 180 mac->type = e1000_82545; 181 break; 182 case E1000_DEV_ID_82545GM_COPPER: 183 case E1000_DEV_ID_82545GM_FIBER: 184 case E1000_DEV_ID_82545GM_SERDES: 185 mac->type = e1000_82545_rev_3; 186 break; 187 case E1000_DEV_ID_82546EB_COPPER: 188 case E1000_DEV_ID_82546EB_FIBER: 189 case E1000_DEV_ID_82546EB_QUAD_COPPER: 190 mac->type = e1000_82546; 191 break; 192 case E1000_DEV_ID_82546GB_COPPER: 193 case E1000_DEV_ID_82546GB_FIBER: 194 case E1000_DEV_ID_82546GB_SERDES: 195 case E1000_DEV_ID_82546GB_PCIE: 196 case E1000_DEV_ID_82546GB_QUAD_COPPER: 197 case E1000_DEV_ID_82546GB_QUAD_COPPER_KSP3: 198 mac->type = e1000_82546_rev_3; 199 break; 200 case E1000_DEV_ID_82541EI: 201 case E1000_DEV_ID_82541EI_MOBILE: 202 case E1000_DEV_ID_82541ER_LOM: 203 mac->type = e1000_82541; 204 break; 205 case E1000_DEV_ID_82541ER: 206 case E1000_DEV_ID_82541GI: 207 case E1000_DEV_ID_82541GI_LF: 208 case E1000_DEV_ID_82541GI_MOBILE: 209 mac->type = e1000_82541_rev_2; 210 break; 211 case E1000_DEV_ID_82547EI: 212 case E1000_DEV_ID_82547EI_MOBILE: 213 mac->type = e1000_82547; 214 break; 215 case E1000_DEV_ID_82547GI: 216 mac->type = e1000_82547_rev_2; 217 break; 218 case E1000_DEV_ID_82571EB_COPPER: 219 case E1000_DEV_ID_82571EB_FIBER: 220 case E1000_DEV_ID_82571EB_SERDES: 221 case E1000_DEV_ID_82571EB_SERDES_DUAL: 222 case E1000_DEV_ID_82571EB_SERDES_QUAD: 223 case E1000_DEV_ID_82571EB_QUAD_COPPER: 224 case E1000_DEV_ID_82571PT_QUAD_COPPER: 225 case E1000_DEV_ID_82571EB_QUAD_FIBER: 226 case E1000_DEV_ID_82571EB_QUAD_COPPER_LP: 227 mac->type = e1000_82571; 228 break; 229 case E1000_DEV_ID_82572EI: 230 case E1000_DEV_ID_82572EI_COPPER: 231 case E1000_DEV_ID_82572EI_FIBER: 232 case E1000_DEV_ID_82572EI_SERDES: 233 mac->type = e1000_82572; 234 break; 235 case E1000_DEV_ID_82573E: 236 case E1000_DEV_ID_82573E_IAMT: 237 case E1000_DEV_ID_82573L: 238 mac->type = e1000_82573; 239 break; 240 case E1000_DEV_ID_82574L: 241 case E1000_DEV_ID_82574LA: 242 mac->type = e1000_82574; 243 break; 244 case E1000_DEV_ID_82583V: 245 mac->type = e1000_82583; 246 break; 247 case E1000_DEV_ID_80003ES2LAN_COPPER_DPT: 248 case E1000_DEV_ID_80003ES2LAN_SERDES_DPT: 249 case E1000_DEV_ID_80003ES2LAN_COPPER_SPT: 250 case E1000_DEV_ID_80003ES2LAN_SERDES_SPT: 251 mac->type = e1000_80003es2lan; 252 break; 253 case E1000_DEV_ID_ICH8_IFE: 254 case E1000_DEV_ID_ICH8_IFE_GT: 255 case E1000_DEV_ID_ICH8_IFE_G: 256 case E1000_DEV_ID_ICH8_IGP_M: 257 case E1000_DEV_ID_ICH8_IGP_M_AMT: 258 case E1000_DEV_ID_ICH8_IGP_AMT: 259 case E1000_DEV_ID_ICH8_IGP_C: 260 case E1000_DEV_ID_ICH8_82567V_3: 261 mac->type = e1000_ich8lan; 262 break; 263 case E1000_DEV_ID_ICH9_IFE: 264 case E1000_DEV_ID_ICH9_IFE_GT: 265 case E1000_DEV_ID_ICH9_IFE_G: 266 case E1000_DEV_ID_ICH9_IGP_M: 267 case E1000_DEV_ID_ICH9_IGP_M_AMT: 268 case E1000_DEV_ID_ICH9_IGP_M_V: 269 case E1000_DEV_ID_ICH9_IGP_AMT: 270 case E1000_DEV_ID_ICH9_BM: 271 case E1000_DEV_ID_ICH9_IGP_C: 272 case E1000_DEV_ID_ICH10_R_BM_LM: 273 case E1000_DEV_ID_ICH10_R_BM_LF: 274 case E1000_DEV_ID_ICH10_R_BM_V: 275 mac->type = e1000_ich9lan; 276 break; 277 case E1000_DEV_ID_ICH10_D_BM_LM: 278 case E1000_DEV_ID_ICH10_D_BM_LF: 279 mac->type = e1000_ich10lan; 280 break; 281 case E1000_DEV_ID_PCH_D_HV_DM: 282 case E1000_DEV_ID_PCH_D_HV_DC: 283 case E1000_DEV_ID_PCH_M_HV_LM: 284 case E1000_DEV_ID_PCH_M_HV_LC: 285 mac->type = e1000_pchlan; 286 break; 287 case E1000_DEV_ID_82575EB_COPPER: 288 case E1000_DEV_ID_82575EB_FIBER_SERDES: 289 case E1000_DEV_ID_82575GB_QUAD_COPPER: 290 case E1000_DEV_ID_82575GB_QUAD_COPPER_PM: 291 mac->type = e1000_82575; 292 break; 293 case E1000_DEV_ID_82576: 294 case E1000_DEV_ID_82576_FIBER: 295 case E1000_DEV_ID_82576_SERDES: 296 case E1000_DEV_ID_82576_QUAD_COPPER: 297 case E1000_DEV_ID_82576_NS: 298 case E1000_DEV_ID_82576_NS_SERDES: 299 case E1000_DEV_ID_82576_SERDES_QUAD: 300 mac->type = e1000_82576; 301 break; 302 case E1000_DEV_ID_82580_COPPER: 303 case E1000_DEV_ID_82580_FIBER: 304 case E1000_DEV_ID_82580_SERDES: 305 case E1000_DEV_ID_82580_SGMII: 306 case E1000_DEV_ID_82580_COPPER_DUAL: 307 mac->type = e1000_82580; 308 break; 309 case E1000_DEV_ID_82576_VF: 310 mac->type = e1000_vfadapt; 311 break; 312 default: 313 /* Should never have loaded on this device */ 314 ret_val = -E1000_ERR_MAC_INIT; 315 break; 316 } 317 318 return ret_val; 319 } 320 321 /** 322 * e1000_setup_init_funcs - Initializes function pointers 323 * @hw: pointer to the HW structure 324 * @init_device: TRUE will initialize the rest of the function pointers 325 * getting the device ready for use. FALSE will only set 326 * MAC type and the function pointers for the other init 327 * functions. Passing FALSE will not generate any hardware 328 * reads or writes. 329 * 330 * This function must be called by a driver in order to use the rest 331 * of the 'shared' code files. Called by drivers only. 332 **/ 333 s32 e1000_setup_init_funcs(struct e1000_hw *hw, bool init_device) 334 { 335 s32 ret_val; 336 337 /* Can't do much good without knowing the MAC type. */ 338 ret_val = e1000_set_mac_type(hw); 339 if (ret_val) { 340 DEBUGOUT("ERROR: MAC type could not be set properly.\n"); 341 goto out; 342 } 343 344 if (!hw->hw_addr) { 345 DEBUGOUT("ERROR: Registers not mapped\n"); 346 ret_val = -E1000_ERR_CONFIG; 347 goto out; 348 } 349 350 /* 351 * Init function pointers to generic implementations. We do this first 352 * allowing a driver module to override it afterward. 353 */ 354 e1000_init_mac_ops_generic(hw); 355 e1000_init_phy_ops_generic(hw); 356 e1000_init_nvm_ops_generic(hw); 357 e1000_init_mbx_ops_generic(hw); 358 359 /* 360 * Set up the init function pointers. These are functions within the 361 * adapter family file that sets up function pointers for the rest of 362 * the functions in that family. 363 */ 364 switch (hw->mac.type) { 365 case e1000_82542: 366 e1000_init_function_pointers_82542(hw); 367 break; 368 case e1000_82543: 369 case e1000_82544: 370 e1000_init_function_pointers_82543(hw); 371 break; 372 case e1000_82540: 373 case e1000_82545: 374 case e1000_82545_rev_3: 375 case e1000_82546: 376 case e1000_82546_rev_3: 377 e1000_init_function_pointers_82540(hw); 378 break; 379 case e1000_82541: 380 case e1000_82541_rev_2: 381 case e1000_82547: 382 case e1000_82547_rev_2: 383 e1000_init_function_pointers_82541(hw); 384 break; 385 case e1000_82571: 386 case e1000_82572: 387 case e1000_82573: 388 case e1000_82574: 389 case e1000_82583: 390 e1000_init_function_pointers_82571(hw); 391 break; 392 case e1000_80003es2lan: 393 e1000_init_function_pointers_80003es2lan(hw); 394 break; 395 case e1000_ich8lan: 396 case e1000_ich9lan: 397 case e1000_ich10lan: 398 case e1000_pchlan: 399 e1000_init_function_pointers_ich8lan(hw); 400 break; 401 case e1000_82575: 402 case e1000_82576: 403 case e1000_82580: 404 e1000_init_function_pointers_82575(hw); 405 break; 406 case e1000_vfadapt: 407 e1000_init_function_pointers_vf(hw); 408 break; 409 default: 410 DEBUGOUT("Hardware not supported\n"); 411 ret_val = -E1000_ERR_CONFIG; 412 break; 413 } 414 415 /* 416 * Initialize the rest of the function pointers. These require some 417 * register reads/writes in some cases. 418 */ 419 if (!(ret_val) && init_device) { 420 ret_val = e1000_init_mac_params(hw); 421 if (ret_val) 422 goto out; 423 424 ret_val = e1000_init_nvm_params(hw); 425 if (ret_val) 426 goto out; 427 428 ret_val = e1000_init_phy_params(hw); 429 if (ret_val) 430 goto out; 431 432 ret_val = e1000_init_mbx_params(hw); 433 if (ret_val) 434 goto out; 435 } 436 437 out: 438 return ret_val; 439 } 440 441 /** 442 * e1000_get_bus_info - Obtain bus information for adapter 443 * @hw: pointer to the HW structure 444 * 445 * This will obtain information about the HW bus for which the 446 * adapter is attached and stores it in the hw structure. This is a 447 * function pointer entry point called by drivers. 448 **/ 449 s32 e1000_get_bus_info(struct e1000_hw *hw) 450 { 451 if (hw->mac.ops.get_bus_info) 452 return hw->mac.ops.get_bus_info(hw); 453 454 return E1000_SUCCESS; 455 } 456 457 /** 458 * e1000_clear_vfta - Clear VLAN filter table 459 * @hw: pointer to the HW structure 460 * 461 * This clears the VLAN filter table on the adapter. This is a function 462 * pointer entry point called by drivers. 463 **/ 464 void e1000_clear_vfta(struct e1000_hw *hw) 465 { 466 if (hw->mac.ops.clear_vfta) 467 hw->mac.ops.clear_vfta(hw); 468 } 469 470 /** 471 * e1000_write_vfta - Write value to VLAN filter table 472 * @hw: pointer to the HW structure 473 * @offset: the 32-bit offset in which to write the value to. 474 * @value: the 32-bit value to write at location offset. 475 * 476 * This writes a 32-bit value to a 32-bit offset in the VLAN filter 477 * table. This is a function pointer entry point called by drivers. 478 **/ 479 void e1000_write_vfta(struct e1000_hw *hw, u32 offset, u32 value) 480 { 481 if (hw->mac.ops.write_vfta) 482 hw->mac.ops.write_vfta(hw, offset, value); 483 } 484 485 /** 486 * e1000_update_mc_addr_list - Update Multicast addresses 487 * @hw: pointer to the HW structure 488 * @mc_addr_list: array of multicast addresses to program 489 * @mc_addr_count: number of multicast addresses to program 490 * 491 * Updates the Multicast Table Array. 492 * The caller must have a packed mc_addr_list of multicast addresses. 493 **/ 494 void e1000_update_mc_addr_list(struct e1000_hw *hw, u8 *mc_addr_list, 495 u32 mc_addr_count) 496 { 497 if (hw->mac.ops.update_mc_addr_list) 498 hw->mac.ops.update_mc_addr_list(hw, mc_addr_list, 499 mc_addr_count); 500 } 501 502 /** 503 * e1000_force_mac_fc - Force MAC flow control 504 * @hw: pointer to the HW structure 505 * 506 * Force the MAC's flow control settings. Currently no func pointer exists 507 * and all implementations are handled in the generic version of this 508 * function. 509 **/ 510 s32 e1000_force_mac_fc(struct e1000_hw *hw) 511 { 512 return e1000_force_mac_fc_generic(hw); 513 } 514 515 /** 516 * e1000_check_for_link - Check/Store link connection 517 * @hw: pointer to the HW structure 518 * 519 * This checks the link condition of the adapter and stores the 520 * results in the hw->mac structure. This is a function pointer entry 521 * point called by drivers. 522 **/ 523 s32 e1000_check_for_link(struct e1000_hw *hw) 524 { 525 if (hw->mac.ops.check_for_link) 526 return hw->mac.ops.check_for_link(hw); 527 528 return -E1000_ERR_CONFIG; 529 } 530 531 /** 532 * e1000_check_mng_mode - Check management mode 533 * @hw: pointer to the HW structure 534 * 535 * This checks if the adapter has manageability enabled. 536 * This is a function pointer entry point called by drivers. 537 **/ 538 bool e1000_check_mng_mode(struct e1000_hw *hw) 539 { 540 if (hw->mac.ops.check_mng_mode) 541 return hw->mac.ops.check_mng_mode(hw); 542 543 return FALSE; 544 } 545 546 /** 547 * e1000_mng_write_dhcp_info - Writes DHCP info to host interface 548 * @hw: pointer to the HW structure 549 * @buffer: pointer to the host interface 550 * @length: size of the buffer 551 * 552 * Writes the DHCP information to the host interface. 553 **/ 554 s32 e1000_mng_write_dhcp_info(struct e1000_hw *hw, u8 *buffer, u16 length) 555 { 556 return e1000_mng_write_dhcp_info_generic(hw, buffer, length); 557 } 558 559 /** 560 * e1000_reset_hw - Reset hardware 561 * @hw: pointer to the HW structure 562 * 563 * This resets the hardware into a known state. This is a function pointer 564 * entry point called by drivers. 565 **/ 566 s32 e1000_reset_hw(struct e1000_hw *hw) 567 { 568 if (hw->mac.ops.reset_hw) 569 return hw->mac.ops.reset_hw(hw); 570 571 return -E1000_ERR_CONFIG; 572 } 573 574 /** 575 * e1000_init_hw - Initialize hardware 576 * @hw: pointer to the HW structure 577 * 578 * This inits the hardware readying it for operation. This is a function 579 * pointer entry point called by drivers. 580 **/ 581 s32 e1000_init_hw(struct e1000_hw *hw) 582 { 583 if (hw->mac.ops.init_hw) 584 return hw->mac.ops.init_hw(hw); 585 586 return -E1000_ERR_CONFIG; 587 } 588 589 /** 590 * e1000_setup_link - Configures link and flow control 591 * @hw: pointer to the HW structure 592 * 593 * This configures link and flow control settings for the adapter. This 594 * is a function pointer entry point called by drivers. While modules can 595 * also call this, they probably call their own version of this function. 596 **/ 597 s32 e1000_setup_link(struct e1000_hw *hw) 598 { 599 if (hw->mac.ops.setup_link) 600 return hw->mac.ops.setup_link(hw); 601 602 return -E1000_ERR_CONFIG; 603 } 604 605 /** 606 * e1000_get_speed_and_duplex - Returns current speed and duplex 607 * @hw: pointer to the HW structure 608 * @speed: pointer to a 16-bit value to store the speed 609 * @duplex: pointer to a 16-bit value to store the duplex. 610 * 611 * This returns the speed and duplex of the adapter in the two 'out' 612 * variables passed in. This is a function pointer entry point called 613 * by drivers. 614 **/ 615 s32 e1000_get_speed_and_duplex(struct e1000_hw *hw, u16 *speed, u16 *duplex) 616 { 617 if (hw->mac.ops.get_link_up_info) 618 return hw->mac.ops.get_link_up_info(hw, speed, duplex); 619 620 return -E1000_ERR_CONFIG; 621 } 622 623 /** 624 * e1000_setup_led - Configures SW controllable LED 625 * @hw: pointer to the HW structure 626 * 627 * This prepares the SW controllable LED for use and saves the current state 628 * of the LED so it can be later restored. This is a function pointer entry 629 * point called by drivers. 630 **/ 631 s32 e1000_setup_led(struct e1000_hw *hw) 632 { 633 if (hw->mac.ops.setup_led) 634 return hw->mac.ops.setup_led(hw); 635 636 return E1000_SUCCESS; 637 } 638 639 /** 640 * e1000_cleanup_led - Restores SW controllable LED 641 * @hw: pointer to the HW structure 642 * 643 * This restores the SW controllable LED to the value saved off by 644 * e1000_setup_led. This is a function pointer entry point called by drivers. 645 **/ 646 s32 e1000_cleanup_led(struct e1000_hw *hw) 647 { 648 if (hw->mac.ops.cleanup_led) 649 return hw->mac.ops.cleanup_led(hw); 650 651 return E1000_SUCCESS; 652 } 653 654 /** 655 * e1000_blink_led - Blink SW controllable LED 656 * @hw: pointer to the HW structure 657 * 658 * This starts the adapter LED blinking. Request the LED to be setup first 659 * and cleaned up after. This is a function pointer entry point called by 660 * drivers. 661 **/ 662 s32 e1000_blink_led(struct e1000_hw *hw) 663 { 664 if (hw->mac.ops.blink_led) 665 return hw->mac.ops.blink_led(hw); 666 667 return E1000_SUCCESS; 668 } 669 670 /** 671 * e1000_id_led_init - store LED configurations in SW 672 * @hw: pointer to the HW structure 673 * 674 * Initializes the LED config in SW. This is a function pointer entry point 675 * called by drivers. 676 **/ 677 s32 e1000_id_led_init(struct e1000_hw *hw) 678 { 679 if (hw->mac.ops.id_led_init) 680 return hw->mac.ops.id_led_init(hw); 681 682 return E1000_SUCCESS; 683 } 684 685 /** 686 * e1000_led_on - Turn on SW controllable LED 687 * @hw: pointer to the HW structure 688 * 689 * Turns the SW defined LED on. This is a function pointer entry point 690 * called by drivers. 691 **/ 692 s32 e1000_led_on(struct e1000_hw *hw) 693 { 694 if (hw->mac.ops.led_on) 695 return hw->mac.ops.led_on(hw); 696 697 return E1000_SUCCESS; 698 } 699 700 /** 701 * e1000_led_off - Turn off SW controllable LED 702 * @hw: pointer to the HW structure 703 * 704 * Turns the SW defined LED off. This is a function pointer entry point 705 * called by drivers. 706 **/ 707 s32 e1000_led_off(struct e1000_hw *hw) 708 { 709 if (hw->mac.ops.led_off) 710 return hw->mac.ops.led_off(hw); 711 712 return E1000_SUCCESS; 713 } 714 715 /** 716 * e1000_reset_adaptive - Reset adaptive IFS 717 * @hw: pointer to the HW structure 718 * 719 * Resets the adaptive IFS. Currently no func pointer exists and all 720 * implementations are handled in the generic version of this function. 721 **/ 722 void e1000_reset_adaptive(struct e1000_hw *hw) 723 { 724 e1000_reset_adaptive_generic(hw); 725 } 726 727 /** 728 * e1000_update_adaptive - Update adaptive IFS 729 * @hw: pointer to the HW structure 730 * 731 * Updates adapter IFS. Currently no func pointer exists and all 732 * implementations are handled in the generic version of this function. 733 **/ 734 void e1000_update_adaptive(struct e1000_hw *hw) 735 { 736 e1000_update_adaptive_generic(hw); 737 } 738 739 /** 740 * e1000_disable_pcie_master - Disable PCI-Express master access 741 * @hw: pointer to the HW structure 742 * 743 * Disables PCI-Express master access and verifies there are no pending 744 * requests. Currently no func pointer exists and all implementations are 745 * handled in the generic version of this function. 746 **/ 747 s32 e1000_disable_pcie_master(struct e1000_hw *hw) 748 { 749 return e1000_disable_pcie_master_generic(hw); 750 } 751 752 /** 753 * e1000_config_collision_dist - Configure collision distance 754 * @hw: pointer to the HW structure 755 * 756 * Configures the collision distance to the default value and is used 757 * during link setup. 758 **/ 759 void e1000_config_collision_dist(struct e1000_hw *hw) 760 { 761 if (hw->mac.ops.config_collision_dist) 762 hw->mac.ops.config_collision_dist(hw); 763 } 764 765 /** 766 * e1000_rar_set - Sets a receive address register 767 * @hw: pointer to the HW structure 768 * @addr: address to set the RAR to 769 * @index: the RAR to set 770 * 771 * Sets a Receive Address Register (RAR) to the specified address. 772 **/ 773 void e1000_rar_set(struct e1000_hw *hw, u8 *addr, u32 index) 774 { 775 if (hw->mac.ops.rar_set) 776 hw->mac.ops.rar_set(hw, addr, index); 777 } 778 779 /** 780 * e1000_validate_mdi_setting - Ensures valid MDI/MDIX SW state 781 * @hw: pointer to the HW structure 782 * 783 * Ensures that the MDI/MDIX SW state is valid. 784 **/ 785 s32 e1000_validate_mdi_setting(struct e1000_hw *hw) 786 { 787 if (hw->mac.ops.validate_mdi_setting) 788 return hw->mac.ops.validate_mdi_setting(hw); 789 790 return E1000_SUCCESS; 791 } 792 793 /** 794 * e1000_hash_mc_addr - Determines address location in multicast table 795 * @hw: pointer to the HW structure 796 * @mc_addr: Multicast address to hash. 797 * 798 * This hashes an address to determine its location in the multicast 799 * table. Currently no func pointer exists and all implementations 800 * are handled in the generic version of this function. 801 **/ 802 u32 e1000_hash_mc_addr(struct e1000_hw *hw, u8 *mc_addr) 803 { 804 return e1000_hash_mc_addr_generic(hw, mc_addr); 805 } 806 807 /** 808 * e1000_enable_tx_pkt_filtering - Enable packet filtering on TX 809 * @hw: pointer to the HW structure 810 * 811 * Enables packet filtering on transmit packets if manageability is enabled 812 * and host interface is enabled. 813 * Currently no func pointer exists and all implementations are handled in the 814 * generic version of this function. 815 **/ 816 bool e1000_enable_tx_pkt_filtering(struct e1000_hw *hw) 817 { 818 return e1000_enable_tx_pkt_filtering_generic(hw); 819 } 820 821 /** 822 * e1000_mng_host_if_write - Writes to the manageability host interface 823 * @hw: pointer to the HW structure 824 * @buffer: pointer to the host interface buffer 825 * @length: size of the buffer 826 * @offset: location in the buffer to write to 827 * @sum: sum of the data (not checksum) 828 * 829 * This function writes the buffer content at the offset given on the host if. 830 * It also does alignment considerations to do the writes in most efficient 831 * way. Also fills up the sum of the buffer in *buffer parameter. 832 **/ 833 s32 e1000_mng_host_if_write(struct e1000_hw * hw, u8 *buffer, u16 length, 834 u16 offset, u8 *sum) 835 { 836 if (hw->mac.ops.mng_host_if_write) 837 return hw->mac.ops.mng_host_if_write(hw, buffer, length, 838 offset, sum); 839 840 return E1000_NOT_IMPLEMENTED; 841 } 842 843 /** 844 * e1000_mng_write_cmd_header - Writes manageability command header 845 * @hw: pointer to the HW structure 846 * @hdr: pointer to the host interface command header 847 * 848 * Writes the command header after does the checksum calculation. 849 **/ 850 s32 e1000_mng_write_cmd_header(struct e1000_hw *hw, 851 struct e1000_host_mng_command_header *hdr) 852 { 853 if (hw->mac.ops.mng_write_cmd_header) 854 return hw->mac.ops.mng_write_cmd_header(hw, hdr); 855 856 return E1000_NOT_IMPLEMENTED; 857 } 858 859 /** 860 * e1000_mng_enable_host_if - Checks host interface is enabled 861 * @hw: pointer to the HW structure 862 * 863 * Returns E1000_success upon success, else E1000_ERR_HOST_INTERFACE_COMMAND 864 * 865 * This function checks whether the HOST IF is enabled for command operation 866 * and also checks whether the previous command is completed. It busy waits 867 * in case of previous command is not completed. 868 **/ 869 s32 e1000_mng_enable_host_if(struct e1000_hw * hw) 870 { 871 if (hw->mac.ops.mng_enable_host_if) 872 return hw->mac.ops.mng_enable_host_if(hw); 873 874 return E1000_NOT_IMPLEMENTED; 875 } 876 877 /** 878 * e1000_wait_autoneg - Waits for autonegotiation completion 879 * @hw: pointer to the HW structure 880 * 881 * Waits for autoneg to complete. Currently no func pointer exists and all 882 * implementations are handled in the generic version of this function. 883 **/ 884 s32 e1000_wait_autoneg(struct e1000_hw *hw) 885 { 886 if (hw->mac.ops.wait_autoneg) 887 return hw->mac.ops.wait_autoneg(hw); 888 889 return E1000_SUCCESS; 890 } 891 892 /** 893 * e1000_check_reset_block - Verifies PHY can be reset 894 * @hw: pointer to the HW structure 895 * 896 * Checks if the PHY is in a state that can be reset or if manageability 897 * has it tied up. This is a function pointer entry point called by drivers. 898 **/ 899 s32 e1000_check_reset_block(struct e1000_hw *hw) 900 { 901 if (hw->phy.ops.check_reset_block) 902 return hw->phy.ops.check_reset_block(hw); 903 904 return E1000_SUCCESS; 905 } 906 907 /** 908 * e1000_read_phy_reg - Reads PHY register 909 * @hw: pointer to the HW structure 910 * @offset: the register to read 911 * @data: the buffer to store the 16-bit read. 912 * 913 * Reads the PHY register and returns the value in data. 914 * This is a function pointer entry point called by drivers. 915 **/ 916 s32 e1000_read_phy_reg(struct e1000_hw *hw, u32 offset, u16 *data) 917 { 918 if (hw->phy.ops.read_reg) 919 return hw->phy.ops.read_reg(hw, offset, data); 920 921 return E1000_SUCCESS; 922 } 923 924 /** 925 * e1000_write_phy_reg - Writes PHY register 926 * @hw: pointer to the HW structure 927 * @offset: the register to write 928 * @data: the value to write. 929 * 930 * Writes the PHY register at offset with the value in data. 931 * This is a function pointer entry point called by drivers. 932 **/ 933 s32 e1000_write_phy_reg(struct e1000_hw *hw, u32 offset, u16 data) 934 { 935 if (hw->phy.ops.write_reg) 936 return hw->phy.ops.write_reg(hw, offset, data); 937 938 return E1000_SUCCESS; 939 } 940 941 /** 942 * e1000_release_phy - Generic release PHY 943 * @hw: pointer to the HW structure 944 * 945 * Return if silicon family does not require a semaphore when accessing the 946 * PHY. 947 **/ 948 void e1000_release_phy(struct e1000_hw *hw) 949 { 950 if (hw->phy.ops.release) 951 hw->phy.ops.release(hw); 952 } 953 954 /** 955 * e1000_acquire_phy - Generic acquire PHY 956 * @hw: pointer to the HW structure 957 * 958 * Return success if silicon family does not require a semaphore when 959 * accessing the PHY. 960 **/ 961 s32 e1000_acquire_phy(struct e1000_hw *hw) 962 { 963 if (hw->phy.ops.acquire) 964 return hw->phy.ops.acquire(hw); 965 966 return E1000_SUCCESS; 967 } 968 969 /** 970 * e1000_cfg_on_link_up - Configure PHY upon link up 971 * @hw: pointer to the HW structure 972 **/ 973 s32 e1000_cfg_on_link_up(struct e1000_hw *hw) 974 { 975 if (hw->phy.ops.cfg_on_link_up) 976 return hw->phy.ops.cfg_on_link_up(hw); 977 978 return E1000_SUCCESS; 979 } 980 981 /** 982 * e1000_read_kmrn_reg - Reads register using Kumeran interface 983 * @hw: pointer to the HW structure 984 * @offset: the register to read 985 * @data: the location to store the 16-bit value read. 986 * 987 * Reads a register out of the Kumeran interface. Currently no func pointer 988 * exists and all implementations are handled in the generic version of 989 * this function. 990 **/ 991 s32 e1000_read_kmrn_reg(struct e1000_hw *hw, u32 offset, u16 *data) 992 { 993 return e1000_read_kmrn_reg_generic(hw, offset, data); 994 } 995 996 /** 997 * e1000_write_kmrn_reg - Writes register using Kumeran interface 998 * @hw: pointer to the HW structure 999 * @offset: the register to write 1000 * @data: the value to write. 1001 * 1002 * Writes a register to the Kumeran interface. Currently no func pointer 1003 * exists and all implementations are handled in the generic version of 1004 * this function. 1005 **/ 1006 s32 e1000_write_kmrn_reg(struct e1000_hw *hw, u32 offset, u16 data) 1007 { 1008 return e1000_write_kmrn_reg_generic(hw, offset, data); 1009 } 1010 1011 /** 1012 * e1000_get_cable_length - Retrieves cable length estimation 1013 * @hw: pointer to the HW structure 1014 * 1015 * This function estimates the cable length and stores them in 1016 * hw->phy.min_length and hw->phy.max_length. This is a function pointer 1017 * entry point called by drivers. 1018 **/ 1019 s32 e1000_get_cable_length(struct e1000_hw *hw) 1020 { 1021 if (hw->phy.ops.get_cable_length) 1022 return hw->phy.ops.get_cable_length(hw); 1023 1024 return E1000_SUCCESS; 1025 } 1026 1027 /** 1028 * e1000_get_phy_info - Retrieves PHY information from registers 1029 * @hw: pointer to the HW structure 1030 * 1031 * This function gets some information from various PHY registers and 1032 * populates hw->phy values with it. This is a function pointer entry 1033 * point called by drivers. 1034 **/ 1035 s32 e1000_get_phy_info(struct e1000_hw *hw) 1036 { 1037 if (hw->phy.ops.get_info) 1038 return hw->phy.ops.get_info(hw); 1039 1040 return E1000_SUCCESS; 1041 } 1042 1043 /** 1044 * e1000_phy_hw_reset - Hard PHY reset 1045 * @hw: pointer to the HW structure 1046 * 1047 * Performs a hard PHY reset. This is a function pointer entry point called 1048 * by drivers. 1049 **/ 1050 s32 e1000_phy_hw_reset(struct e1000_hw *hw) 1051 { 1052 if (hw->phy.ops.reset) 1053 return hw->phy.ops.reset(hw); 1054 1055 return E1000_SUCCESS; 1056 } 1057 1058 /** 1059 * e1000_phy_commit - Soft PHY reset 1060 * @hw: pointer to the HW structure 1061 * 1062 * Performs a soft PHY reset on those that apply. This is a function pointer 1063 * entry point called by drivers. 1064 **/ 1065 s32 e1000_phy_commit(struct e1000_hw *hw) 1066 { 1067 if (hw->phy.ops.commit) 1068 return hw->phy.ops.commit(hw); 1069 1070 return E1000_SUCCESS; 1071 } 1072 1073 /** 1074 * e1000_set_d0_lplu_state - Sets low power link up state for D0 1075 * @hw: pointer to the HW structure 1076 * @active: boolean used to enable/disable lplu 1077 * 1078 * Success returns 0, Failure returns 1 1079 * 1080 * The low power link up (lplu) state is set to the power management level D0 1081 * and SmartSpeed is disabled when active is TRUE, else clear lplu for D0 1082 * and enable Smartspeed. LPLU and Smartspeed are mutually exclusive. LPLU 1083 * is used during Dx states where the power conservation is most important. 1084 * During driver activity, SmartSpeed should be enabled so performance is 1085 * maintained. This is a function pointer entry point called by drivers. 1086 **/ 1087 s32 e1000_set_d0_lplu_state(struct e1000_hw *hw, bool active) 1088 { 1089 if (hw->phy.ops.set_d0_lplu_state) 1090 return hw->phy.ops.set_d0_lplu_state(hw, active); 1091 1092 return E1000_SUCCESS; 1093 } 1094 1095 /** 1096 * e1000_set_d3_lplu_state - Sets low power link up state for D3 1097 * @hw: pointer to the HW structure 1098 * @active: boolean used to enable/disable lplu 1099 * 1100 * Success returns 0, Failure returns 1 1101 * 1102 * The low power link up (lplu) state is set to the power management level D3 1103 * and SmartSpeed is disabled when active is TRUE, else clear lplu for D3 1104 * and enable Smartspeed. LPLU and Smartspeed are mutually exclusive. LPLU 1105 * is used during Dx states where the power conservation is most important. 1106 * During driver activity, SmartSpeed should be enabled so performance is 1107 * maintained. This is a function pointer entry point called by drivers. 1108 **/ 1109 s32 e1000_set_d3_lplu_state(struct e1000_hw *hw, bool active) 1110 { 1111 if (hw->phy.ops.set_d3_lplu_state) 1112 return hw->phy.ops.set_d3_lplu_state(hw, active); 1113 1114 return E1000_SUCCESS; 1115 } 1116 1117 /** 1118 * e1000_read_mac_addr - Reads MAC address 1119 * @hw: pointer to the HW structure 1120 * 1121 * Reads the MAC address out of the adapter and stores it in the HW structure. 1122 * Currently no func pointer exists and all implementations are handled in the 1123 * generic version of this function. 1124 **/ 1125 s32 e1000_read_mac_addr(struct e1000_hw *hw) 1126 { 1127 if (hw->mac.ops.read_mac_addr) 1128 return hw->mac.ops.read_mac_addr(hw); 1129 1130 return e1000_read_mac_addr_generic(hw); 1131 } 1132 1133 /** 1134 * e1000_read_pba_num - Read device part number 1135 * @hw: pointer to the HW structure 1136 * @pba_num: pointer to device part number 1137 * 1138 * Reads the product board assembly (PBA) number from the EEPROM and stores 1139 * the value in pba_num. 1140 * Currently no func pointer exists and all implementations are handled in the 1141 * generic version of this function. 1142 **/ 1143 s32 e1000_read_pba_num(struct e1000_hw *hw, u32 *pba_num) 1144 { 1145 return e1000_read_pba_num_generic(hw, pba_num); 1146 } 1147 1148 /** 1149 * e1000_validate_nvm_checksum - Verifies NVM (EEPROM) checksum 1150 * @hw: pointer to the HW structure 1151 * 1152 * Validates the NVM checksum is correct. This is a function pointer entry 1153 * point called by drivers. 1154 **/ 1155 s32 e1000_validate_nvm_checksum(struct e1000_hw *hw) 1156 { 1157 if (hw->nvm.ops.validate) 1158 return hw->nvm.ops.validate(hw); 1159 1160 return -E1000_ERR_CONFIG; 1161 } 1162 1163 /** 1164 * e1000_update_nvm_checksum - Updates NVM (EEPROM) checksum 1165 * @hw: pointer to the HW structure 1166 * 1167 * Updates the NVM checksum. Currently no func pointer exists and all 1168 * implementations are handled in the generic version of this function. 1169 **/ 1170 s32 e1000_update_nvm_checksum(struct e1000_hw *hw) 1171 { 1172 if (hw->nvm.ops.update) 1173 return hw->nvm.ops.update(hw); 1174 1175 return -E1000_ERR_CONFIG; 1176 } 1177 1178 /** 1179 * e1000_reload_nvm - Reloads EEPROM 1180 * @hw: pointer to the HW structure 1181 * 1182 * Reloads the EEPROM by setting the "Reinitialize from EEPROM" bit in the 1183 * extended control register. 1184 **/ 1185 void e1000_reload_nvm(struct e1000_hw *hw) 1186 { 1187 if (hw->nvm.ops.reload) 1188 hw->nvm.ops.reload(hw); 1189 } 1190 1191 /** 1192 * e1000_read_nvm - Reads NVM (EEPROM) 1193 * @hw: pointer to the HW structure 1194 * @offset: the word offset to read 1195 * @words: number of 16-bit words to read 1196 * @data: pointer to the properly sized buffer for the data. 1197 * 1198 * Reads 16-bit chunks of data from the NVM (EEPROM). This is a function 1199 * pointer entry point called by drivers. 1200 **/ 1201 s32 e1000_read_nvm(struct e1000_hw *hw, u16 offset, u16 words, u16 *data) 1202 { 1203 if (hw->nvm.ops.read) 1204 return hw->nvm.ops.read(hw, offset, words, data); 1205 1206 return -E1000_ERR_CONFIG; 1207 } 1208 1209 /** 1210 * e1000_write_nvm - Writes to NVM (EEPROM) 1211 * @hw: pointer to the HW structure 1212 * @offset: the word offset to read 1213 * @words: number of 16-bit words to write 1214 * @data: pointer to the properly sized buffer for the data. 1215 * 1216 * Writes 16-bit chunks of data to the NVM (EEPROM). This is a function 1217 * pointer entry point called by drivers. 1218 **/ 1219 s32 e1000_write_nvm(struct e1000_hw *hw, u16 offset, u16 words, u16 *data) 1220 { 1221 if (hw->nvm.ops.write) 1222 return hw->nvm.ops.write(hw, offset, words, data); 1223 1224 return E1000_SUCCESS; 1225 } 1226 1227 /** 1228 * e1000_write_8bit_ctrl_reg - Writes 8bit Control register 1229 * @hw: pointer to the HW structure 1230 * @reg: 32bit register offset 1231 * @offset: the register to write 1232 * @data: the value to write. 1233 * 1234 * Writes the PHY register at offset with the value in data. 1235 * This is a function pointer entry point called by drivers. 1236 **/ 1237 s32 e1000_write_8bit_ctrl_reg(struct e1000_hw *hw, u32 reg, u32 offset, 1238 u8 data) 1239 { 1240 return e1000_write_8bit_ctrl_reg_generic(hw, reg, offset, data); 1241 } 1242 1243 /** 1244 * e1000_power_up_phy - Restores link in case of PHY power down 1245 * @hw: pointer to the HW structure 1246 * 1247 * The phy may be powered down to save power, to turn off link when the 1248 * driver is unloaded, or wake on lan is not enabled (among others). 1249 **/ 1250 void e1000_power_up_phy(struct e1000_hw *hw) 1251 { 1252 if (hw->phy.ops.power_up) 1253 hw->phy.ops.power_up(hw); 1254 1255 e1000_setup_link(hw); 1256 } 1257 1258 /** 1259 * e1000_power_down_phy - Power down PHY 1260 * @hw: pointer to the HW structure 1261 * 1262 * The phy may be powered down to save power, to turn off link when the 1263 * driver is unloaded, or wake on lan is not enabled (among others). 1264 **/ 1265 void e1000_power_down_phy(struct e1000_hw *hw) 1266 { 1267 if (hw->phy.ops.power_down) 1268 hw->phy.ops.power_down(hw); 1269 } 1270 1271 /** 1272 * e1000_power_up_fiber_serdes_link - Power up serdes link 1273 * @hw: pointer to the HW structure 1274 * 1275 * Power on the optics and PCS. 1276 **/ 1277 void e1000_power_up_fiber_serdes_link(struct e1000_hw *hw) 1278 { 1279 if (hw->mac.ops.power_up_serdes) 1280 hw->mac.ops.power_up_serdes(hw); 1281 } 1282 1283 /** 1284 * e1000_shutdown_fiber_serdes_link - Remove link during power down 1285 * @hw: pointer to the HW structure 1286 * 1287 * Shutdown the optics and PCS on driver unload. 1288 **/ 1289 void e1000_shutdown_fiber_serdes_link(struct e1000_hw *hw) 1290 { 1291 if (hw->mac.ops.shutdown_serdes) 1292 hw->mac.ops.shutdown_serdes(hw); 1293 } 1294 1295