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