1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2001 - 2015 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 mac->type = e1000_pch_cnp; 288 break; 289 case E1000_DEV_ID_82575EB_COPPER: 290 case E1000_DEV_ID_82575EB_FIBER_SERDES: 291 case E1000_DEV_ID_82575GB_QUAD_COPPER: 292 mac->type = e1000_82575; 293 break; 294 case E1000_DEV_ID_82576: 295 case E1000_DEV_ID_82576_FIBER: 296 case E1000_DEV_ID_82576_SERDES: 297 case E1000_DEV_ID_82576_QUAD_COPPER: 298 case E1000_DEV_ID_82576_QUAD_COPPER_ET2: 299 case E1000_DEV_ID_82576_NS: 300 case E1000_DEV_ID_82576_NS_SERDES: 301 case E1000_DEV_ID_82576_SERDES_QUAD: 302 mac->type = e1000_82576; 303 break; 304 case E1000_DEV_ID_82580_COPPER: 305 case E1000_DEV_ID_82580_FIBER: 306 case E1000_DEV_ID_82580_SERDES: 307 case E1000_DEV_ID_82580_SGMII: 308 case E1000_DEV_ID_82580_COPPER_DUAL: 309 case E1000_DEV_ID_82580_QUAD_FIBER: 310 case E1000_DEV_ID_DH89XXCC_SGMII: 311 case E1000_DEV_ID_DH89XXCC_SERDES: 312 case E1000_DEV_ID_DH89XXCC_BACKPLANE: 313 case E1000_DEV_ID_DH89XXCC_SFP: 314 mac->type = e1000_82580; 315 break; 316 case E1000_DEV_ID_I350_COPPER: 317 case E1000_DEV_ID_I350_FIBER: 318 case E1000_DEV_ID_I350_SERDES: 319 case E1000_DEV_ID_I350_SGMII: 320 case E1000_DEV_ID_I350_DA4: 321 mac->type = e1000_i350; 322 break; 323 case E1000_DEV_ID_I210_COPPER_FLASHLESS: 324 case E1000_DEV_ID_I210_SERDES_FLASHLESS: 325 case E1000_DEV_ID_I210_COPPER: 326 case E1000_DEV_ID_I210_COPPER_OEM1: 327 case E1000_DEV_ID_I210_COPPER_IT: 328 case E1000_DEV_ID_I210_FIBER: 329 case E1000_DEV_ID_I210_SERDES: 330 case E1000_DEV_ID_I210_SGMII: 331 mac->type = e1000_i210; 332 break; 333 case E1000_DEV_ID_I211_COPPER: 334 mac->type = e1000_i211; 335 break; 336 case E1000_DEV_ID_82576_VF: 337 case E1000_DEV_ID_82576_VF_HV: 338 mac->type = e1000_vfadapt; 339 break; 340 case E1000_DEV_ID_I350_VF: 341 case E1000_DEV_ID_I350_VF_HV: 342 mac->type = e1000_vfadapt_i350; 343 break; 344 345 case E1000_DEV_ID_I354_BACKPLANE_1GBPS: 346 case E1000_DEV_ID_I354_SGMII: 347 case E1000_DEV_ID_I354_BACKPLANE_2_5GBPS: 348 mac->type = e1000_i354; 349 break; 350 default: 351 /* Should never have loaded on this device */ 352 ret_val = -E1000_ERR_MAC_INIT; 353 break; 354 } 355 356 return ret_val; 357 } 358 359 /** 360 * e1000_setup_init_funcs - Initializes function pointers 361 * @hw: pointer to the HW structure 362 * @init_device: true will initialize the rest of the function pointers 363 * getting the device ready for use. false will only set 364 * MAC type and the function pointers for the other init 365 * functions. Passing false will not generate any hardware 366 * reads or writes. 367 * 368 * This function must be called by a driver in order to use the rest 369 * of the 'shared' code files. Called by drivers only. 370 **/ 371 s32 e1000_setup_init_funcs(struct e1000_hw *hw, bool init_device) 372 { 373 s32 ret_val; 374 375 /* Can't do much good without knowing the MAC type. */ 376 ret_val = e1000_set_mac_type(hw); 377 if (ret_val) { 378 DEBUGOUT("ERROR: MAC type could not be set properly.\n"); 379 goto out; 380 } 381 382 if (!hw->hw_addr) { 383 DEBUGOUT("ERROR: Registers not mapped\n"); 384 ret_val = -E1000_ERR_CONFIG; 385 goto out; 386 } 387 388 /* 389 * Init function pointers to generic implementations. We do this first 390 * allowing a driver module to override it afterward. 391 */ 392 e1000_init_mac_ops_generic(hw); 393 e1000_init_phy_ops_generic(hw); 394 e1000_init_nvm_ops_generic(hw); 395 e1000_init_mbx_ops_generic(hw); 396 397 /* 398 * Set up the init function pointers. These are functions within the 399 * adapter family file that sets up function pointers for the rest of 400 * the functions in that family. 401 */ 402 switch (hw->mac.type) { 403 case e1000_82542: 404 e1000_init_function_pointers_82542(hw); 405 break; 406 case e1000_82543: 407 case e1000_82544: 408 e1000_init_function_pointers_82543(hw); 409 break; 410 case e1000_82540: 411 case e1000_82545: 412 case e1000_82545_rev_3: 413 case e1000_82546: 414 case e1000_82546_rev_3: 415 e1000_init_function_pointers_82540(hw); 416 break; 417 case e1000_82541: 418 case e1000_82541_rev_2: 419 case e1000_82547: 420 case e1000_82547_rev_2: 421 e1000_init_function_pointers_82541(hw); 422 break; 423 case e1000_82571: 424 case e1000_82572: 425 case e1000_82573: 426 case e1000_82574: 427 case e1000_82583: 428 e1000_init_function_pointers_82571(hw); 429 break; 430 case e1000_80003es2lan: 431 e1000_init_function_pointers_80003es2lan(hw); 432 break; 433 case e1000_ich8lan: 434 case e1000_ich9lan: 435 case e1000_ich10lan: 436 case e1000_pchlan: 437 case e1000_pch2lan: 438 case e1000_pch_lpt: 439 case e1000_pch_spt: 440 case e1000_pch_cnp: 441 e1000_init_function_pointers_ich8lan(hw); 442 break; 443 case e1000_82575: 444 case e1000_82576: 445 case e1000_82580: 446 case e1000_i350: 447 case e1000_i354: 448 e1000_init_function_pointers_82575(hw); 449 break; 450 case e1000_i210: 451 case e1000_i211: 452 e1000_init_function_pointers_i210(hw); 453 break; 454 case e1000_vfadapt: 455 e1000_init_function_pointers_vf(hw); 456 break; 457 case e1000_vfadapt_i350: 458 e1000_init_function_pointers_vf(hw); 459 break; 460 default: 461 DEBUGOUT("Hardware not supported\n"); 462 ret_val = -E1000_ERR_CONFIG; 463 break; 464 } 465 466 /* 467 * Initialize the rest of the function pointers. These require some 468 * register reads/writes in some cases. 469 */ 470 if (!(ret_val) && init_device) { 471 ret_val = e1000_init_mac_params(hw); 472 if (ret_val) 473 goto out; 474 475 ret_val = e1000_init_nvm_params(hw); 476 if (ret_val) 477 goto out; 478 479 ret_val = e1000_init_phy_params(hw); 480 if (ret_val) 481 goto out; 482 483 ret_val = e1000_init_mbx_params(hw); 484 if (ret_val) 485 goto out; 486 } 487 488 out: 489 return ret_val; 490 } 491 492 /** 493 * e1000_get_bus_info - Obtain bus information for adapter 494 * @hw: pointer to the HW structure 495 * 496 * This will obtain information about the HW bus for which the 497 * adapter is attached and stores it in the hw structure. This is a 498 * function pointer entry point called by drivers. 499 **/ 500 s32 e1000_get_bus_info(struct e1000_hw *hw) 501 { 502 if (hw->mac.ops.get_bus_info) 503 return hw->mac.ops.get_bus_info(hw); 504 505 return E1000_SUCCESS; 506 } 507 508 /** 509 * e1000_clear_vfta - Clear VLAN filter table 510 * @hw: pointer to the HW structure 511 * 512 * This clears the VLAN filter table on the adapter. This is a function 513 * pointer entry point called by drivers. 514 **/ 515 void e1000_clear_vfta(struct e1000_hw *hw) 516 { 517 if (hw->mac.ops.clear_vfta) 518 hw->mac.ops.clear_vfta(hw); 519 } 520 521 /** 522 * e1000_write_vfta - Write value to VLAN filter table 523 * @hw: pointer to the HW structure 524 * @offset: the 32-bit offset in which to write the value to. 525 * @value: the 32-bit value to write at location offset. 526 * 527 * This writes a 32-bit value to a 32-bit offset in the VLAN filter 528 * table. This is a function pointer entry point called by drivers. 529 **/ 530 void e1000_write_vfta(struct e1000_hw *hw, u32 offset, u32 value) 531 { 532 if (hw->mac.ops.write_vfta) 533 hw->mac.ops.write_vfta(hw, offset, value); 534 } 535 536 /** 537 * e1000_update_mc_addr_list - Update Multicast addresses 538 * @hw: pointer to the HW structure 539 * @mc_addr_list: array of multicast addresses to program 540 * @mc_addr_count: number of multicast addresses to program 541 * 542 * Updates the Multicast Table Array. 543 * The caller must have a packed mc_addr_list of multicast addresses. 544 **/ 545 void e1000_update_mc_addr_list(struct e1000_hw *hw, u8 *mc_addr_list, 546 u32 mc_addr_count) 547 { 548 if (hw->mac.ops.update_mc_addr_list) 549 hw->mac.ops.update_mc_addr_list(hw, mc_addr_list, 550 mc_addr_count); 551 } 552 553 /** 554 * e1000_force_mac_fc - Force MAC flow control 555 * @hw: pointer to the HW structure 556 * 557 * Force the MAC's flow control settings. Currently no func pointer exists 558 * and all implementations are handled in the generic version of this 559 * function. 560 **/ 561 s32 e1000_force_mac_fc(struct e1000_hw *hw) 562 { 563 return e1000_force_mac_fc_generic(hw); 564 } 565 566 /** 567 * e1000_check_for_link - Check/Store link connection 568 * @hw: pointer to the HW structure 569 * 570 * This checks the link condition of the adapter and stores the 571 * results in the hw->mac structure. This is a function pointer entry 572 * point called by drivers. 573 **/ 574 s32 e1000_check_for_link(struct e1000_hw *hw) 575 { 576 if (hw->mac.ops.check_for_link) 577 return hw->mac.ops.check_for_link(hw); 578 579 return -E1000_ERR_CONFIG; 580 } 581 582 /** 583 * e1000_check_mng_mode - Check management mode 584 * @hw: pointer to the HW structure 585 * 586 * This checks if the adapter has manageability enabled. 587 * This is a function pointer entry point called by drivers. 588 **/ 589 bool e1000_check_mng_mode(struct e1000_hw *hw) 590 { 591 if (hw->mac.ops.check_mng_mode) 592 return hw->mac.ops.check_mng_mode(hw); 593 594 return false; 595 } 596 597 /** 598 * e1000_mng_write_dhcp_info - Writes DHCP info to host interface 599 * @hw: pointer to the HW structure 600 * @buffer: pointer to the host interface 601 * @length: size of the buffer 602 * 603 * Writes the DHCP information to the host interface. 604 **/ 605 s32 e1000_mng_write_dhcp_info(struct e1000_hw *hw, u8 *buffer, u16 length) 606 { 607 return e1000_mng_write_dhcp_info_generic(hw, buffer, length); 608 } 609 610 /** 611 * e1000_reset_hw - Reset hardware 612 * @hw: pointer to the HW structure 613 * 614 * This resets the hardware into a known state. This is a function pointer 615 * entry point called by drivers. 616 **/ 617 s32 e1000_reset_hw(struct e1000_hw *hw) 618 { 619 if (hw->mac.ops.reset_hw) 620 return hw->mac.ops.reset_hw(hw); 621 622 return -E1000_ERR_CONFIG; 623 } 624 625 /** 626 * e1000_init_hw - Initialize hardware 627 * @hw: pointer to the HW structure 628 * 629 * This inits the hardware readying it for operation. This is a function 630 * pointer entry point called by drivers. 631 **/ 632 s32 e1000_init_hw(struct e1000_hw *hw) 633 { 634 if (hw->mac.ops.init_hw) 635 return hw->mac.ops.init_hw(hw); 636 637 return -E1000_ERR_CONFIG; 638 } 639 640 /** 641 * e1000_setup_link - Configures link and flow control 642 * @hw: pointer to the HW structure 643 * 644 * This configures link and flow control settings for the adapter. This 645 * is a function pointer entry point called by drivers. While modules can 646 * also call this, they probably call their own version of this function. 647 **/ 648 s32 e1000_setup_link(struct e1000_hw *hw) 649 { 650 if (hw->mac.ops.setup_link) 651 return hw->mac.ops.setup_link(hw); 652 653 return -E1000_ERR_CONFIG; 654 } 655 656 /** 657 * e1000_get_speed_and_duplex - Returns current speed and duplex 658 * @hw: pointer to the HW structure 659 * @speed: pointer to a 16-bit value to store the speed 660 * @duplex: pointer to a 16-bit value to store the duplex. 661 * 662 * This returns the speed and duplex of the adapter in the two 'out' 663 * variables passed in. This is a function pointer entry point called 664 * by drivers. 665 **/ 666 s32 e1000_get_speed_and_duplex(struct e1000_hw *hw, u16 *speed, u16 *duplex) 667 { 668 if (hw->mac.ops.get_link_up_info) 669 return hw->mac.ops.get_link_up_info(hw, speed, duplex); 670 671 return -E1000_ERR_CONFIG; 672 } 673 674 /** 675 * e1000_setup_led - Configures SW controllable LED 676 * @hw: pointer to the HW structure 677 * 678 * This prepares the SW controllable LED for use and saves the current state 679 * of the LED so it can be later restored. This is a function pointer entry 680 * point called by drivers. 681 **/ 682 s32 e1000_setup_led(struct e1000_hw *hw) 683 { 684 if (hw->mac.ops.setup_led) 685 return hw->mac.ops.setup_led(hw); 686 687 return E1000_SUCCESS; 688 } 689 690 /** 691 * e1000_cleanup_led - Restores SW controllable LED 692 * @hw: pointer to the HW structure 693 * 694 * This restores the SW controllable LED to the value saved off by 695 * e1000_setup_led. This is a function pointer entry point called by drivers. 696 **/ 697 s32 e1000_cleanup_led(struct e1000_hw *hw) 698 { 699 if (hw->mac.ops.cleanup_led) 700 return hw->mac.ops.cleanup_led(hw); 701 702 return E1000_SUCCESS; 703 } 704 705 /** 706 * e1000_blink_led - Blink SW controllable LED 707 * @hw: pointer to the HW structure 708 * 709 * This starts the adapter LED blinking. Request the LED to be setup first 710 * and cleaned up after. This is a function pointer entry point called by 711 * drivers. 712 **/ 713 s32 e1000_blink_led(struct e1000_hw *hw) 714 { 715 if (hw->mac.ops.blink_led) 716 return hw->mac.ops.blink_led(hw); 717 718 return E1000_SUCCESS; 719 } 720 721 /** 722 * e1000_id_led_init - store LED configurations in SW 723 * @hw: pointer to the HW structure 724 * 725 * Initializes the LED config in SW. This is a function pointer entry point 726 * called by drivers. 727 **/ 728 s32 e1000_id_led_init(struct e1000_hw *hw) 729 { 730 if (hw->mac.ops.id_led_init) 731 return hw->mac.ops.id_led_init(hw); 732 733 return E1000_SUCCESS; 734 } 735 736 /** 737 * e1000_led_on - Turn on SW controllable LED 738 * @hw: pointer to the HW structure 739 * 740 * Turns the SW defined LED on. This is a function pointer entry point 741 * called by drivers. 742 **/ 743 s32 e1000_led_on(struct e1000_hw *hw) 744 { 745 if (hw->mac.ops.led_on) 746 return hw->mac.ops.led_on(hw); 747 748 return E1000_SUCCESS; 749 } 750 751 /** 752 * e1000_led_off - Turn off SW controllable LED 753 * @hw: pointer to the HW structure 754 * 755 * Turns the SW defined LED off. This is a function pointer entry point 756 * called by drivers. 757 **/ 758 s32 e1000_led_off(struct e1000_hw *hw) 759 { 760 if (hw->mac.ops.led_off) 761 return hw->mac.ops.led_off(hw); 762 763 return E1000_SUCCESS; 764 } 765 766 /** 767 * e1000_reset_adaptive - Reset adaptive IFS 768 * @hw: pointer to the HW structure 769 * 770 * Resets the adaptive IFS. Currently no func pointer exists and all 771 * implementations are handled in the generic version of this function. 772 **/ 773 void e1000_reset_adaptive(struct e1000_hw *hw) 774 { 775 e1000_reset_adaptive_generic(hw); 776 } 777 778 /** 779 * e1000_update_adaptive - Update adaptive IFS 780 * @hw: pointer to the HW structure 781 * 782 * Updates adapter IFS. Currently no func pointer exists and all 783 * implementations are handled in the generic version of this function. 784 **/ 785 void e1000_update_adaptive(struct e1000_hw *hw) 786 { 787 e1000_update_adaptive_generic(hw); 788 } 789 790 /** 791 * e1000_disable_pcie_master - Disable PCI-Express master access 792 * @hw: pointer to the HW structure 793 * 794 * Disables PCI-Express master access and verifies there are no pending 795 * requests. Currently no func pointer exists and all implementations are 796 * handled in the generic version of this function. 797 **/ 798 s32 e1000_disable_pcie_master(struct e1000_hw *hw) 799 { 800 return e1000_disable_pcie_master_generic(hw); 801 } 802 803 /** 804 * e1000_config_collision_dist - Configure collision distance 805 * @hw: pointer to the HW structure 806 * 807 * Configures the collision distance to the default value and is used 808 * during link setup. 809 **/ 810 void e1000_config_collision_dist(struct e1000_hw *hw) 811 { 812 if (hw->mac.ops.config_collision_dist) 813 hw->mac.ops.config_collision_dist(hw); 814 } 815 816 /** 817 * e1000_rar_set - Sets a receive address register 818 * @hw: pointer to the HW structure 819 * @addr: address to set the RAR to 820 * @index: the RAR to set 821 * 822 * Sets a Receive Address Register (RAR) to the specified address. 823 **/ 824 int e1000_rar_set(struct e1000_hw *hw, u8 *addr, u32 index) 825 { 826 if (hw->mac.ops.rar_set) 827 return hw->mac.ops.rar_set(hw, addr, index); 828 829 return E1000_SUCCESS; 830 } 831 832 /** 833 * e1000_validate_mdi_setting - Ensures valid MDI/MDIX SW state 834 * @hw: pointer to the HW structure 835 * 836 * Ensures that the MDI/MDIX SW state is valid. 837 **/ 838 s32 e1000_validate_mdi_setting(struct e1000_hw *hw) 839 { 840 if (hw->mac.ops.validate_mdi_setting) 841 return hw->mac.ops.validate_mdi_setting(hw); 842 843 return E1000_SUCCESS; 844 } 845 846 /** 847 * e1000_hash_mc_addr - Determines address location in multicast table 848 * @hw: pointer to the HW structure 849 * @mc_addr: Multicast address to hash. 850 * 851 * This hashes an address to determine its location in the multicast 852 * table. Currently no func pointer exists and all implementations 853 * are handled in the generic version of this function. 854 **/ 855 u32 e1000_hash_mc_addr(struct e1000_hw *hw, u8 *mc_addr) 856 { 857 return e1000_hash_mc_addr_generic(hw, mc_addr); 858 } 859 860 /** 861 * e1000_enable_tx_pkt_filtering - Enable packet filtering on TX 862 * @hw: pointer to the HW structure 863 * 864 * Enables packet filtering on transmit packets if manageability is enabled 865 * and host interface is enabled. 866 * Currently no func pointer exists and all implementations are handled in the 867 * generic version of this function. 868 **/ 869 bool e1000_enable_tx_pkt_filtering(struct e1000_hw *hw) 870 { 871 return e1000_enable_tx_pkt_filtering_generic(hw); 872 } 873 874 /** 875 * e1000_mng_host_if_write - Writes to the manageability host interface 876 * @hw: pointer to the HW structure 877 * @buffer: pointer to the host interface buffer 878 * @length: size of the buffer 879 * @offset: location in the buffer to write to 880 * @sum: sum of the data (not checksum) 881 * 882 * This function writes the buffer content at the offset given on the host if. 883 * It also does alignment considerations to do the writes in most efficient 884 * way. Also fills up the sum of the buffer in *buffer parameter. 885 **/ 886 s32 e1000_mng_host_if_write(struct e1000_hw *hw, u8 *buffer, u16 length, 887 u16 offset, u8 *sum) 888 { 889 return e1000_mng_host_if_write_generic(hw, buffer, length, offset, sum); 890 } 891 892 /** 893 * e1000_mng_write_cmd_header - Writes manageability command header 894 * @hw: pointer to the HW structure 895 * @hdr: pointer to the host interface command header 896 * 897 * Writes the command header after does the checksum calculation. 898 **/ 899 s32 e1000_mng_write_cmd_header(struct e1000_hw *hw, 900 struct e1000_host_mng_command_header *hdr) 901 { 902 return e1000_mng_write_cmd_header_generic(hw, hdr); 903 } 904 905 /** 906 * e1000_mng_enable_host_if - Checks host interface is enabled 907 * @hw: pointer to the HW structure 908 * 909 * Returns E1000_success upon success, else E1000_ERR_HOST_INTERFACE_COMMAND 910 * 911 * This function checks whether the HOST IF is enabled for command operation 912 * and also checks whether the previous command is completed. It busy waits 913 * in case of previous command is not completed. 914 **/ 915 s32 e1000_mng_enable_host_if(struct e1000_hw *hw) 916 { 917 return e1000_mng_enable_host_if_generic(hw); 918 } 919 920 /** 921 * e1000_check_reset_block - Verifies PHY can be reset 922 * @hw: pointer to the HW structure 923 * 924 * Checks if the PHY is in a state that can be reset or if manageability 925 * has it tied up. This is a function pointer entry point called by drivers. 926 **/ 927 s32 e1000_check_reset_block(struct e1000_hw *hw) 928 { 929 if (hw->phy.ops.check_reset_block) 930 return hw->phy.ops.check_reset_block(hw); 931 932 return E1000_SUCCESS; 933 } 934 935 /** 936 * e1000_read_phy_reg - Reads PHY register 937 * @hw: pointer to the HW structure 938 * @offset: the register to read 939 * @data: the buffer to store the 16-bit read. 940 * 941 * Reads the PHY register and returns the value in data. 942 * This is a function pointer entry point called by drivers. 943 **/ 944 s32 e1000_read_phy_reg(struct e1000_hw *hw, u32 offset, u16 *data) 945 { 946 if (hw->phy.ops.read_reg) 947 return hw->phy.ops.read_reg(hw, offset, data); 948 949 return E1000_SUCCESS; 950 } 951 952 /** 953 * e1000_write_phy_reg - Writes PHY register 954 * @hw: pointer to the HW structure 955 * @offset: the register to write 956 * @data: the value to write. 957 * 958 * Writes the PHY register at offset with the value in data. 959 * This is a function pointer entry point called by drivers. 960 **/ 961 s32 e1000_write_phy_reg(struct e1000_hw *hw, u32 offset, u16 data) 962 { 963 if (hw->phy.ops.write_reg) 964 return hw->phy.ops.write_reg(hw, offset, data); 965 966 return E1000_SUCCESS; 967 } 968 969 /** 970 * e1000_release_phy - Generic release PHY 971 * @hw: pointer to the HW structure 972 * 973 * Return if silicon family does not require a semaphore when accessing the 974 * PHY. 975 **/ 976 void e1000_release_phy(struct e1000_hw *hw) 977 { 978 if (hw->phy.ops.release) 979 hw->phy.ops.release(hw); 980 } 981 982 /** 983 * e1000_acquire_phy - Generic acquire PHY 984 * @hw: pointer to the HW structure 985 * 986 * Return success if silicon family does not require a semaphore when 987 * accessing the PHY. 988 **/ 989 s32 e1000_acquire_phy(struct e1000_hw *hw) 990 { 991 if (hw->phy.ops.acquire) 992 return hw->phy.ops.acquire(hw); 993 994 return E1000_SUCCESS; 995 } 996 997 /** 998 * e1000_cfg_on_link_up - Configure PHY upon link up 999 * @hw: pointer to the HW structure 1000 **/ 1001 s32 e1000_cfg_on_link_up(struct e1000_hw *hw) 1002 { 1003 if (hw->phy.ops.cfg_on_link_up) 1004 return hw->phy.ops.cfg_on_link_up(hw); 1005 1006 return E1000_SUCCESS; 1007 } 1008 1009 /** 1010 * e1000_read_kmrn_reg - Reads register using Kumeran interface 1011 * @hw: pointer to the HW structure 1012 * @offset: the register to read 1013 * @data: the location to store the 16-bit value read. 1014 * 1015 * Reads a register out of the Kumeran interface. Currently no func pointer 1016 * exists and all implementations are handled in the generic version of 1017 * this function. 1018 **/ 1019 s32 e1000_read_kmrn_reg(struct e1000_hw *hw, u32 offset, u16 *data) 1020 { 1021 return e1000_read_kmrn_reg_generic(hw, offset, data); 1022 } 1023 1024 /** 1025 * e1000_write_kmrn_reg - Writes register using Kumeran interface 1026 * @hw: pointer to the HW structure 1027 * @offset: the register to write 1028 * @data: the value to write. 1029 * 1030 * Writes a register to the Kumeran interface. Currently no func pointer 1031 * exists and all implementations are handled in the generic version of 1032 * this function. 1033 **/ 1034 s32 e1000_write_kmrn_reg(struct e1000_hw *hw, u32 offset, u16 data) 1035 { 1036 return e1000_write_kmrn_reg_generic(hw, offset, data); 1037 } 1038 1039 /** 1040 * e1000_get_cable_length - Retrieves cable length estimation 1041 * @hw: pointer to the HW structure 1042 * 1043 * This function estimates the cable length and stores them in 1044 * hw->phy.min_length and hw->phy.max_length. This is a function pointer 1045 * entry point called by drivers. 1046 **/ 1047 s32 e1000_get_cable_length(struct e1000_hw *hw) 1048 { 1049 if (hw->phy.ops.get_cable_length) 1050 return hw->phy.ops.get_cable_length(hw); 1051 1052 return E1000_SUCCESS; 1053 } 1054 1055 /** 1056 * e1000_get_phy_info - Retrieves PHY information from registers 1057 * @hw: pointer to the HW structure 1058 * 1059 * This function gets some information from various PHY registers and 1060 * populates hw->phy values with it. This is a function pointer entry 1061 * point called by drivers. 1062 **/ 1063 s32 e1000_get_phy_info(struct e1000_hw *hw) 1064 { 1065 if (hw->phy.ops.get_info) 1066 return hw->phy.ops.get_info(hw); 1067 1068 return E1000_SUCCESS; 1069 } 1070 1071 /** 1072 * e1000_phy_hw_reset - Hard PHY reset 1073 * @hw: pointer to the HW structure 1074 * 1075 * Performs a hard PHY reset. This is a function pointer entry point called 1076 * by drivers. 1077 **/ 1078 s32 e1000_phy_hw_reset(struct e1000_hw *hw) 1079 { 1080 if (hw->phy.ops.reset) 1081 return hw->phy.ops.reset(hw); 1082 1083 return E1000_SUCCESS; 1084 } 1085 1086 /** 1087 * e1000_phy_commit - Soft PHY reset 1088 * @hw: pointer to the HW structure 1089 * 1090 * Performs a soft PHY reset on those that apply. This is a function pointer 1091 * entry point called by drivers. 1092 **/ 1093 s32 e1000_phy_commit(struct e1000_hw *hw) 1094 { 1095 if (hw->phy.ops.commit) 1096 return hw->phy.ops.commit(hw); 1097 1098 return E1000_SUCCESS; 1099 } 1100 1101 /** 1102 * e1000_set_d0_lplu_state - Sets low power link up state for D0 1103 * @hw: pointer to the HW structure 1104 * @active: boolean used to enable/disable lplu 1105 * 1106 * Success returns 0, Failure returns 1 1107 * 1108 * The low power link up (lplu) state is set to the power management level D0 1109 * and SmartSpeed is disabled when active is true, else clear lplu for D0 1110 * and enable Smartspeed. LPLU and Smartspeed are mutually exclusive. LPLU 1111 * is used during Dx states where the power conservation is most important. 1112 * During driver activity, SmartSpeed should be enabled so performance is 1113 * maintained. This is a function pointer entry point called by drivers. 1114 **/ 1115 s32 e1000_set_d0_lplu_state(struct e1000_hw *hw, bool active) 1116 { 1117 if (hw->phy.ops.set_d0_lplu_state) 1118 return hw->phy.ops.set_d0_lplu_state(hw, active); 1119 1120 return E1000_SUCCESS; 1121 } 1122 1123 /** 1124 * e1000_set_d3_lplu_state - Sets low power link up state for D3 1125 * @hw: pointer to the HW structure 1126 * @active: boolean used to enable/disable lplu 1127 * 1128 * Success returns 0, Failure returns 1 1129 * 1130 * The low power link up (lplu) state is set to the power management level D3 1131 * and SmartSpeed is disabled when active is true, else clear lplu for D3 1132 * and enable Smartspeed. LPLU and Smartspeed are mutually exclusive. LPLU 1133 * is used during Dx states where the power conservation is most important. 1134 * During driver activity, SmartSpeed should be enabled so performance is 1135 * maintained. This is a function pointer entry point called by drivers. 1136 **/ 1137 s32 e1000_set_d3_lplu_state(struct e1000_hw *hw, bool active) 1138 { 1139 if (hw->phy.ops.set_d3_lplu_state) 1140 return hw->phy.ops.set_d3_lplu_state(hw, active); 1141 1142 return E1000_SUCCESS; 1143 } 1144 1145 /** 1146 * e1000_read_mac_addr - Reads MAC address 1147 * @hw: pointer to the HW structure 1148 * 1149 * Reads the MAC address out of the adapter and stores it in the HW structure. 1150 * Currently no func pointer exists and all implementations are handled in the 1151 * generic version of this function. 1152 **/ 1153 s32 e1000_read_mac_addr(struct e1000_hw *hw) 1154 { 1155 if (hw->mac.ops.read_mac_addr) 1156 return hw->mac.ops.read_mac_addr(hw); 1157 1158 return e1000_read_mac_addr_generic(hw); 1159 } 1160 1161 /** 1162 * e1000_read_pba_string - Read device part number string 1163 * @hw: pointer to the HW structure 1164 * @pba_num: pointer to device part number 1165 * @pba_num_size: size of part number buffer 1166 * 1167 * Reads the product board assembly (PBA) number from the EEPROM and stores 1168 * the value in pba_num. 1169 * Currently no func pointer exists and all implementations are handled in the 1170 * generic version of this function. 1171 **/ 1172 s32 e1000_read_pba_string(struct e1000_hw *hw, u8 *pba_num, u32 pba_num_size) 1173 { 1174 return e1000_read_pba_string_generic(hw, pba_num, pba_num_size); 1175 } 1176 1177 /** 1178 * e1000_read_pba_length - Read device part number string length 1179 * @hw: pointer to the HW structure 1180 * @pba_num_size: size of part number buffer 1181 * 1182 * Reads the product board assembly (PBA) number length from the EEPROM and 1183 * stores the value in pba_num. 1184 * Currently no func pointer exists and all implementations are handled in the 1185 * generic version of this function. 1186 **/ 1187 s32 e1000_read_pba_length(struct e1000_hw *hw, u32 *pba_num_size) 1188 { 1189 return e1000_read_pba_length_generic(hw, pba_num_size); 1190 } 1191 1192 /** 1193 * e1000_read_pba_num - Read device part number 1194 * @hw: pointer to the HW structure 1195 * @pba_num: pointer to device part number 1196 * 1197 * Reads the product board assembly (PBA) number from the EEPROM and stores 1198 * the value in pba_num. 1199 * Currently no func pointer exists and all implementations are handled in the 1200 * generic version of this function. 1201 **/ 1202 s32 e1000_read_pba_num(struct e1000_hw *hw, u32 *pba_num) 1203 { 1204 return e1000_read_pba_num_generic(hw, pba_num); 1205 } 1206 1207 /** 1208 * e1000_validate_nvm_checksum - Verifies NVM (EEPROM) checksum 1209 * @hw: pointer to the HW structure 1210 * 1211 * Validates the NVM checksum is correct. This is a function pointer entry 1212 * point called by drivers. 1213 **/ 1214 s32 e1000_validate_nvm_checksum(struct e1000_hw *hw) 1215 { 1216 if (hw->nvm.ops.validate) 1217 return hw->nvm.ops.validate(hw); 1218 1219 return -E1000_ERR_CONFIG; 1220 } 1221 1222 /** 1223 * e1000_update_nvm_checksum - Updates NVM (EEPROM) checksum 1224 * @hw: pointer to the HW structure 1225 * 1226 * Updates the NVM checksum. Currently no func pointer exists and all 1227 * implementations are handled in the generic version of this function. 1228 **/ 1229 s32 e1000_update_nvm_checksum(struct e1000_hw *hw) 1230 { 1231 if (hw->nvm.ops.update) 1232 return hw->nvm.ops.update(hw); 1233 1234 return -E1000_ERR_CONFIG; 1235 } 1236 1237 /** 1238 * e1000_reload_nvm - Reloads EEPROM 1239 * @hw: pointer to the HW structure 1240 * 1241 * Reloads the EEPROM by setting the "Reinitialize from EEPROM" bit in the 1242 * extended control register. 1243 **/ 1244 void e1000_reload_nvm(struct e1000_hw *hw) 1245 { 1246 if (hw->nvm.ops.reload) 1247 hw->nvm.ops.reload(hw); 1248 } 1249 1250 /** 1251 * e1000_read_nvm - Reads NVM (EEPROM) 1252 * @hw: pointer to the HW structure 1253 * @offset: the word offset to read 1254 * @words: number of 16-bit words to read 1255 * @data: pointer to the properly sized buffer for the data. 1256 * 1257 * Reads 16-bit chunks of data from the NVM (EEPROM). This is a function 1258 * pointer entry point called by drivers. 1259 **/ 1260 s32 e1000_read_nvm(struct e1000_hw *hw, u16 offset, u16 words, u16 *data) 1261 { 1262 if (hw->nvm.ops.read) 1263 return hw->nvm.ops.read(hw, offset, words, data); 1264 1265 return -E1000_ERR_CONFIG; 1266 } 1267 1268 /** 1269 * e1000_write_nvm - Writes to NVM (EEPROM) 1270 * @hw: pointer to the HW structure 1271 * @offset: the word offset to read 1272 * @words: number of 16-bit words to write 1273 * @data: pointer to the properly sized buffer for the data. 1274 * 1275 * Writes 16-bit chunks of data to the NVM (EEPROM). This is a function 1276 * pointer entry point called by drivers. 1277 **/ 1278 s32 e1000_write_nvm(struct e1000_hw *hw, u16 offset, u16 words, u16 *data) 1279 { 1280 if (hw->nvm.ops.write) 1281 return hw->nvm.ops.write(hw, offset, words, data); 1282 1283 return E1000_SUCCESS; 1284 } 1285 1286 /** 1287 * e1000_write_8bit_ctrl_reg - Writes 8bit Control register 1288 * @hw: pointer to the HW structure 1289 * @reg: 32bit register offset 1290 * @offset: the register to write 1291 * @data: the value to write. 1292 * 1293 * Writes the PHY register at offset with the value in data. 1294 * This is a function pointer entry point called by drivers. 1295 **/ 1296 s32 e1000_write_8bit_ctrl_reg(struct e1000_hw *hw, u32 reg, u32 offset, 1297 u8 data) 1298 { 1299 return e1000_write_8bit_ctrl_reg_generic(hw, reg, offset, data); 1300 } 1301 1302 /** 1303 * e1000_power_up_phy - Restores link in case of PHY power down 1304 * @hw: pointer to the HW structure 1305 * 1306 * The phy may be powered down to save power, to turn off link when the 1307 * driver is unloaded, or wake on lan is not enabled (among others). 1308 **/ 1309 void e1000_power_up_phy(struct e1000_hw *hw) 1310 { 1311 if (hw->phy.ops.power_up) 1312 hw->phy.ops.power_up(hw); 1313 1314 e1000_setup_link(hw); 1315 } 1316 1317 /** 1318 * e1000_power_down_phy - Power down PHY 1319 * @hw: pointer to the HW structure 1320 * 1321 * The phy may be powered down to save power, to turn off link when the 1322 * driver is unloaded, or wake on lan is not enabled (among others). 1323 **/ 1324 void e1000_power_down_phy(struct e1000_hw *hw) 1325 { 1326 if (hw->phy.ops.power_down) 1327 hw->phy.ops.power_down(hw); 1328 } 1329 1330 /** 1331 * e1000_power_up_fiber_serdes_link - Power up serdes link 1332 * @hw: pointer to the HW structure 1333 * 1334 * Power on the optics and PCS. 1335 **/ 1336 void e1000_power_up_fiber_serdes_link(struct e1000_hw *hw) 1337 { 1338 if (hw->mac.ops.power_up_serdes) 1339 hw->mac.ops.power_up_serdes(hw); 1340 } 1341 1342 /** 1343 * e1000_shutdown_fiber_serdes_link - Remove link during power down 1344 * @hw: pointer to the HW structure 1345 * 1346 * Shutdown the optics and PCS on driver unload. 1347 **/ 1348 void e1000_shutdown_fiber_serdes_link(struct e1000_hw *hw) 1349 { 1350 if (hw->mac.ops.shutdown_serdes) 1351 hw->mac.ops.shutdown_serdes(hw); 1352 } 1353 1354