1 /* Intel PRO/1000 Linux driver 2 * Copyright(c) 1999 - 2014 Intel Corporation. 3 * 4 * This program is free software; you can redistribute it and/or modify it 5 * under the terms and conditions of the GNU General Public License, 6 * version 2, as published by the Free Software Foundation. 7 * 8 * This program is distributed in the hope it will be useful, but WITHOUT 9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 11 * more details. 12 * 13 * The full GNU General Public License is included in this distribution in 14 * the file called "COPYING". 15 * 16 * Contact Information: 17 * Linux NICS <linux.nics@intel.com> 18 * e1000-devel Mailing List <e1000-devel@lists.sourceforge.net> 19 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497 20 */ 21 22 #include "e1000.h" 23 24 /** 25 * e1000_raise_eec_clk - Raise EEPROM clock 26 * @hw: pointer to the HW structure 27 * @eecd: pointer to the EEPROM 28 * 29 * Enable/Raise the EEPROM clock bit. 30 **/ 31 static void e1000_raise_eec_clk(struct e1000_hw *hw, u32 *eecd) 32 { 33 *eecd = *eecd | E1000_EECD_SK; 34 ew32(EECD, *eecd); 35 e1e_flush(); 36 udelay(hw->nvm.delay_usec); 37 } 38 39 /** 40 * e1000_lower_eec_clk - Lower EEPROM clock 41 * @hw: pointer to the HW structure 42 * @eecd: pointer to the EEPROM 43 * 44 * Clear/Lower the EEPROM clock bit. 45 **/ 46 static void e1000_lower_eec_clk(struct e1000_hw *hw, u32 *eecd) 47 { 48 *eecd = *eecd & ~E1000_EECD_SK; 49 ew32(EECD, *eecd); 50 e1e_flush(); 51 udelay(hw->nvm.delay_usec); 52 } 53 54 /** 55 * e1000_shift_out_eec_bits - Shift data bits our to the EEPROM 56 * @hw: pointer to the HW structure 57 * @data: data to send to the EEPROM 58 * @count: number of bits to shift out 59 * 60 * We need to shift 'count' bits out to the EEPROM. So, the value in the 61 * "data" parameter will be shifted out to the EEPROM one bit at a time. 62 * In order to do this, "data" must be broken down into bits. 63 **/ 64 static void e1000_shift_out_eec_bits(struct e1000_hw *hw, u16 data, u16 count) 65 { 66 struct e1000_nvm_info *nvm = &hw->nvm; 67 u32 eecd = er32(EECD); 68 u32 mask; 69 70 mask = 0x01 << (count - 1); 71 if (nvm->type == e1000_nvm_eeprom_spi) 72 eecd |= E1000_EECD_DO; 73 74 do { 75 eecd &= ~E1000_EECD_DI; 76 77 if (data & mask) 78 eecd |= E1000_EECD_DI; 79 80 ew32(EECD, eecd); 81 e1e_flush(); 82 83 udelay(nvm->delay_usec); 84 85 e1000_raise_eec_clk(hw, &eecd); 86 e1000_lower_eec_clk(hw, &eecd); 87 88 mask >>= 1; 89 } while (mask); 90 91 eecd &= ~E1000_EECD_DI; 92 ew32(EECD, eecd); 93 } 94 95 /** 96 * e1000_shift_in_eec_bits - Shift data bits in from the EEPROM 97 * @hw: pointer to the HW structure 98 * @count: number of bits to shift in 99 * 100 * In order to read a register from the EEPROM, we need to shift 'count' bits 101 * in from the EEPROM. Bits are "shifted in" by raising the clock input to 102 * the EEPROM (setting the SK bit), and then reading the value of the data out 103 * "DO" bit. During this "shifting in" process the data in "DI" bit should 104 * always be clear. 105 **/ 106 static u16 e1000_shift_in_eec_bits(struct e1000_hw *hw, u16 count) 107 { 108 u32 eecd; 109 u32 i; 110 u16 data; 111 112 eecd = er32(EECD); 113 eecd &= ~(E1000_EECD_DO | E1000_EECD_DI); 114 data = 0; 115 116 for (i = 0; i < count; i++) { 117 data <<= 1; 118 e1000_raise_eec_clk(hw, &eecd); 119 120 eecd = er32(EECD); 121 122 eecd &= ~E1000_EECD_DI; 123 if (eecd & E1000_EECD_DO) 124 data |= 1; 125 126 e1000_lower_eec_clk(hw, &eecd); 127 } 128 129 return data; 130 } 131 132 /** 133 * e1000e_poll_eerd_eewr_done - Poll for EEPROM read/write completion 134 * @hw: pointer to the HW structure 135 * @ee_reg: EEPROM flag for polling 136 * 137 * Polls the EEPROM status bit for either read or write completion based 138 * upon the value of 'ee_reg'. 139 **/ 140 s32 e1000e_poll_eerd_eewr_done(struct e1000_hw *hw, int ee_reg) 141 { 142 u32 attempts = 100000; 143 u32 i, reg = 0; 144 145 for (i = 0; i < attempts; i++) { 146 if (ee_reg == E1000_NVM_POLL_READ) 147 reg = er32(EERD); 148 else 149 reg = er32(EEWR); 150 151 if (reg & E1000_NVM_RW_REG_DONE) 152 return 0; 153 154 udelay(5); 155 } 156 157 return -E1000_ERR_NVM; 158 } 159 160 /** 161 * e1000e_acquire_nvm - Generic request for access to EEPROM 162 * @hw: pointer to the HW structure 163 * 164 * Set the EEPROM access request bit and wait for EEPROM access grant bit. 165 * Return successful if access grant bit set, else clear the request for 166 * EEPROM access and return -E1000_ERR_NVM (-1). 167 **/ 168 s32 e1000e_acquire_nvm(struct e1000_hw *hw) 169 { 170 u32 eecd = er32(EECD); 171 s32 timeout = E1000_NVM_GRANT_ATTEMPTS; 172 173 ew32(EECD, eecd | E1000_EECD_REQ); 174 eecd = er32(EECD); 175 176 while (timeout) { 177 if (eecd & E1000_EECD_GNT) 178 break; 179 udelay(5); 180 eecd = er32(EECD); 181 timeout--; 182 } 183 184 if (!timeout) { 185 eecd &= ~E1000_EECD_REQ; 186 ew32(EECD, eecd); 187 e_dbg("Could not acquire NVM grant\n"); 188 return -E1000_ERR_NVM; 189 } 190 191 return 0; 192 } 193 194 /** 195 * e1000_standby_nvm - Return EEPROM to standby state 196 * @hw: pointer to the HW structure 197 * 198 * Return the EEPROM to a standby state. 199 **/ 200 static void e1000_standby_nvm(struct e1000_hw *hw) 201 { 202 struct e1000_nvm_info *nvm = &hw->nvm; 203 u32 eecd = er32(EECD); 204 205 if (nvm->type == e1000_nvm_eeprom_spi) { 206 /* Toggle CS to flush commands */ 207 eecd |= E1000_EECD_CS; 208 ew32(EECD, eecd); 209 e1e_flush(); 210 udelay(nvm->delay_usec); 211 eecd &= ~E1000_EECD_CS; 212 ew32(EECD, eecd); 213 e1e_flush(); 214 udelay(nvm->delay_usec); 215 } 216 } 217 218 /** 219 * e1000_stop_nvm - Terminate EEPROM command 220 * @hw: pointer to the HW structure 221 * 222 * Terminates the current command by inverting the EEPROM's chip select pin. 223 **/ 224 static void e1000_stop_nvm(struct e1000_hw *hw) 225 { 226 u32 eecd; 227 228 eecd = er32(EECD); 229 if (hw->nvm.type == e1000_nvm_eeprom_spi) { 230 /* Pull CS high */ 231 eecd |= E1000_EECD_CS; 232 e1000_lower_eec_clk(hw, &eecd); 233 } 234 } 235 236 /** 237 * e1000e_release_nvm - Release exclusive access to EEPROM 238 * @hw: pointer to the HW structure 239 * 240 * Stop any current commands to the EEPROM and clear the EEPROM request bit. 241 **/ 242 void e1000e_release_nvm(struct e1000_hw *hw) 243 { 244 u32 eecd; 245 246 e1000_stop_nvm(hw); 247 248 eecd = er32(EECD); 249 eecd &= ~E1000_EECD_REQ; 250 ew32(EECD, eecd); 251 } 252 253 /** 254 * e1000_ready_nvm_eeprom - Prepares EEPROM for read/write 255 * @hw: pointer to the HW structure 256 * 257 * Setups the EEPROM for reading and writing. 258 **/ 259 static s32 e1000_ready_nvm_eeprom(struct e1000_hw *hw) 260 { 261 struct e1000_nvm_info *nvm = &hw->nvm; 262 u32 eecd = er32(EECD); 263 u8 spi_stat_reg; 264 265 if (nvm->type == e1000_nvm_eeprom_spi) { 266 u16 timeout = NVM_MAX_RETRY_SPI; 267 268 /* Clear SK and CS */ 269 eecd &= ~(E1000_EECD_CS | E1000_EECD_SK); 270 ew32(EECD, eecd); 271 e1e_flush(); 272 udelay(1); 273 274 /* Read "Status Register" repeatedly until the LSB is cleared. 275 * The EEPROM will signal that the command has been completed 276 * by clearing bit 0 of the internal status register. If it's 277 * not cleared within 'timeout', then error out. 278 */ 279 while (timeout) { 280 e1000_shift_out_eec_bits(hw, NVM_RDSR_OPCODE_SPI, 281 hw->nvm.opcode_bits); 282 spi_stat_reg = (u8)e1000_shift_in_eec_bits(hw, 8); 283 if (!(spi_stat_reg & NVM_STATUS_RDY_SPI)) 284 break; 285 286 udelay(5); 287 e1000_standby_nvm(hw); 288 timeout--; 289 } 290 291 if (!timeout) { 292 e_dbg("SPI NVM Status error\n"); 293 return -E1000_ERR_NVM; 294 } 295 } 296 297 return 0; 298 } 299 300 /** 301 * e1000e_read_nvm_eerd - Reads EEPROM using EERD register 302 * @hw: pointer to the HW structure 303 * @offset: offset of word in the EEPROM to read 304 * @words: number of words to read 305 * @data: word read from the EEPROM 306 * 307 * Reads a 16 bit word from the EEPROM using the EERD register. 308 **/ 309 s32 e1000e_read_nvm_eerd(struct e1000_hw *hw, u16 offset, u16 words, u16 *data) 310 { 311 struct e1000_nvm_info *nvm = &hw->nvm; 312 u32 i, eerd = 0; 313 s32 ret_val = 0; 314 315 /* A check for invalid values: offset too large, too many words, 316 * too many words for the offset, and not enough words. 317 */ 318 if ((offset >= nvm->word_size) || (words > (nvm->word_size - offset)) || 319 (words == 0)) { 320 e_dbg("nvm parameter(s) out of bounds\n"); 321 return -E1000_ERR_NVM; 322 } 323 324 for (i = 0; i < words; i++) { 325 eerd = ((offset + i) << E1000_NVM_RW_ADDR_SHIFT) + 326 E1000_NVM_RW_REG_START; 327 328 ew32(EERD, eerd); 329 ret_val = e1000e_poll_eerd_eewr_done(hw, E1000_NVM_POLL_READ); 330 if (ret_val) 331 break; 332 333 data[i] = (er32(EERD) >> E1000_NVM_RW_REG_DATA); 334 } 335 336 return ret_val; 337 } 338 339 /** 340 * e1000e_write_nvm_spi - Write to EEPROM using SPI 341 * @hw: pointer to the HW structure 342 * @offset: offset within the EEPROM to be written to 343 * @words: number of words to write 344 * @data: 16 bit word(s) to be written to the EEPROM 345 * 346 * Writes data to EEPROM at offset using SPI interface. 347 * 348 * If e1000e_update_nvm_checksum is not called after this function , the 349 * EEPROM will most likely contain an invalid checksum. 350 **/ 351 s32 e1000e_write_nvm_spi(struct e1000_hw *hw, u16 offset, u16 words, u16 *data) 352 { 353 struct e1000_nvm_info *nvm = &hw->nvm; 354 s32 ret_val = -E1000_ERR_NVM; 355 u16 widx = 0; 356 357 /* A check for invalid values: offset too large, too many words, 358 * and not enough words. 359 */ 360 if ((offset >= nvm->word_size) || (words > (nvm->word_size - offset)) || 361 (words == 0)) { 362 e_dbg("nvm parameter(s) out of bounds\n"); 363 return -E1000_ERR_NVM; 364 } 365 366 while (widx < words) { 367 u8 write_opcode = NVM_WRITE_OPCODE_SPI; 368 369 ret_val = nvm->ops.acquire(hw); 370 if (ret_val) 371 return ret_val; 372 373 ret_val = e1000_ready_nvm_eeprom(hw); 374 if (ret_val) { 375 nvm->ops.release(hw); 376 return ret_val; 377 } 378 379 e1000_standby_nvm(hw); 380 381 /* Send the WRITE ENABLE command (8 bit opcode) */ 382 e1000_shift_out_eec_bits(hw, NVM_WREN_OPCODE_SPI, 383 nvm->opcode_bits); 384 385 e1000_standby_nvm(hw); 386 387 /* Some SPI eeproms use the 8th address bit embedded in the 388 * opcode 389 */ 390 if ((nvm->address_bits == 8) && (offset >= 128)) 391 write_opcode |= NVM_A8_OPCODE_SPI; 392 393 /* Send the Write command (8-bit opcode + addr) */ 394 e1000_shift_out_eec_bits(hw, write_opcode, nvm->opcode_bits); 395 e1000_shift_out_eec_bits(hw, (u16)((offset + widx) * 2), 396 nvm->address_bits); 397 398 /* Loop to allow for up to whole page write of eeprom */ 399 while (widx < words) { 400 u16 word_out = data[widx]; 401 word_out = (word_out >> 8) | (word_out << 8); 402 e1000_shift_out_eec_bits(hw, word_out, 16); 403 widx++; 404 405 if ((((offset + widx) * 2) % nvm->page_size) == 0) { 406 e1000_standby_nvm(hw); 407 break; 408 } 409 } 410 usleep_range(10000, 20000); 411 nvm->ops.release(hw); 412 } 413 414 return ret_val; 415 } 416 417 /** 418 * e1000_read_pba_string_generic - Read device part number 419 * @hw: pointer to the HW structure 420 * @pba_num: pointer to device part number 421 * @pba_num_size: size of part number buffer 422 * 423 * Reads the product board assembly (PBA) number from the EEPROM and stores 424 * the value in pba_num. 425 **/ 426 s32 e1000_read_pba_string_generic(struct e1000_hw *hw, u8 *pba_num, 427 u32 pba_num_size) 428 { 429 s32 ret_val; 430 u16 nvm_data; 431 u16 pba_ptr; 432 u16 offset; 433 u16 length; 434 435 if (pba_num == NULL) { 436 e_dbg("PBA string buffer was null\n"); 437 return -E1000_ERR_INVALID_ARGUMENT; 438 } 439 440 ret_val = e1000_read_nvm(hw, NVM_PBA_OFFSET_0, 1, &nvm_data); 441 if (ret_val) { 442 e_dbg("NVM Read Error\n"); 443 return ret_val; 444 } 445 446 ret_val = e1000_read_nvm(hw, NVM_PBA_OFFSET_1, 1, &pba_ptr); 447 if (ret_val) { 448 e_dbg("NVM Read Error\n"); 449 return ret_val; 450 } 451 452 /* if nvm_data is not ptr guard the PBA must be in legacy format which 453 * means pba_ptr is actually our second data word for the PBA number 454 * and we can decode it into an ascii string 455 */ 456 if (nvm_data != NVM_PBA_PTR_GUARD) { 457 e_dbg("NVM PBA number is not stored as string\n"); 458 459 /* make sure callers buffer is big enough to store the PBA */ 460 if (pba_num_size < E1000_PBANUM_LENGTH) { 461 e_dbg("PBA string buffer too small\n"); 462 return E1000_ERR_NO_SPACE; 463 } 464 465 /* extract hex string from data and pba_ptr */ 466 pba_num[0] = (nvm_data >> 12) & 0xF; 467 pba_num[1] = (nvm_data >> 8) & 0xF; 468 pba_num[2] = (nvm_data >> 4) & 0xF; 469 pba_num[3] = nvm_data & 0xF; 470 pba_num[4] = (pba_ptr >> 12) & 0xF; 471 pba_num[5] = (pba_ptr >> 8) & 0xF; 472 pba_num[6] = '-'; 473 pba_num[7] = 0; 474 pba_num[8] = (pba_ptr >> 4) & 0xF; 475 pba_num[9] = pba_ptr & 0xF; 476 477 /* put a null character on the end of our string */ 478 pba_num[10] = '\0'; 479 480 /* switch all the data but the '-' to hex char */ 481 for (offset = 0; offset < 10; offset++) { 482 if (pba_num[offset] < 0xA) 483 pba_num[offset] += '0'; 484 else if (pba_num[offset] < 0x10) 485 pba_num[offset] += 'A' - 0xA; 486 } 487 488 return 0; 489 } 490 491 ret_val = e1000_read_nvm(hw, pba_ptr, 1, &length); 492 if (ret_val) { 493 e_dbg("NVM Read Error\n"); 494 return ret_val; 495 } 496 497 if (length == 0xFFFF || length == 0) { 498 e_dbg("NVM PBA number section invalid length\n"); 499 return -E1000_ERR_NVM_PBA_SECTION; 500 } 501 /* check if pba_num buffer is big enough */ 502 if (pba_num_size < (((u32)length * 2) - 1)) { 503 e_dbg("PBA string buffer too small\n"); 504 return -E1000_ERR_NO_SPACE; 505 } 506 507 /* trim pba length from start of string */ 508 pba_ptr++; 509 length--; 510 511 for (offset = 0; offset < length; offset++) { 512 ret_val = e1000_read_nvm(hw, pba_ptr + offset, 1, &nvm_data); 513 if (ret_val) { 514 e_dbg("NVM Read Error\n"); 515 return ret_val; 516 } 517 pba_num[offset * 2] = (u8)(nvm_data >> 8); 518 pba_num[(offset * 2) + 1] = (u8)(nvm_data & 0xFF); 519 } 520 pba_num[offset * 2] = '\0'; 521 522 return 0; 523 } 524 525 /** 526 * e1000_read_mac_addr_generic - Read device MAC address 527 * @hw: pointer to the HW structure 528 * 529 * Reads the device MAC address from the EEPROM and stores the value. 530 * Since devices with two ports use the same EEPROM, we increment the 531 * last bit in the MAC address for the second port. 532 **/ 533 s32 e1000_read_mac_addr_generic(struct e1000_hw *hw) 534 { 535 u32 rar_high; 536 u32 rar_low; 537 u16 i; 538 539 rar_high = er32(RAH(0)); 540 rar_low = er32(RAL(0)); 541 542 for (i = 0; i < E1000_RAL_MAC_ADDR_LEN; i++) 543 hw->mac.perm_addr[i] = (u8)(rar_low >> (i * 8)); 544 545 for (i = 0; i < E1000_RAH_MAC_ADDR_LEN; i++) 546 hw->mac.perm_addr[i + 4] = (u8)(rar_high >> (i * 8)); 547 548 for (i = 0; i < ETH_ALEN; i++) 549 hw->mac.addr[i] = hw->mac.perm_addr[i]; 550 551 return 0; 552 } 553 554 /** 555 * e1000e_validate_nvm_checksum_generic - Validate EEPROM checksum 556 * @hw: pointer to the HW structure 557 * 558 * Calculates the EEPROM checksum by reading/adding each word of the EEPROM 559 * and then verifies that the sum of the EEPROM is equal to 0xBABA. 560 **/ 561 s32 e1000e_validate_nvm_checksum_generic(struct e1000_hw *hw) 562 { 563 s32 ret_val; 564 u16 checksum = 0; 565 u16 i, nvm_data; 566 567 for (i = 0; i < (NVM_CHECKSUM_REG + 1); i++) { 568 ret_val = e1000_read_nvm(hw, i, 1, &nvm_data); 569 if (ret_val) { 570 e_dbg("NVM Read Error\n"); 571 return ret_val; 572 } 573 checksum += nvm_data; 574 } 575 576 if (checksum != (u16)NVM_SUM) { 577 e_dbg("NVM Checksum Invalid\n"); 578 return -E1000_ERR_NVM; 579 } 580 581 return 0; 582 } 583 584 /** 585 * e1000e_update_nvm_checksum_generic - Update EEPROM checksum 586 * @hw: pointer to the HW structure 587 * 588 * Updates the EEPROM checksum by reading/adding each word of the EEPROM 589 * up to the checksum. Then calculates the EEPROM checksum and writes the 590 * value to the EEPROM. 591 **/ 592 s32 e1000e_update_nvm_checksum_generic(struct e1000_hw *hw) 593 { 594 s32 ret_val; 595 u16 checksum = 0; 596 u16 i, nvm_data; 597 598 for (i = 0; i < NVM_CHECKSUM_REG; i++) { 599 ret_val = e1000_read_nvm(hw, i, 1, &nvm_data); 600 if (ret_val) { 601 e_dbg("NVM Read Error while updating checksum.\n"); 602 return ret_val; 603 } 604 checksum += nvm_data; 605 } 606 checksum = (u16)NVM_SUM - checksum; 607 ret_val = e1000_write_nvm(hw, NVM_CHECKSUM_REG, 1, &checksum); 608 if (ret_val) 609 e_dbg("NVM Write Error while updating checksum.\n"); 610 611 return ret_val; 612 } 613 614 /** 615 * e1000e_reload_nvm_generic - Reloads EEPROM 616 * @hw: pointer to the HW structure 617 * 618 * Reloads the EEPROM by setting the "Reinitialize from EEPROM" bit in the 619 * extended control register. 620 **/ 621 void e1000e_reload_nvm_generic(struct e1000_hw *hw) 622 { 623 u32 ctrl_ext; 624 625 usleep_range(10, 20); 626 ctrl_ext = er32(CTRL_EXT); 627 ctrl_ext |= E1000_CTRL_EXT_EE_RST; 628 ew32(CTRL_EXT, ctrl_ext); 629 e1e_flush(); 630 } 631