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