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 **/
e1000_init_mac_params(struct e1000_hw * hw)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 **/
e1000_init_nvm_params(struct e1000_hw * hw)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 **/
e1000_init_phy_params(struct e1000_hw * hw)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 **/
e1000_init_mbx_params(struct e1000_hw * hw)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 **/
e1000_set_mac_type(struct e1000_hw * hw)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 **/
e1000_setup_init_funcs(struct e1000_hw * hw,bool init_device)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 **/
e1000_get_bus_info(struct e1000_hw * hw)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 **/
e1000_clear_vfta(struct e1000_hw * hw)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 **/
e1000_write_vfta(struct e1000_hw * hw,u32 offset,u32 value)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 **/
e1000_update_mc_addr_list(struct e1000_hw * hw,u8 * mc_addr_list,u32 mc_addr_count)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 **/
e1000_force_mac_fc(struct e1000_hw * hw)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 **/
e1000_check_for_link(struct e1000_hw * hw)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 **/
e1000_check_mng_mode(struct e1000_hw * hw)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 **/
e1000_mng_write_dhcp_info(struct e1000_hw * hw,u8 * buffer,u16 length)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 **/
e1000_reset_hw(struct e1000_hw * hw)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 **/
e1000_init_hw(struct e1000_hw * hw)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 **/
e1000_setup_link(struct e1000_hw * hw)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 **/
e1000_get_speed_and_duplex(struct e1000_hw * hw,u16 * speed,u16 * duplex)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 **/
e1000_setup_led(struct e1000_hw * hw)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 **/
e1000_cleanup_led(struct e1000_hw * hw)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 **/
e1000_blink_led(struct e1000_hw * hw)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 **/
e1000_id_led_init(struct e1000_hw * hw)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 **/
e1000_led_on(struct e1000_hw * hw)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 **/
e1000_led_off(struct e1000_hw * hw)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 **/
e1000_reset_adaptive(struct e1000_hw * hw)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 **/
e1000_update_adaptive(struct e1000_hw * hw)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 **/
e1000_disable_pcie_master(struct e1000_hw * hw)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 **/
e1000_config_collision_dist(struct e1000_hw * hw)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 **/
e1000_rar_set(struct e1000_hw * hw,u8 * addr,u32 index)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 **/
e1000_validate_mdi_setting(struct e1000_hw * hw)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 **/
e1000_hash_mc_addr(struct e1000_hw * hw,u8 * mc_addr)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 **/
e1000_enable_tx_pkt_filtering(struct e1000_hw * hw)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 **/
e1000_mng_host_if_write(struct e1000_hw * hw,u8 * buffer,u16 length,u16 offset,u8 * sum)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 **/
e1000_mng_write_cmd_header(struct e1000_hw * hw,struct e1000_host_mng_command_header * hdr)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 **/
e1000_mng_enable_host_if(struct e1000_hw * hw)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 **/
e1000_check_reset_block(struct e1000_hw * hw)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 **/
e1000_read_phy_reg(struct e1000_hw * hw,u32 offset,u16 * data)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 **/
e1000_write_phy_reg(struct e1000_hw * hw,u32 offset,u16 data)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 **/
e1000_release_phy(struct e1000_hw * hw)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 **/
e1000_acquire_phy(struct e1000_hw * hw)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 **/
e1000_cfg_on_link_up(struct e1000_hw * hw)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 **/
e1000_read_kmrn_reg(struct e1000_hw * hw,u32 offset,u16 * data)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 **/
e1000_write_kmrn_reg(struct e1000_hw * hw,u32 offset,u16 data)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 **/
e1000_get_cable_length(struct e1000_hw * hw)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 **/
e1000_get_phy_info(struct e1000_hw * hw)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 **/
e1000_phy_hw_reset(struct e1000_hw * hw)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 **/
e1000_phy_commit(struct e1000_hw * hw)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 **/
e1000_set_d0_lplu_state(struct e1000_hw * hw,bool active)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 **/
e1000_set_d3_lplu_state(struct e1000_hw * hw,bool active)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 **/
e1000_read_mac_addr(struct e1000_hw * hw)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 **/
e1000_read_pba_string(struct e1000_hw * hw,u8 * pba_num,u32 pba_num_size)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 **/
e1000_read_pba_length(struct e1000_hw * hw,u32 * pba_num_size)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 **/
e1000_read_pba_num(struct e1000_hw * hw,u32 * pba_num)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 **/
e1000_validate_nvm_checksum(struct e1000_hw * hw)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 **/
e1000_update_nvm_checksum(struct e1000_hw * hw)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 **/
e1000_reload_nvm(struct e1000_hw * hw)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 **/
e1000_read_nvm(struct e1000_hw * hw,u16 offset,u16 words,u16 * data)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 **/
e1000_write_nvm(struct e1000_hw * hw,u16 offset,u16 words,u16 * data)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 **/
e1000_write_8bit_ctrl_reg(struct e1000_hw * hw,u32 reg,u32 offset,u8 data)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 **/
e1000_power_up_phy(struct e1000_hw * hw)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 **/
e1000_power_down_phy(struct e1000_hw * hw)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 **/
e1000_power_up_fiber_serdes_link(struct e1000_hw * hw)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 **/
e1000_shutdown_fiber_serdes_link(struct e1000_hw * hw)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