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