352e31932ea6b50256377d87a37185813ffc69f6
[dpdk.git] / drivers / net / e1000 / base / e1000_api.c
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         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