BNX2X: usability fixups
[akaros.git] / kern / drivers / net / e1000 / e1000_nvm.c
1 /*******************************************************************************
2
3   Intel PRO/1000 Linux driver
4   Copyright(c) 1999 - 2008 Intel Corporation.
5
6   This program is free software; you can redistribute it and/or modify it
7   under the terms and conditions of the GNU General Public License,
8   version 2, as published by the Free Software Foundation.
9
10   This program is distributed in the hope it will be useful, but WITHOUT
11   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
13   more details.
14
15   You should have received a copy of the GNU General Public License along with
16   this program; if not, write to the Free Software Foundation, Inc.,
17   51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
18
19   The full GNU General Public License is included in this distribution in
20   the file called "COPYING".
21
22   Contact Information:
23   Linux NICS <linux.nics@intel.com>
24   e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
25   Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
26
27 *******************************************************************************/
28
29 FILE_LICENCE(GPL2_OR_LATER);
30
31 #include "e1000_api.h"
32
33 static void e1000_reload_nvm_generic(struct e1000_hw *hw);
34
35 /**
36  *  e1000_init_nvm_ops_generic - Initialize NVM function pointers
37  *  @hw: pointer to the HW structure
38  *
39  *  Setups up the function pointers to no-op functions
40  **/
41 void e1000_init_nvm_ops_generic(struct e1000_hw *hw)
42 {
43         struct e1000_nvm_info *nvm = &hw->nvm;
44         DEBUGFUNC("e1000_init_nvm_ops_generic");
45
46         /* Initialize function pointers */
47         nvm->ops.init_params = e1000_null_ops_generic;
48         nvm->ops.acquire = e1000_null_ops_generic;
49         nvm->ops.read = e1000_null_read_nvm;
50         nvm->ops.release = e1000_null_nvm_generic;
51         nvm->ops.reload = e1000_reload_nvm_generic;
52         nvm->ops.update = e1000_null_ops_generic;
53         nvm->ops.valid_led_default = e1000_null_led_default;
54         nvm->ops.validate = e1000_null_ops_generic;
55         nvm->ops.write = e1000_null_write_nvm;
56 }
57
58 /**
59  *  e1000_null_nvm_read - No-op function, return 0
60  *  @hw: pointer to the HW structure
61  **/
62 s32 e1000_null_read_nvm(struct e1000_hw *hw __unused, u16 a __unused,
63                                                 u16 b __unused, u16 * c __unused)
64 {
65         DEBUGFUNC("e1000_null_read_nvm");
66         return E1000_SUCCESS;
67 }
68
69 /**
70  *  e1000_null_nvm_generic - No-op function, return void
71  *  @hw: pointer to the HW structure
72  **/
73 void e1000_null_nvm_generic(struct e1000_hw *hw __unused)
74 {
75         DEBUGFUNC("e1000_null_nvm_generic");
76         return;
77 }
78
79 /**
80  *  e1000_null_led_default - No-op function, return 0
81  *  @hw: pointer to the HW structure
82  **/
83 s32 e1000_null_led_default(struct e1000_hw * hw __unused, u16 * data __unused)
84 {
85         DEBUGFUNC("e1000_null_led_default");
86         return E1000_SUCCESS;
87 }
88
89 /**
90  *  e1000_null_write_nvm - No-op function, return 0
91  *  @hw: pointer to the HW structure
92  **/
93 s32 e1000_null_write_nvm(struct e1000_hw * hw __unused, u16 a __unused,
94                                                  u16 b __unused, u16 * c __unused)
95 {
96         DEBUGFUNC("e1000_null_write_nvm");
97         return E1000_SUCCESS;
98 }
99
100 /**
101  *  e1000_raise_eec_clk - Raise EEPROM clock
102  *  @hw: pointer to the HW structure
103  *  @eecd: pointer to the EEPROM
104  *
105  *  Enable/Raise the EEPROM clock bit.
106  **/
107 static void e1000_raise_eec_clk(struct e1000_hw *hw, u32 * eecd)
108 {
109         *eecd = *eecd | E1000_EECD_SK;
110         E1000_WRITE_REG(hw, E1000_EECD, *eecd);
111         E1000_WRITE_FLUSH(hw);
112         usec_delay(hw->nvm.delay_usec);
113 }
114
115 /**
116  *  e1000_lower_eec_clk - Lower EEPROM clock
117  *  @hw: pointer to the HW structure
118  *  @eecd: pointer to the EEPROM
119  *
120  *  Clear/Lower the EEPROM clock bit.
121  **/
122 static void e1000_lower_eec_clk(struct e1000_hw *hw, u32 * eecd)
123 {
124         *eecd = *eecd & ~E1000_EECD_SK;
125         E1000_WRITE_REG(hw, E1000_EECD, *eecd);
126         E1000_WRITE_FLUSH(hw);
127         usec_delay(hw->nvm.delay_usec);
128 }
129
130 /**
131  *  e1000_shift_out_eec_bits - Shift data bits our to the EEPROM
132  *  @hw: pointer to the HW structure
133  *  @data: data to send to the EEPROM
134  *  @count: number of bits to shift out
135  *
136  *  We need to shift 'count' bits out to the EEPROM.  So, the value in the
137  *  "data" parameter will be shifted out to the EEPROM one bit at a time.
138  *  In order to do this, "data" must be broken down into bits.
139  **/
140 static void e1000_shift_out_eec_bits(struct e1000_hw *hw, u16 data, u16 count)
141 {
142         struct e1000_nvm_info *nvm = &hw->nvm;
143         u32 eecd = E1000_READ_REG(hw, E1000_EECD);
144         u32 mask;
145
146         DEBUGFUNC("e1000_shift_out_eec_bits");
147
148         mask = 0x01 << (count - 1);
149         if (nvm->type == e1000_nvm_eeprom_microwire)
150                 eecd &= ~E1000_EECD_DO;
151         else if (nvm->type == e1000_nvm_eeprom_spi)
152                 eecd |= E1000_EECD_DO;
153
154         do {
155                 eecd &= ~E1000_EECD_DI;
156
157                 if (data & mask)
158                         eecd |= E1000_EECD_DI;
159
160                 E1000_WRITE_REG(hw, E1000_EECD, eecd);
161                 E1000_WRITE_FLUSH(hw);
162
163                 usec_delay(nvm->delay_usec);
164
165                 e1000_raise_eec_clk(hw, &eecd);
166                 e1000_lower_eec_clk(hw, &eecd);
167
168                 mask >>= 1;
169         } while (mask);
170
171         eecd &= ~E1000_EECD_DI;
172         E1000_WRITE_REG(hw, E1000_EECD, eecd);
173 }
174
175 /**
176  *  e1000_shift_in_eec_bits - Shift data bits in from the EEPROM
177  *  @hw: pointer to the HW structure
178  *  @count: number of bits to shift in
179  *
180  *  In order to read a register from the EEPROM, we need to shift 'count' bits
181  *  in from the EEPROM.  Bits are "shifted in" by raising the clock input to
182  *  the EEPROM (setting the SK bit), and then reading the value of the data out
183  *  "DO" bit.  During this "shifting in" process the data in "DI" bit should
184  *  always be clear.
185  **/
186 static u16 e1000_shift_in_eec_bits(struct e1000_hw *hw, u16 count)
187 {
188         u32 eecd;
189         u32 i;
190         u16 data;
191
192         DEBUGFUNC("e1000_shift_in_eec_bits");
193
194         eecd = E1000_READ_REG(hw, E1000_EECD);
195
196         eecd &= ~(E1000_EECD_DO | E1000_EECD_DI);
197         data = 0;
198
199         for (i = 0; i < count; i++) {
200                 data <<= 1;
201                 e1000_raise_eec_clk(hw, &eecd);
202
203                 eecd = E1000_READ_REG(hw, E1000_EECD);
204
205                 eecd &= ~E1000_EECD_DI;
206                 if (eecd & E1000_EECD_DO)
207                         data |= 1;
208
209                 e1000_lower_eec_clk(hw, &eecd);
210         }
211
212         return data;
213 }
214
215 /**
216  *  e1000_poll_eerd_eewr_done - Poll for EEPROM read/write completion
217  *  @hw: pointer to the HW structure
218  *  @ee_reg: EEPROM flag for polling
219  *
220  *  Polls the EEPROM status bit for either read or write completion based
221  *  upon the value of 'ee_reg'.
222  **/
223 s32 e1000_poll_eerd_eewr_done(struct e1000_hw * hw, int ee_reg)
224 {
225         u32 attempts = 100000;
226         u32 i, reg = 0;
227         s32 ret_val = -E1000_ERR_NVM;
228
229         DEBUGFUNC("e1000_poll_eerd_eewr_done");
230
231         for (i = 0; i < attempts; i++) {
232                 if (ee_reg == E1000_NVM_POLL_READ)
233                         reg = E1000_READ_REG(hw, E1000_EERD);
234                 else
235                         reg = E1000_READ_REG(hw, E1000_EEWR);
236
237                 if (reg & E1000_NVM_RW_REG_DONE) {
238                         ret_val = E1000_SUCCESS;
239                         break;
240                 }
241
242                 usec_delay(5);
243         }
244
245         return ret_val;
246 }
247
248 /**
249  *  e1000_acquire_nvm_generic - Generic request for access to EEPROM
250  *  @hw: pointer to the HW structure
251  *
252  *  Set the EEPROM access request bit and wait for EEPROM access grant bit.
253  *  Return successful if access grant bit set, else clear the request for
254  *  EEPROM access and return -E1000_ERR_NVM (-1).
255  **/
256 s32 e1000_acquire_nvm_generic(struct e1000_hw * hw)
257 {
258         u32 eecd = E1000_READ_REG(hw, E1000_EECD);
259         s32 timeout = E1000_NVM_GRANT_ATTEMPTS;
260         s32 ret_val = E1000_SUCCESS;
261
262         DEBUGFUNC("e1000_acquire_nvm_generic");
263
264         E1000_WRITE_REG(hw, E1000_EECD, eecd | E1000_EECD_REQ);
265         eecd = E1000_READ_REG(hw, E1000_EECD);
266
267         while (timeout) {
268                 if (eecd & E1000_EECD_GNT)
269                         break;
270                 usec_delay(5);
271                 eecd = E1000_READ_REG(hw, E1000_EECD);
272                 timeout--;
273         }
274
275         if (!timeout) {
276                 eecd &= ~E1000_EECD_REQ;
277                 E1000_WRITE_REG(hw, E1000_EECD, eecd);
278                 DEBUGOUT("Could not acquire NVM grant\n");
279                 ret_val = -E1000_ERR_NVM;
280         }
281
282         return ret_val;
283 }
284
285 /**
286  *  e1000_standby_nvm - Return EEPROM to standby state
287  *  @hw: pointer to the HW structure
288  *
289  *  Return the EEPROM to a standby state.
290  **/
291 static void e1000_standby_nvm(struct e1000_hw *hw)
292 {
293         struct e1000_nvm_info *nvm = &hw->nvm;
294         u32 eecd = E1000_READ_REG(hw, E1000_EECD);
295
296         DEBUGFUNC("e1000_standby_nvm");
297
298         if (nvm->type == e1000_nvm_eeprom_microwire) {
299                 eecd &= ~(E1000_EECD_CS | E1000_EECD_SK);
300                 E1000_WRITE_REG(hw, E1000_EECD, eecd);
301                 E1000_WRITE_FLUSH(hw);
302                 usec_delay(nvm->delay_usec);
303
304                 e1000_raise_eec_clk(hw, &eecd);
305
306                 /* Select EEPROM */
307                 eecd |= E1000_EECD_CS;
308                 E1000_WRITE_REG(hw, E1000_EECD, eecd);
309                 E1000_WRITE_FLUSH(hw);
310                 usec_delay(nvm->delay_usec);
311
312                 e1000_lower_eec_clk(hw, &eecd);
313         } else if (nvm->type == e1000_nvm_eeprom_spi) {
314                 /* Toggle CS to flush commands */
315                 eecd |= E1000_EECD_CS;
316                 E1000_WRITE_REG(hw, E1000_EECD, eecd);
317                 E1000_WRITE_FLUSH(hw);
318                 usec_delay(nvm->delay_usec);
319                 eecd &= ~E1000_EECD_CS;
320                 E1000_WRITE_REG(hw, E1000_EECD, eecd);
321                 E1000_WRITE_FLUSH(hw);
322                 usec_delay(nvm->delay_usec);
323         }
324 }
325
326 /**
327  *  e1000_stop_nvm - Terminate EEPROM command
328  *  @hw: pointer to the HW structure
329  *
330  *  Terminates the current command by inverting the EEPROM's chip select pin.
331  **/
332 void e1000_stop_nvm(struct e1000_hw *hw)
333 {
334         u32 eecd;
335
336         DEBUGFUNC("e1000_stop_nvm");
337
338         eecd = E1000_READ_REG(hw, E1000_EECD);
339         if (hw->nvm.type == e1000_nvm_eeprom_spi) {
340                 /* Pull CS high */
341                 eecd |= E1000_EECD_CS;
342                 e1000_lower_eec_clk(hw, &eecd);
343         } else if (hw->nvm.type == e1000_nvm_eeprom_microwire) {
344                 /* CS on Microwire is active-high */
345                 eecd &= ~(E1000_EECD_CS | E1000_EECD_DI);
346                 E1000_WRITE_REG(hw, E1000_EECD, eecd);
347                 e1000_raise_eec_clk(hw, &eecd);
348                 e1000_lower_eec_clk(hw, &eecd);
349         }
350 }
351
352 /**
353  *  e1000_release_nvm_generic - Release exclusive access to EEPROM
354  *  @hw: pointer to the HW structure
355  *
356  *  Stop any current commands to the EEPROM and clear the EEPROM request bit.
357  **/
358 void e1000_release_nvm_generic(struct e1000_hw *hw)
359 {
360         u32 eecd;
361
362         DEBUGFUNC("e1000_release_nvm_generic");
363
364         e1000_stop_nvm(hw);
365
366         eecd = E1000_READ_REG(hw, E1000_EECD);
367         eecd &= ~E1000_EECD_REQ;
368         E1000_WRITE_REG(hw, E1000_EECD, eecd);
369 }
370
371 /**
372  *  e1000_ready_nvm_eeprom - Prepares EEPROM for read/write
373  *  @hw: pointer to the HW structure
374  *
375  *  Setups the EEPROM for reading and writing.
376  **/
377 static s32 e1000_ready_nvm_eeprom(struct e1000_hw *hw)
378 {
379         struct e1000_nvm_info *nvm = &hw->nvm;
380         u32 eecd = E1000_READ_REG(hw, E1000_EECD);
381         s32 ret_val = E1000_SUCCESS;
382         u16 timeout = 0;
383         u8 spi_stat_reg;
384
385         DEBUGFUNC("e1000_ready_nvm_eeprom");
386
387         if (nvm->type == e1000_nvm_eeprom_microwire) {
388                 /* Clear SK and DI */
389                 eecd &= ~(E1000_EECD_DI | E1000_EECD_SK);
390                 E1000_WRITE_REG(hw, E1000_EECD, eecd);
391                 /* Set CS */
392                 eecd |= E1000_EECD_CS;
393                 E1000_WRITE_REG(hw, E1000_EECD, eecd);
394         } else if (nvm->type == e1000_nvm_eeprom_spi) {
395                 /* Clear SK and CS */
396                 eecd &= ~(E1000_EECD_CS | E1000_EECD_SK);
397                 E1000_WRITE_REG(hw, E1000_EECD, eecd);
398                 usec_delay(1);
399                 timeout = NVM_MAX_RETRY_SPI;
400
401                 /*
402                  * Read "Status Register" repeatedly until the LSB is cleared.
403                  * The EEPROM will signal that the command has been completed
404                  * by clearing bit 0 of the internal status register.  If it's
405                  * not cleared within 'timeout', then error out.
406                  */
407                 while (timeout) {
408                         e1000_shift_out_eec_bits(hw, NVM_RDSR_OPCODE_SPI,
409                                                                          hw->nvm.opcode_bits);
410                         spi_stat_reg = (u8) e1000_shift_in_eec_bits(hw, 8);
411                         if (!(spi_stat_reg & NVM_STATUS_RDY_SPI))
412                                 break;
413
414                         usec_delay(5);
415                         e1000_standby_nvm(hw);
416                         timeout--;
417                 }
418
419                 if (!timeout) {
420                         DEBUGOUT("SPI NVM Status error\n");
421                         ret_val = -E1000_ERR_NVM;
422                         goto out;
423                 }
424         }
425
426 out:
427         return ret_val;
428 }
429
430 /**
431  *  e1000_read_nvm_spi - Read EEPROM's using SPI
432  *  @hw: pointer to the HW structure
433  *  @offset: offset of word in the EEPROM to read
434  *  @words: number of words to read
435  *  @data: word read from the EEPROM
436  *
437  *  Reads a 16 bit word from the EEPROM.
438  **/
439 s32 e1000_read_nvm_spi(struct e1000_hw * hw, u16 offset, u16 words, u16 * data)
440 {
441         struct e1000_nvm_info *nvm = &hw->nvm;
442         u32 i = 0;
443         s32 ret_val;
444         u16 word_in;
445         u8 read_opcode = NVM_READ_OPCODE_SPI;
446
447         DEBUGFUNC("e1000_read_nvm_spi");
448
449         /*
450          * A check for invalid values:  offset too large, too many words,
451          * and not enough words.
452          */
453         if ((offset >= nvm->word_size) || (words > (nvm->word_size - offset)) ||
454                 (words == 0)) {
455                 DEBUGOUT("nvm parameter(s) out of bounds\n");
456                 ret_val = -E1000_ERR_NVM;
457                 goto out;
458         }
459
460         ret_val = nvm->ops.acquire(hw);
461         if (ret_val)
462                 goto out;
463
464         ret_val = e1000_ready_nvm_eeprom(hw);
465         if (ret_val)
466                 goto release;
467
468         e1000_standby_nvm(hw);
469
470         if ((nvm->address_bits == 8) && (offset >= 128))
471                 read_opcode |= NVM_A8_OPCODE_SPI;
472
473         /* Send the READ command (opcode + addr) */
474         e1000_shift_out_eec_bits(hw, read_opcode, nvm->opcode_bits);
475         e1000_shift_out_eec_bits(hw, (u16) (offset * 2), nvm->address_bits);
476
477         /*
478          * Read the data.  SPI NVMs increment the address with each byte
479          * read and will roll over if reading beyond the end.  This allows
480          * us to read the whole NVM from any offset
481          */
482         for (i = 0; i < words; i++) {
483                 word_in = e1000_shift_in_eec_bits(hw, 16);
484                 data[i] = (word_in >> 8) | (word_in << 8);
485         }
486
487 release:
488         nvm->ops.release(hw);
489
490 out:
491         return ret_val;
492 }
493
494 /**
495  *  e1000_read_nvm_microwire - Reads EEPROM's using microwire
496  *  @hw: pointer to the HW structure
497  *  @offset: offset of word in the EEPROM to read
498  *  @words: number of words to read
499  *  @data: word read from the EEPROM
500  *
501  *  Reads a 16 bit word from the EEPROM.
502  **/
503 s32 e1000_read_nvm_microwire(struct e1000_hw * hw, u16 offset, u16 words,
504                                                          u16 * data)
505 {
506         struct e1000_nvm_info *nvm = &hw->nvm;
507         u32 i = 0;
508         s32 ret_val;
509         u8 read_opcode = NVM_READ_OPCODE_MICROWIRE;
510
511         DEBUGFUNC("e1000_read_nvm_microwire");
512
513         /*
514          * A check for invalid values:  offset too large, too many words,
515          * and not enough words.
516          */
517         if ((offset >= nvm->word_size) || (words > (nvm->word_size - offset)) ||
518                 (words == 0)) {
519                 DEBUGOUT("nvm parameter(s) out of bounds\n");
520                 ret_val = -E1000_ERR_NVM;
521                 goto out;
522         }
523
524         ret_val = nvm->ops.acquire(hw);
525         if (ret_val)
526                 goto out;
527
528         ret_val = e1000_ready_nvm_eeprom(hw);
529         if (ret_val)
530                 goto release;
531
532         for (i = 0; i < words; i++) {
533                 /* Send the READ command (opcode + addr) */
534                 e1000_shift_out_eec_bits(hw, read_opcode, nvm->opcode_bits);
535                 e1000_shift_out_eec_bits(hw, (u16) (offset + i), nvm->address_bits);
536
537                 /*
538                  * Read the data.  For microwire, each word requires the
539                  * overhead of setup and tear-down.
540                  */
541                 data[i] = e1000_shift_in_eec_bits(hw, 16);
542                 e1000_standby_nvm(hw);
543         }
544
545 release:
546         nvm->ops.release(hw);
547
548 out:
549         return ret_val;
550 }
551
552 /**
553  *  e1000_read_nvm_eerd - Reads EEPROM using EERD register
554  *  @hw: pointer to the HW structure
555  *  @offset: offset of word in the EEPROM to read
556  *  @words: number of words to read
557  *  @data: word read from the EEPROM
558  *
559  *  Reads a 16 bit word from the EEPROM using the EERD register.
560  **/
561 s32 e1000_read_nvm_eerd(struct e1000_hw * hw, u16 offset, u16 words, u16 * data)
562 {
563         struct e1000_nvm_info *nvm = &hw->nvm;
564         u32 i, eerd = 0;
565         s32 ret_val = E1000_SUCCESS;
566
567         DEBUGFUNC("e1000_read_nvm_eerd");
568
569         /*
570          * A check for invalid values:  offset too large, too many words,
571          * too many words for the offset, and not enough words.
572          */
573         if ((offset >= nvm->word_size) || (words > (nvm->word_size - offset)) ||
574                 (words == 0)) {
575                 DEBUGOUT("nvm parameter(s) out of bounds\n");
576                 ret_val = -E1000_ERR_NVM;
577                 goto out;
578         }
579
580         for (i = 0; i < words; i++) {
581                 eerd = ((offset + i) << E1000_NVM_RW_ADDR_SHIFT) +
582                         E1000_NVM_RW_REG_START;
583
584                 E1000_WRITE_REG(hw, E1000_EERD, eerd);
585                 ret_val = e1000_poll_eerd_eewr_done(hw, E1000_NVM_POLL_READ);
586                 if (ret_val)
587                         break;
588
589                 data[i] = (E1000_READ_REG(hw, E1000_EERD) >> E1000_NVM_RW_REG_DATA);
590         }
591
592 out:
593         return ret_val;
594 }
595
596 /**
597  *  e1000_write_nvm_spi - Write to EEPROM using SPI
598  *  @hw: pointer to the HW structure
599  *  @offset: offset within the EEPROM to be written to
600  *  @words: number of words to write
601  *  @data: 16 bit word(s) to be written to the EEPROM
602  *
603  *  Writes data to EEPROM at offset using SPI interface.
604  *
605  *  If e1000_update_nvm_checksum is not called after this function , the
606  *  EEPROM will most likely contain an invalid checksum.
607  **/
608 s32 e1000_write_nvm_spi(struct e1000_hw * hw, u16 offset, u16 words, u16 * data)
609 {
610         struct e1000_nvm_info *nvm = &hw->nvm;
611         s32 ret_val;
612         u16 widx = 0;
613
614         DEBUGFUNC("e1000_write_nvm_spi");
615
616         /*
617          * A check for invalid values:  offset too large, too many words,
618          * and not enough words.
619          */
620         if ((offset >= nvm->word_size) || (words > (nvm->word_size - offset)) ||
621                 (words == 0)) {
622                 DEBUGOUT("nvm parameter(s) out of bounds\n");
623                 ret_val = -E1000_ERR_NVM;
624                 goto out;
625         }
626
627         ret_val = nvm->ops.acquire(hw);
628         if (ret_val)
629                 goto out;
630
631         while (widx < words) {
632                 u8 write_opcode = NVM_WRITE_OPCODE_SPI;
633
634                 ret_val = e1000_ready_nvm_eeprom(hw);
635                 if (ret_val)
636                         goto release;
637
638                 e1000_standby_nvm(hw);
639
640                 /* Send the WRITE ENABLE command (8 bit opcode) */
641                 e1000_shift_out_eec_bits(hw, NVM_WREN_OPCODE_SPI, nvm->opcode_bits);
642
643                 e1000_standby_nvm(hw);
644
645                 /*
646                  * Some SPI eeproms use the 8th address bit embedded in the
647                  * opcode
648                  */
649                 if ((nvm->address_bits == 8) && (offset >= 128))
650                         write_opcode |= NVM_A8_OPCODE_SPI;
651
652                 /* Send the Write command (8-bit opcode + addr) */
653                 e1000_shift_out_eec_bits(hw, write_opcode, nvm->opcode_bits);
654                 e1000_shift_out_eec_bits(hw, (u16) ((offset + widx) * 2),
655                                                                  nvm->address_bits);
656
657                 /* Loop to allow for up to whole page write of eeprom */
658                 while (widx < words) {
659                         u16 word_out = data[widx];
660                         word_out = (word_out >> 8) | (word_out << 8);
661                         e1000_shift_out_eec_bits(hw, word_out, 16);
662                         widx++;
663
664                         if ((((offset + widx) * 2) % nvm->page_size) == 0) {
665                                 e1000_standby_nvm(hw);
666                                 break;
667                         }
668                 }
669         }
670
671         msec_delay(10);
672 release:
673         nvm->ops.release(hw);
674
675 out:
676         return ret_val;
677 }
678
679 /**
680  *  e1000_write_nvm_microwire - Writes EEPROM using microwire
681  *  @hw: pointer to the HW structure
682  *  @offset: offset within the EEPROM to be written to
683  *  @words: number of words to write
684  *  @data: 16 bit word(s) to be written to the EEPROM
685  *
686  *  Writes data to EEPROM at offset using microwire interface.
687  *
688  *  If e1000_update_nvm_checksum is not called after this function , the
689  *  EEPROM will most likely contain an invalid checksum.
690  **/
691 s32 e1000_write_nvm_microwire(struct e1000_hw * hw, u16 offset, u16 words,
692                                                           u16 * data)
693 {
694         struct e1000_nvm_info *nvm = &hw->nvm;
695         s32 ret_val;
696         u32 eecd;
697         u16 words_written = 0;
698         u16 widx = 0;
699
700         DEBUGFUNC("e1000_write_nvm_microwire");
701
702         /*
703          * A check for invalid values:  offset too large, too many words,
704          * and not enough words.
705          */
706         if ((offset >= nvm->word_size) || (words > (nvm->word_size - offset)) ||
707                 (words == 0)) {
708                 DEBUGOUT("nvm parameter(s) out of bounds\n");
709                 ret_val = -E1000_ERR_NVM;
710                 goto out;
711         }
712
713         ret_val = nvm->ops.acquire(hw);
714         if (ret_val)
715                 goto out;
716
717         ret_val = e1000_ready_nvm_eeprom(hw);
718         if (ret_val)
719                 goto release;
720
721         e1000_shift_out_eec_bits(hw, NVM_EWEN_OPCODE_MICROWIRE,
722                                                          (u16) (nvm->opcode_bits + 2));
723
724         e1000_shift_out_eec_bits(hw, 0, (u16) (nvm->address_bits - 2));
725
726         e1000_standby_nvm(hw);
727
728         while (words_written < words) {
729                 e1000_shift_out_eec_bits(hw, NVM_WRITE_OPCODE_MICROWIRE,
730                                                                  nvm->opcode_bits);
731
732                 e1000_shift_out_eec_bits(hw, (u16) (offset + words_written),
733                                                                  nvm->address_bits);
734
735                 e1000_shift_out_eec_bits(hw, data[words_written], 16);
736
737                 e1000_standby_nvm(hw);
738
739                 for (widx = 0; widx < 200; widx++) {
740                         eecd = E1000_READ_REG(hw, E1000_EECD);
741                         if (eecd & E1000_EECD_DO)
742                                 break;
743                         usec_delay(50);
744                 }
745
746                 if (widx == 200) {
747                         DEBUGOUT("NVM Write did not complete\n");
748                         ret_val = -E1000_ERR_NVM;
749                         goto release;
750                 }
751
752                 e1000_standby_nvm(hw);
753
754                 words_written++;
755         }
756
757         e1000_shift_out_eec_bits(hw, NVM_EWDS_OPCODE_MICROWIRE,
758                                                          (u16) (nvm->opcode_bits + 2));
759
760         e1000_shift_out_eec_bits(hw, 0, (u16) (nvm->address_bits - 2));
761
762 release:
763         nvm->ops.release(hw);
764
765 out:
766         return ret_val;
767 }
768
769 /**
770  *  e1000_read_pba_num_generic - Read device part number
771  *  @hw: pointer to the HW structure
772  *  @pba_num: pointer to device part number
773  *
774  *  Reads the product board assembly (PBA) number from the EEPROM and stores
775  *  the value in pba_num.
776  **/
777 s32 e1000_read_pba_num_generic(struct e1000_hw * hw, u32 * pba_num)
778 {
779         s32 ret_val;
780         u16 nvm_data;
781
782         DEBUGFUNC("e1000_read_pba_num_generic");
783
784         ret_val = hw->nvm.ops.read(hw, NVM_PBA_OFFSET_0, 1, &nvm_data);
785         if (ret_val) {
786                 DEBUGOUT("NVM Read Error\n");
787                 goto out;
788         }
789         *pba_num = (u32) (nvm_data << 16);
790
791         ret_val = hw->nvm.ops.read(hw, NVM_PBA_OFFSET_1, 1, &nvm_data);
792         if (ret_val) {
793                 DEBUGOUT("NVM Read Error\n");
794                 goto out;
795         }
796         *pba_num |= nvm_data;
797
798 out:
799         return ret_val;
800 }
801
802 /**
803  *  e1000_read_mac_addr_generic - Read device MAC address
804  *  @hw: pointer to the HW structure
805  *
806  *  Reads the device MAC address from the EEPROM and stores the value.
807  *  Since devices with two ports use the same EEPROM, we increment the
808  *  last bit in the MAC address for the second port.
809  **/
810 s32 e1000_read_mac_addr_generic(struct e1000_hw * hw)
811 {
812         u32 rar_high;
813         u32 rar_low;
814         u16 i;
815
816         rar_high = E1000_READ_REG(hw, E1000_RAH(0));
817         rar_low = E1000_READ_REG(hw, E1000_RAL(0));
818
819         for (i = 0; i < E1000_RAL_MAC_ADDR_LEN; i++)
820                 hw->mac.perm_addr[i] = (u8) (rar_low >> (i * 8));
821
822         for (i = 0; i < E1000_RAH_MAC_ADDR_LEN; i++)
823                 hw->mac.perm_addr[i + 4] = (u8) (rar_high >> (i * 8));
824
825         for (i = 0; i < ETH_ADDR_LEN; i++)
826                 hw->mac.addr[i] = hw->mac.perm_addr[i];
827
828         return E1000_SUCCESS;
829 }
830
831 /**
832  *  e1000_validate_nvm_checksum_generic - Validate EEPROM checksum
833  *  @hw: pointer to the HW structure
834  *
835  *  Calculates the EEPROM checksum by reading/adding each word of the EEPROM
836  *  and then verifies that the sum of the EEPROM is equal to 0xBABA.
837  **/
838 s32 e1000_validate_nvm_checksum_generic(struct e1000_hw * hw)
839 {
840         s32 ret_val = E1000_SUCCESS;
841         u16 checksum = 0;
842         u16 i, nvm_data;
843
844         DEBUGFUNC("e1000_validate_nvm_checksum_generic");
845
846         for (i = 0; i < (NVM_CHECKSUM_REG + 1); i++) {
847                 ret_val = hw->nvm.ops.read(hw, i, 1, &nvm_data);
848                 if (ret_val) {
849                         DEBUGOUT("NVM Read Error\n");
850                         goto out;
851                 }
852                 checksum += nvm_data;
853         }
854
855         if (checksum != (u16) NVM_SUM) {
856                 DEBUGOUT("NVM Checksum Invalid\n");
857                 ret_val = -E1000_ERR_NVM;
858                 goto out;
859         }
860
861 out:
862         return ret_val;
863 }
864
865 /**
866  *  e1000_update_nvm_checksum_generic - Update EEPROM checksum
867  *  @hw: pointer to the HW structure
868  *
869  *  Updates the EEPROM checksum by reading/adding each word of the EEPROM
870  *  up to the checksum.  Then calculates the EEPROM checksum and writes the
871  *  value to the EEPROM.
872  **/
873 s32 e1000_update_nvm_checksum_generic(struct e1000_hw * hw)
874 {
875         s32 ret_val;
876         u16 checksum = 0;
877         u16 i, nvm_data;
878
879         DEBUGFUNC("e1000_update_nvm_checksum");
880
881         for (i = 0; i < NVM_CHECKSUM_REG; i++) {
882                 ret_val = hw->nvm.ops.read(hw, i, 1, &nvm_data);
883                 if (ret_val) {
884                         DEBUGOUT("NVM Read Error while updating checksum.\n");
885                         goto out;
886                 }
887                 checksum += nvm_data;
888         }
889         checksum = (u16) NVM_SUM - checksum;
890         ret_val = hw->nvm.ops.write(hw, NVM_CHECKSUM_REG, 1, &checksum);
891         if (ret_val)
892                 DEBUGOUT("NVM Write Error while updating checksum.\n");
893
894 out:
895         return ret_val;
896 }
897
898 /**
899  *  e1000_reload_nvm_generic - Reloads EEPROM
900  *  @hw: pointer to the HW structure
901  *
902  *  Reloads the EEPROM by setting the "Reinitialize from EEPROM" bit in the
903  *  extended control register.
904  **/
905 static void e1000_reload_nvm_generic(struct e1000_hw *hw)
906 {
907         u32 ctrl_ext;
908
909         DEBUGFUNC("e1000_reload_nvm_generic");
910
911         usec_delay(10);
912         ctrl_ext = E1000_READ_REG(hw, E1000_CTRL_EXT);
913         ctrl_ext |= E1000_CTRL_EXT_EE_RST;
914         E1000_WRITE_REG(hw, E1000_CTRL_EXT, ctrl_ext);
915         E1000_WRITE_FLUSH(hw);
916 }