1 /******************************************************************************
2
3 Copyright (c) 2001-2013, 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 static s32 e1000_acquire_nvm_i210(struct e1000_hw *hw);
39 static void e1000_release_nvm_i210(struct e1000_hw *hw);
40 static s32 e1000_get_hw_semaphore_i210(struct e1000_hw *hw);
41 static s32 e1000_write_nvm_srwr(struct e1000_hw *hw, u16 offset, u16 words,
42 u16 *data);
43 static s32 e1000_pool_flash_update_done_i210(struct e1000_hw *hw);
44 static s32 e1000_valid_led_default_i210(struct e1000_hw *hw, u16 *data);
45 static s32 e1000_read_nvm_i211(struct e1000_hw *hw, u16 offset, u16 words,
46 u16 *data);
47
48 /**
49 * e1000_acquire_nvm_i210 - Request for access to EEPROM
50 * @hw: pointer to the HW structure
51 *
52 * Acquire the necessary semaphores for exclusive access to the EEPROM.
53 * Set the EEPROM access request bit and wait for EEPROM access grant bit.
54 * Return successful if access grant bit set, else clear the request for
55 * EEPROM access and return -E1000_ERR_NVM (-1).
56 **/
57 static s32 e1000_acquire_nvm_i210(struct e1000_hw *hw)
58 {
59 s32 ret_val;
60
61 DEBUGFUNC("e1000_acquire_nvm_i210");
62
63 ret_val = e1000_acquire_swfw_sync_i210(hw, E1000_SWFW_EEP_SM);
64
65 return ret_val;
66 }
67
68 /**
69 * e1000_release_nvm_i210 - Release exclusive access to EEPROM
70 * @hw: pointer to the HW structure
71 *
72 * Stop any current commands to the EEPROM and clear the EEPROM request bit,
73 * then release the semaphores acquired.
74 **/
75 static void e1000_release_nvm_i210(struct e1000_hw *hw)
76 {
77 DEBUGFUNC("e1000_release_nvm_i210");
78
79 e1000_release_swfw_sync_i210(hw, E1000_SWFW_EEP_SM);
80 }
81
82 /**
83 * e1000_acquire_swfw_sync_i210 - Acquire SW/FW semaphore
84 * @hw: pointer to the HW structure
85 * @mask: specifies which semaphore to acquire
86 *
87 * Acquire the SW/FW semaphore to access the PHY or NVM. The mask
88 * will also specify which port we're acquiring the lock for.
89 **/
90 s32 e1000_acquire_swfw_sync_i210(struct e1000_hw *hw, u16 mask)
91 {
92 u32 swfw_sync;
93 u32 swmask = mask;
94 u32 fwmask = mask << 16;
95 s32 ret_val = E1000_SUCCESS;
96 s32 i = 0, timeout = 200; /* FIXME: find real value to use here */
97
98 DEBUGFUNC("e1000_acquire_swfw_sync_i210");
99
100 while (i < timeout) {
101 if (e1000_get_hw_semaphore_i210(hw)) {
102 ret_val = -E1000_ERR_SWFW_SYNC;
103 goto out;
104 }
105
106 swfw_sync = E1000_READ_REG(hw, E1000_SW_FW_SYNC);
107 if (!(swfw_sync & (fwmask | swmask)))
108 break;
109
110 /*
111 * Firmware currently using resource (fwmask)
112 * or other software thread using resource (swmask)
113 */
114 e1000_put_hw_semaphore_generic(hw);
115 msec_delay_irq(5);
116 i++;
117 }
118
119 if (i == timeout) {
120 DEBUGOUT("Driver can't access resource, SW_FW_SYNC timeout.\n");
121 ret_val = -E1000_ERR_SWFW_SYNC;
122 goto out;
123 }
124
125 swfw_sync |= swmask;
126 E1000_WRITE_REG(hw, E1000_SW_FW_SYNC, swfw_sync);
127
128 e1000_put_hw_semaphore_generic(hw);
129
130 out:
131 return ret_val;
132 }
133
134 /**
135 * e1000_release_swfw_sync_i210 - Release SW/FW semaphore
136 * @hw: pointer to the HW structure
137 * @mask: specifies which semaphore to acquire
138 *
139 * Release the SW/FW semaphore used to access the PHY or NVM. The mask
140 * will also specify which port we're releasing the lock for.
141 **/
142 void e1000_release_swfw_sync_i210(struct e1000_hw *hw, u16 mask)
143 {
144 u32 swfw_sync;
145
146 DEBUGFUNC("e1000_release_swfw_sync_i210");
147
148 while (e1000_get_hw_semaphore_i210(hw) != E1000_SUCCESS)
149 ; /* Empty */
150
151 swfw_sync = E1000_READ_REG(hw, E1000_SW_FW_SYNC);
152 swfw_sync &= ~mask;
153 E1000_WRITE_REG(hw, E1000_SW_FW_SYNC, swfw_sync);
154
155 e1000_put_hw_semaphore_generic(hw);
156 }
157
158 /**
159 * e1000_get_hw_semaphore_i210 - Acquire hardware semaphore
160 * @hw: pointer to the HW structure
161 *
162 * Acquire the HW semaphore to access the PHY or NVM
163 **/
164 static s32 e1000_get_hw_semaphore_i210(struct e1000_hw *hw)
165 {
166 u32 swsm;
167 s32 timeout = hw->nvm.word_size + 1;
168 s32 i = 0;
169
170 DEBUGFUNC("e1000_get_hw_semaphore_i210");
171
172 /* Get the SW semaphore */
173 while (i < timeout) {
174 swsm = E1000_READ_REG(hw, E1000_SWSM);
175 if (!(swsm & E1000_SWSM_SMBI))
176 break;
177
178 usec_delay(50);
179 i++;
180 }
181
182 if (i == timeout) {
183 /*
184 * In rare circumstances, the driver may not have released the
185 * SW semaphore. Clear the semaphore once before giving up.
186 */
187 if (hw->dev_spec._82575.clear_semaphore_once) {
188 hw->dev_spec._82575.clear_semaphore_once = FALSE;
189 e1000_put_hw_semaphore_generic(hw);
190 for (i = 0; i < timeout; i++) {
191 swsm = E1000_READ_REG(hw, E1000_SWSM);
192 if (!(swsm & E1000_SWSM_SMBI))
193 break;
194
195 usec_delay(50);
196 }
197 }
198
199 /* If we do not have the semaphore here, we have to give up. */
200 if (i == timeout) {
201 DEBUGOUT("Driver can't access device - SMBI bit is set.\n");
202 return -E1000_ERR_NVM;
203 }
204 }
205
206 /* Get the FW semaphore. */
207 for (i = 0; i < timeout; i++) {
208 swsm = E1000_READ_REG(hw, E1000_SWSM);
209 E1000_WRITE_REG(hw, E1000_SWSM, swsm | E1000_SWSM_SWESMBI);
210
211 /* Semaphore acquired if bit latched */
212 if (E1000_READ_REG(hw, E1000_SWSM) & E1000_SWSM_SWESMBI)
213 break;
214
215 usec_delay(50);
216 }
217
218 if (i == timeout) {
219 /* Release semaphores */
220 e1000_put_hw_semaphore_generic(hw);
221 DEBUGOUT("Driver can't access the NVM\n");
222 return -E1000_ERR_NVM;
223 }
224
225 return E1000_SUCCESS;
226 }
227
228 /**
229 * e1000_read_nvm_srrd_i210 - Reads Shadow Ram using EERD register
230 * @hw: pointer to the HW structure
231 * @offset: offset of word in the Shadow Ram to read
232 * @words: number of words to read
233 * @data: word read from the Shadow Ram
234 *
235 * Reads a 16 bit word from the Shadow Ram using the EERD register.
236 * Uses necessary synchronization semaphores.
237 **/
238 s32 e1000_read_nvm_srrd_i210(struct e1000_hw *hw, u16 offset, u16 words,
239 u16 *data)
240 {
241 s32 status = E1000_SUCCESS;
242 u16 i, count;
243
244 DEBUGFUNC("e1000_read_nvm_srrd_i210");
245
246 /* We cannot hold synchronization semaphores for too long,
247 * because of forceful takeover procedure. However it is more efficient
248 * to read in bursts than synchronizing access for each word. */
249 for (i = 0; i < words; i += E1000_EERD_EEWR_MAX_COUNT) {
250 count = (words - i) / E1000_EERD_EEWR_MAX_COUNT > 0 ?
251 E1000_EERD_EEWR_MAX_COUNT : (words - i);
252 if (hw->nvm.ops.acquire(hw) == E1000_SUCCESS) {
253 status = e1000_read_nvm_eerd(hw, offset, count,
254 data + i);
255 hw->nvm.ops.release(hw);
256 } else {
257 status = E1000_ERR_SWFW_SYNC;
258 }
259
260 if (status != E1000_SUCCESS)
261 break;
262 }
263
264 return status;
265 }
266
267 /**
268 * e1000_write_nvm_srwr_i210 - Write to Shadow RAM using EEWR
269 * @hw: pointer to the HW structure
270 * @offset: offset within the Shadow RAM to be written to
271 * @words: number of words to write
272 * @data: 16 bit word(s) to be written to the Shadow RAM
273 *
274 * Writes data to Shadow RAM at offset using EEWR register.
275 *
276 * If e1000_update_nvm_checksum is not called after this function , the
277 * data will not be committed to FLASH and also Shadow RAM will most likely
278 * contain an invalid checksum.
279 *
280 * If error code is returned, data and Shadow RAM may be inconsistent - buffer
281 * partially written.
282 **/
283 s32 e1000_write_nvm_srwr_i210(struct e1000_hw *hw, u16 offset, u16 words,
284 u16 *data)
285 {
286 s32 status = E1000_SUCCESS;
287 u16 i, count;
288
289 DEBUGFUNC("e1000_write_nvm_srwr_i210");
290
291 /* We cannot hold synchronization semaphores for too long,
292 * because of forceful takeover procedure. However it is more efficient
293 * to write in bursts than synchronizing access for each word. */
294 for (i = 0; i < words; i += E1000_EERD_EEWR_MAX_COUNT) {
295 count = (words - i) / E1000_EERD_EEWR_MAX_COUNT > 0 ?
296 E1000_EERD_EEWR_MAX_COUNT : (words - i);
297 if (hw->nvm.ops.acquire(hw) == E1000_SUCCESS) {
298 status = e1000_write_nvm_srwr(hw, offset, count,
299 data + i);
300 hw->nvm.ops.release(hw);
301 } else {
302 status = E1000_ERR_SWFW_SYNC;
303 }
304
305 if (status != E1000_SUCCESS)
306 break;
307 }
308
309 return status;
310 }
311
312 /**
313 * e1000_write_nvm_srwr - Write to Shadow Ram using EEWR
314 * @hw: pointer to the HW structure
315 * @offset: offset within the Shadow Ram to be written to
316 * @words: number of words to write
317 * @data: 16 bit word(s) to be written to the Shadow Ram
318 *
319 * Writes data to Shadow Ram at offset using EEWR register.
320 *
321 * If e1000_update_nvm_checksum is not called after this function , the
322 * Shadow Ram will most likely contain an invalid checksum.
323 **/
324 static s32 e1000_write_nvm_srwr(struct e1000_hw *hw, u16 offset, u16 words,
325 u16 *data)
326 {
327 struct e1000_nvm_info *nvm = &hw->nvm;
328 u32 i, k, eewr = 0;
329 u32 attempts = 100000;
330 s32 ret_val = E1000_SUCCESS;
331
332 DEBUGFUNC("e1000_write_nvm_srwr");
333
334 /*
335 * A check for invalid values: offset too large, too many words,
336 * too many words for the offset, and not enough words.
337 */
338 if ((offset >= nvm->word_size) || (words > (nvm->word_size - offset)) ||
339 (words == 0)) {
340 DEBUGOUT("nvm parameter(s) out of bounds\n");
341 ret_val = -E1000_ERR_NVM;
342 goto out;
343 }
344
345 for (i = 0; i < words; i++) {
346 eewr = ((offset+i) << E1000_NVM_RW_ADDR_SHIFT) |
347 (data[i] << E1000_NVM_RW_REG_DATA) |
348 E1000_NVM_RW_REG_START;
349
350 E1000_WRITE_REG(hw, E1000_SRWR, eewr);
351
352 for (k = 0; k < attempts; k++) {
353 if (E1000_NVM_RW_REG_DONE &
354 E1000_READ_REG(hw, E1000_SRWR)) {
355 ret_val = E1000_SUCCESS;
356 break;
357 }
358 usec_delay(5);
359 }
360
361 if (ret_val != E1000_SUCCESS) {
362 DEBUGOUT("Shadow RAM write EEWR timed out\n");
363 break;
364 }
365 }
366
367 out:
368 return ret_val;
369 }
370
371 /**
372 * e1000_read_nvm_i211 - Read NVM wrapper function for I211
373 * @hw: pointer to the HW structure
374 * @address: the word address (aka eeprom offset) to read
375 * @data: pointer to the data read
376 *
377 * Wrapper function to return data formerly found in the NVM.
378 **/
379 static s32 e1000_read_nvm_i211(struct e1000_hw *hw, u16 offset,
380 u16 words, u16 *data)
381 {
382 s32 ret_val = E1000_SUCCESS;
383
384 DEBUGFUNC("e1000_read_nvm_i211");
385
386 /* Only the MAC addr is required to be present in the iNVM */
387 switch (offset) {
388 case NVM_MAC_ADDR:
389 ret_val = e1000_read_invm_i211(hw, (u8)offset, &data[0]);
390 ret_val |= e1000_read_invm_i211(hw, (u8)offset+1, &data[1]);
391 ret_val |= e1000_read_invm_i211(hw, (u8)offset+2, &data[2]);
392 if (ret_val != E1000_SUCCESS)
393 DEBUGOUT("MAC Addr not found in iNVM\n");
394 break;
395 case NVM_INIT_CTRL_2:
396 ret_val = e1000_read_invm_i211(hw, (u8)offset, data);
397 if (ret_val != E1000_SUCCESS) {
398 *data = NVM_INIT_CTRL_2_DEFAULT_I211;
399 ret_val = E1000_SUCCESS;
400 }
401 break;
402 case NVM_INIT_CTRL_4:
403 ret_val = e1000_read_invm_i211(hw, (u8)offset, data);
404 if (ret_val != E1000_SUCCESS) {
405 *data = NVM_INIT_CTRL_4_DEFAULT_I211;
406 ret_val = E1000_SUCCESS;
407 }
408 break;
409 case NVM_LED_1_CFG:
410 ret_val = e1000_read_invm_i211(hw, (u8)offset, data);
411 if (ret_val != E1000_SUCCESS) {
412 *data = NVM_LED_1_CFG_DEFAULT_I211;
413 ret_val = E1000_SUCCESS;
414 }
415 break;
416 case NVM_LED_0_2_CFG:
417 ret_val = e1000_read_invm_i211(hw, (u8)offset, data);
418 if (ret_val != E1000_SUCCESS) {
419 *data = NVM_LED_0_2_CFG_DEFAULT_I211;
420 ret_val = E1000_SUCCESS;
421 }
422 break;
423 case NVM_ID_LED_SETTINGS:
424 ret_val = e1000_read_invm_i211(hw, (u8)offset, data);
425 if (ret_val != E1000_SUCCESS) {
426 *data = ID_LED_RESERVED_FFFF;
427 ret_val = E1000_SUCCESS;
428 }
429 break;
430 case NVM_SUB_DEV_ID:
431 *data = hw->subsystem_device_id;
432 break;
433 case NVM_SUB_VEN_ID:
434 *data = hw->subsystem_vendor_id;
435 break;
436 case NVM_DEV_ID:
437 *data = hw->device_id;
438 break;
439 case NVM_VEN_ID:
440 *data = hw->vendor_id;
441 break;
442 default:
443 DEBUGOUT1("NVM word 0x%02x is not mapped.\n", offset);
444 *data = NVM_RESERVED_WORD;
445 break;
446 }
447 return ret_val;
448 }
449
450 /**
451 * e1000_read_invm_i211 - Reads OTP
452 * @hw: pointer to the HW structure
453 * @address: the word address (aka eeprom offset) to read
454 * @data: pointer to the data read
455 *
456 * Reads 16-bit words from the OTP. Return error when the word is not
457 * stored in OTP.
458 **/
459 s32 e1000_read_invm_i211(struct e1000_hw *hw, u8 address, u16 *data)
460 {
461 s32 status = -E1000_ERR_INVM_VALUE_NOT_FOUND;
462 u32 invm_dword;
463 u16 i;
464 u8 record_type, word_address;
465
466 DEBUGFUNC("e1000_read_invm_i211");
467
468 for (i = 0; i < E1000_INVM_SIZE; i++) {
469 invm_dword = E1000_READ_REG(hw, E1000_INVM_DATA_REG(i));
470 /* Get record type */
471 record_type = INVM_DWORD_TO_RECORD_TYPE(invm_dword);
472 if (record_type == E1000_INVM_UNINITIALIZED_STRUCTURE)
473 break;
474 if (record_type == E1000_INVM_CSR_AUTOLOAD_STRUCTURE)
475 i += E1000_INVM_CSR_AUTOLOAD_DATA_SIZE_IN_DWORDS;
476 if (record_type == E1000_INVM_RSA_KEY_SHA256_STRUCTURE)
477 i += E1000_INVM_RSA_KEY_SHA256_DATA_SIZE_IN_DWORDS;
478 if (record_type == E1000_INVM_WORD_AUTOLOAD_STRUCTURE) {
479 word_address = INVM_DWORD_TO_WORD_ADDRESS(invm_dword);
480 if (word_address == address) {
481 *data = INVM_DWORD_TO_WORD_DATA(invm_dword);
482 DEBUGOUT2("Read INVM Word 0x%02x = %x",
483 address, *data);
484 status = E1000_SUCCESS;
485 break;
486 }
487 }
488 }
489 if (status != E1000_SUCCESS)
490 DEBUGOUT1("Requested word 0x%02x not found in OTP\n", address);
491 return status;
492 }
493
494 /**
495 * e1000_validate_nvm_checksum_i210 - Validate EEPROM checksum
496 * @hw: pointer to the HW structure
497 *
498 * Calculates the EEPROM checksum by reading/adding each word of the EEPROM
499 * and then verifies that the sum of the EEPROM is equal to 0xBABA.
500 **/
501 s32 e1000_validate_nvm_checksum_i210(struct e1000_hw *hw)
502 {
503 s32 status = E1000_SUCCESS;
504 s32 (*read_op_ptr)(struct e1000_hw *, u16, u16, u16 *);
505
506 DEBUGFUNC("e1000_validate_nvm_checksum_i210");
507
508 if (hw->nvm.ops.acquire(hw) == E1000_SUCCESS) {
509
510 /*
511 * Replace the read function with semaphore grabbing with
512 * the one that skips this for a while.
513 * We have semaphore taken already here.
514 */
515 read_op_ptr = hw->nvm.ops.read;
516 hw->nvm.ops.read = e1000_read_nvm_eerd;
517
518 status = e1000_validate_nvm_checksum_generic(hw);
519
520 /* Revert original read operation. */
521 hw->nvm.ops.read = read_op_ptr;
522
523 hw->nvm.ops.release(hw);
524 } else {
525 status = E1000_ERR_SWFW_SYNC;
526 }
527
528 return status;
529 }
530
531
532 /**
533 * e1000_update_nvm_checksum_i210 - Update EEPROM checksum
534 * @hw: pointer to the HW structure
535 *
536 * Updates the EEPROM checksum by reading/adding each word of the EEPROM
537 * up to the checksum. Then calculates the EEPROM checksum and writes the
538 * value to the EEPROM. Next commit EEPROM data onto the Flash.
539 **/
540 s32 e1000_update_nvm_checksum_i210(struct e1000_hw *hw)
541 {
542 s32 ret_val = E1000_SUCCESS;
543 u16 checksum = 0;
544 u16 i, nvm_data;
545
546 DEBUGFUNC("e1000_update_nvm_checksum_i210");
547
548 /*
549 * Read the first word from the EEPROM. If this times out or fails, do
550 * not continue or we could be in for a very long wait while every
551 * EEPROM read fails
552 */
553 ret_val = e1000_read_nvm_eerd(hw, 0, 1, &nvm_data);
554 if (ret_val != E1000_SUCCESS) {
555 DEBUGOUT("EEPROM read failed\n");
556 goto out;
557 }
558
559 if (hw->nvm.ops.acquire(hw) == E1000_SUCCESS) {
560 /*
561 * Do not use hw->nvm.ops.write, hw->nvm.ops.read
562 * because we do not want to take the synchronization
563 * semaphores twice here.
564 */
565
566 for (i = 0; i < NVM_CHECKSUM_REG; i++) {
567 ret_val = e1000_read_nvm_eerd(hw, i, 1, &nvm_data);
568 if (ret_val) {
569 hw->nvm.ops.release(hw);
570 DEBUGOUT("NVM Read Error while updating checksum.\n");
571 goto out;
572 }
573 checksum += nvm_data;
574 }
575 checksum = (u16) NVM_SUM - checksum;
576 ret_val = e1000_write_nvm_srwr(hw, NVM_CHECKSUM_REG, 1,
577 &checksum);
578 if (ret_val != E1000_SUCCESS) {
579 hw->nvm.ops.release(hw);
580 DEBUGOUT("NVM Write Error while updating checksum.\n");
581 goto out;
582 }
583
584 hw->nvm.ops.release(hw);
585
586 ret_val = e1000_update_flash_i210(hw);
587 } else {
588 ret_val = E1000_ERR_SWFW_SYNC;
589 }
590 out:
591 return ret_val;
592 }
593
594 /**
595 * e1000_update_flash_i210 - Commit EEPROM to the flash
596 * @hw: pointer to the HW structure
597 *
598 **/
599 s32 e1000_update_flash_i210(struct e1000_hw *hw)
600 {
601 s32 ret_val = E1000_SUCCESS;
602 u32 flup;
603
604 DEBUGFUNC("e1000_update_flash_i210");
605
606 ret_val = e1000_pool_flash_update_done_i210(hw);
607 if (ret_val == -E1000_ERR_NVM) {
608 DEBUGOUT("Flash update time out\n");
609 goto out;
610 }
611
612 flup = E1000_READ_REG(hw, E1000_EECD) | E1000_EECD_FLUPD_I210;
613 E1000_WRITE_REG(hw, E1000_EECD, flup);
614
615 ret_val = e1000_pool_flash_update_done_i210(hw);
616 if (ret_val == E1000_SUCCESS)
617 DEBUGOUT("Flash update complete\n");
618 else
619 DEBUGOUT("Flash update time out\n");
620
621 out:
622 return ret_val;
623 }
624
625 /**
626 * e1000_pool_flash_update_done_i210 - Pool FLUDONE status.
627 * @hw: pointer to the HW structure
628 *
629 **/
630 s32 e1000_pool_flash_update_done_i210(struct e1000_hw *hw)
631 {
632 s32 ret_val = -E1000_ERR_NVM;
633 u32 i, reg;
634
635 DEBUGFUNC("e1000_pool_flash_update_done_i210");
636
637 for (i = 0; i < E1000_FLUDONE_ATTEMPTS; i++) {
638 reg = E1000_READ_REG(hw, E1000_EECD);
639 if (reg & E1000_EECD_FLUDONE_I210) {
640 ret_val = E1000_SUCCESS;
641 break;
642 }
643 usec_delay(5);
644 }
645
646 return ret_val;
647 }
648
649 /**
650 * e1000_init_nvm_params_i210 - Initialize i210 NVM function pointers
651 * @hw: pointer to the HW structure
652 *
653 * Initialize the i210 NVM parameters and function pointers.
654 **/
655 static s32 e1000_init_nvm_params_i210(struct e1000_hw *hw)
656 {
657 s32 ret_val = E1000_SUCCESS;
658 struct e1000_nvm_info *nvm = &hw->nvm;
659
660 DEBUGFUNC("e1000_init_nvm_params_i210");
661
662 ret_val = e1000_init_nvm_params_82575(hw);
663
664 nvm->ops.acquire = e1000_acquire_nvm_i210;
665 nvm->ops.release = e1000_release_nvm_i210;
666 nvm->ops.read = e1000_read_nvm_srrd_i210;
667 nvm->ops.write = e1000_write_nvm_srwr_i210;
668 nvm->ops.valid_led_default = e1000_valid_led_default_i210;
669 nvm->ops.validate = e1000_validate_nvm_checksum_i210;
670 nvm->ops.update = e1000_update_nvm_checksum_i210;
671
672 return ret_val;
673 }
674
675 /**
676 * e1000_init_nvm_params_i211 - Initialize i211 NVM function pointers
677 * @hw: pointer to the HW structure
678 *
679 * Initialize the NVM parameters and function pointers for i211.
680 **/
681 static s32 e1000_init_nvm_params_i211(struct e1000_hw *hw)
682 {
683 struct e1000_nvm_info *nvm = &hw->nvm;
684
685 DEBUGFUNC("e1000_init_nvm_params_i211");
686
687 nvm->ops.acquire = e1000_acquire_nvm_i210;
688 nvm->ops.release = e1000_release_nvm_i210;
689 nvm->ops.read = e1000_read_nvm_i211;
690 nvm->ops.valid_led_default = e1000_valid_led_default_i210;
691 nvm->ops.write = e1000_null_write_nvm;
692 nvm->ops.validate = e1000_null_ops_generic;
693 nvm->ops.update = e1000_null_ops_generic;
694
695 return E1000_SUCCESS;
696 }
697
698 /**
699 * e1000_init_function_pointers_i210 - Init func ptrs.
700 * @hw: pointer to the HW structure
701 *
702 * Called to initialize all function pointers and parameters.
703 **/
704 void e1000_init_function_pointers_i210(struct e1000_hw *hw)
705 {
706 e1000_init_function_pointers_82575(hw);
707
708 switch (hw->mac.type) {
709 case e1000_i210:
710 hw->nvm.ops.init_params = e1000_init_nvm_params_i210;
711 break;
712 case e1000_i211:
713 hw->nvm.ops.init_params = e1000_init_nvm_params_i211;
714 break;
715 default:
716 break;
717 }
718 return;
719 }
720
721 /**
722 * e1000_valid_led_default_i210 - Verify a valid default LED config
723 * @hw: pointer to the HW structure
724 * @data: pointer to the NVM (EEPROM)
725 *
726 * Read the EEPROM for the current default LED configuration. If the
727 * LED configuration is not valid, set to a valid LED configuration.
728 **/
729 static s32 e1000_valid_led_default_i210(struct e1000_hw *hw, u16 *data)
730 {
731 s32 ret_val;
732
733 DEBUGFUNC("e1000_valid_led_default_i210");
734
735 ret_val = hw->nvm.ops.read(hw, NVM_ID_LED_SETTINGS, 1, data);
736 if (ret_val) {
737 DEBUGOUT("NVM Read Error\n");
738 goto out;
739 }
740
741 if (*data == ID_LED_RESERVED_0000 || *data == ID_LED_RESERVED_FFFF) {
742 switch (hw->phy.media_type) {
743 case e1000_media_type_internal_serdes:
744 *data = ID_LED_DEFAULT_I210_SERDES;
745 break;
746 case e1000_media_type_copper:
747 default:
748 *data = ID_LED_DEFAULT_I210;
749 break;
750 }
751 }
752 out:
753 return ret_val;
754 }
755
756 /**
757 * __e1000_access_xmdio_reg - Read/write XMDIO register
758 * @hw: pointer to the HW structure
759 * @address: XMDIO address to program
760 * @dev_addr: device address to program
761 * @data: pointer to value to read/write from/to the XMDIO address
762 * @read: boolean flag to indicate read or write
763 **/
764 static s32 __e1000_access_xmdio_reg(struct e1000_hw *hw, u16 address,
765 u8 dev_addr, u16 *data, bool read)
766 {
767 s32 ret_val = E1000_SUCCESS;
768
769 DEBUGFUNC("__e1000_access_xmdio_reg");
770
771 ret_val = hw->phy.ops.write_reg(hw, E1000_MMDAC, dev_addr);
772 if (ret_val)
773 return ret_val;
774
775 ret_val = hw->phy.ops.write_reg(hw, E1000_MMDAAD, address);
776 if (ret_val)
777 return ret_val;
778
779 ret_val = hw->phy.ops.write_reg(hw, E1000_MMDAC, E1000_MMDAC_FUNC_DATA |
780 dev_addr);
781 if (ret_val)
782 return ret_val;
783
784 if (read)
785 ret_val = hw->phy.ops.read_reg(hw, E1000_MMDAAD, data);
786 else
787 ret_val = hw->phy.ops.write_reg(hw, E1000_MMDAAD, *data);
788 if (ret_val)
789 return ret_val;
790
791 /* Recalibrate the device back to 0 */
792 ret_val = hw->phy.ops.write_reg(hw, E1000_MMDAC, 0);
793 if (ret_val)
794 return ret_val;
795
796 return ret_val;
797 }
798
799 /**
800 * e1000_read_xmdio_reg - Read XMDIO register
801 * @hw: pointer to the HW structure
802 * @addr: XMDIO address to program
803 * @dev_addr: device address to program
804 * @data: value to be read from the EMI address
805 **/
806 s32 e1000_read_xmdio_reg(struct e1000_hw *hw, u16 addr, u8 dev_addr, u16 *data)
807 {
808 DEBUGFUNC("e1000_read_xmdio_reg");
809
810 return __e1000_access_xmdio_reg(hw, addr, dev_addr, data, TRUE);
811 }
812
813 /**
814 * e1000_write_xmdio_reg - Write XMDIO register
815 * @hw: pointer to the HW structure
816 * @addr: XMDIO address to program
817 * @dev_addr: device address to program
818 * @data: value to be written to the XMDIO address
819 **/
820 s32 e1000_write_xmdio_reg(struct e1000_hw *hw, u16 addr, u8 dev_addr, u16 data)
821 {
822 DEBUGFUNC("e1000_read_xmdio_reg");
823
824 return __e1000_access_xmdio_reg(hw, addr, dev_addr, &data, FALSE);
825 }
826
827