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