e1000e_nvm.c File Reference

#include "e1000e.h"

Go to the source code of this file.

Functions
	FILE_LICENCE (GPL2_OR_LATER)
static void	e1000e_stop_nvm (struct e1000_hw *hw)
	e1000e_stop_nvm - Terminate EEPROM command : pointer to the HW structure
static void	e1000e_reload_nvm (struct e1000_hw *hw)
	e1000e_reload_nvm - Reloads EEPROM : pointer to the HW structure
void	e1000e_init_nvm_ops_generic (struct e1000_hw *hw)
	e1000e_init_nvm_ops_generic - Initialize NVM function pointers : pointer to the HW structure
static void	e1000e_raise_eec_clk (struct e1000_hw *hw, u32 *eecd)
	e1000e_raise_eec_clk - Raise EEPROM clock : pointer to the HW structure : pointer to the EEPROM
static void	e1000e_lower_eec_clk (struct e1000_hw *hw, u32 *eecd)
	e1000e_lower_eec_clk - Lower EEPROM clock : pointer to the HW structure : pointer to the EEPROM
static void	e1000e_shift_out_eec_bits (struct e1000_hw *hw, u16 data, u16 count)
	e1000e_shift_out_eec_bits - Shift data bits our to the EEPROM : pointer to the HW structure : data to send to the EEPROM : number of bits to shift out
static u16	e1000e_shift_in_eec_bits (struct e1000_hw *hw, u16 count)
	e1000e_shift_in_eec_bits - Shift data bits in from the EEPROM : pointer to the HW structure : number of bits to shift in
s32	e1000e_poll_eerd_eewr_done (struct e1000_hw *hw, int ee_reg)
	e1000e_poll_eerd_eewr_done - Poll for EEPROM read/write completion : pointer to the HW structure : EEPROM flag for polling
s32	e1000e_acquire_nvm (struct e1000_hw *hw)
	e1000e_acquire_nvm - Generic request for access to EEPROM : pointer to the HW structure
static void	e1000e_standby_nvm (struct e1000_hw *hw)
	e1000e_standby_nvm - Return EEPROM to standby state : pointer to the HW structure
void	e1000e_release_nvm (struct e1000_hw *hw)
	e1000e_release_nvm - Release exclusive access to EEPROM : pointer to the HW structure
static s32	e1000e_ready_nvm_eeprom (struct e1000_hw *hw)
	e1000e_ready_nvm_eeprom - Prepares EEPROM for read/write : pointer to the HW structure
s32	e1000e_read_nvm_eerd (struct e1000_hw *hw, u16 offset, u16 words, u16 *data)
	e1000e_read_nvm_eerd - Reads EEPROM using EERD register : pointer to the HW structure : offset of word in the EEPROM to read : number of words to read : word read from the EEPROM
s32	e1000e_write_nvm_spi (struct e1000_hw *hw, u16 offset, u16 words, u16 *data)
	e1000e_write_nvm_spi - Write to EEPROM using SPI : pointer to the HW structure : offset within the EEPROM to be written to : number of words to write : 16 bit word(s) to be written to the EEPROM
s32	e1000e_read_pba_num (struct e1000_hw *hw, u32 *pba_num)
	e1000e_read_pba_num - Read device part number : pointer to the HW structure : pointer to device part number
s32	e1000e_read_mac_addr_generic (struct e1000_hw *hw)
	e1000e_read_mac_addr_generic - Read device MAC address : pointer to the HW structure
s32	e1000e_validate_nvm_checksum_generic (struct e1000_hw *hw)
	e1000e_validate_nvm_checksum_generic - Validate EEPROM checksum : pointer to the HW structure
s32	e1000e_update_nvm_checksum_generic (struct e1000_hw *hw)
	e1000e_update_nvm_checksum_generic - Update EEPROM checksum : pointer to the HW structure

---

Function Documentation

FILE_LICENCE

(

GPL2_OR_LATER

)

static void e1000e_stop_nvm

(

struct e1000_hw *

hw

)

[static]

e1000e_stop_nvm - Terminate EEPROM command : pointer to the HW structure

Terminates the current command by inverting the EEPROM's chip select pin.

Definition at line 252 of file e1000e_nvm.c.

References E1000_EECD_CS, e1000_nvm_eeprom_spi, e1000e_lower_eec_clk(), er32, e1000_hw::nvm, e1000_nvm_info::type, and u32.

Referenced by e1000e_release_nvm().

{
        u32 eecd;

        eecd = er32(EECD);
        if (hw->nvm.type == e1000_nvm_eeprom_spi) {
                /* Pull CS high */
                eecd |= E1000_EECD_CS;
                e1000e_lower_eec_clk(hw, &eecd);
        }
}

static void e1000e_reload_nvm

(

struct e1000_hw *

hw

)

[static]

e1000e_reload_nvm - Reloads EEPROM : pointer to the HW structure

Reloads the EEPROM by setting the "Reinitialize from EEPROM" bit in the extended control register.

Definition at line 586 of file e1000e_nvm.c.

References E1000_CTRL_EXT_EE_RST, e1e_flush, er32, ew32, u32, and udelay().

Referenced by e1000e_init_nvm_ops_generic().

{
        u32 ctrl_ext;

        udelay(10);
        ctrl_ext = er32(CTRL_EXT);
        ctrl_ext |= E1000_CTRL_EXT_EE_RST;
        ew32(CTRL_EXT, ctrl_ext);
        e1e_flush();
}

void e1000e_init_nvm_ops_generic

(

struct e1000_hw *

hw

)

e1000e_init_nvm_ops_generic - Initialize NVM function pointers : pointer to the HW structure

Setups up the function pointers to no-op functions

Definition at line 42 of file e1000e_nvm.c.

References e1000e_reload_nvm(), e1000_hw::nvm, e1000_nvm_info::ops, and e1000_nvm_operations::reload.

Referenced by e1000e_init_function_pointers_80003es2lan(), e1000e_init_function_pointers_82571(), and e1000e_init_function_pointers_ich8lan().

{
        struct e1000_nvm_info *nvm = &hw->nvm;
        /* Initialize function pointers */
        nvm->ops.reload = e1000e_reload_nvm;
}

static void e1000e_raise_eec_clk	(	struct e1000_hw *	hw,
		u32 *	eecd
	)			[static]

e1000e_raise_eec_clk - Raise EEPROM clock : pointer to the HW structure : pointer to the EEPROM

Enable/Raise the EEPROM clock bit.

Definition at line 56 of file e1000e_nvm.c.

References e1000_nvm_info::delay_usec, E1000_EECD_SK, e1e_flush, ew32, e1000_hw::nvm, and udelay().

Referenced by e1000e_shift_in_eec_bits(), and e1000e_shift_out_eec_bits().

{
        *eecd = *eecd | E1000_EECD_SK;
        ew32(EECD, *eecd);
        e1e_flush();
        udelay(hw->nvm.delay_usec);
}

static void e1000e_lower_eec_clk	(	struct e1000_hw *	hw,
		u32 *	eecd
	)			[static]

e1000e_lower_eec_clk - Lower EEPROM clock : pointer to the HW structure : pointer to the EEPROM

Clear/Lower the EEPROM clock bit.

Definition at line 71 of file e1000e_nvm.c.

References e1000_nvm_info::delay_usec, E1000_EECD_SK, e1e_flush, ew32, e1000_hw::nvm, and udelay().

Referenced by e1000e_shift_in_eec_bits(), e1000e_shift_out_eec_bits(), and e1000e_stop_nvm().

{
        *eecd = *eecd & ~E1000_EECD_SK;
        ew32(EECD, *eecd);
        e1e_flush();
        udelay(hw->nvm.delay_usec);
}

static void e1000e_shift_out_eec_bits	(	struct e1000_hw *	hw,
		u16	data,
		u16	count
	)			[static]

e1000e_shift_out_eec_bits - Shift data bits our to the EEPROM : pointer to the HW structure : data to send to the EEPROM : number of bits to shift out

We need to shift 'count' bits out to the EEPROM. So, the value in the "data" parameter will be shifted out to the EEPROM one bit at a time. In order to do this, "data" must be broken down into bits.

Definition at line 89 of file e1000e_nvm.c.

References e1000_nvm_info::delay_usec, E1000_EECD_DI, E1000_EECD_DO, e1000_nvm_eeprom_spi, e1000e_lower_eec_clk(), e1000e_raise_eec_clk(), e1e_flush, er32, ew32, e1000_hw::nvm, e1000_nvm_info::type, u32, and udelay().

Referenced by e1000e_ready_nvm_eeprom(), and e1000e_write_nvm_spi().

{
        struct e1000_nvm_info *nvm = &hw->nvm;
        u32 eecd = er32(EECD);
        u32 mask;

        mask = 0x01 << (count - 1);
        if (nvm->type == e1000_nvm_eeprom_spi)
                eecd |= E1000_EECD_DO;

        do {
                eecd &= ~E1000_EECD_DI;

                if (data & mask)
                        eecd |= E1000_EECD_DI;

                ew32(EECD, eecd);
                e1e_flush();

                udelay(nvm->delay_usec);

                e1000e_raise_eec_clk(hw, &eecd);
                e1000e_lower_eec_clk(hw, &eecd);

                mask >>= 1;
        } while (mask);

        eecd &= ~E1000_EECD_DI;
        ew32(EECD, eecd);
}

static u16 e1000e_shift_in_eec_bits	(	struct e1000_hw *	hw,
		u16	count
	)			[static]

e1000e_shift_in_eec_bits - Shift data bits in from the EEPROM : pointer to the HW structure : number of bits to shift in

In order to read a register from the EEPROM, we need to shift 'count' bits in from the EEPROM. Bits are "shifted in" by raising the clock input to the EEPROM (setting the SK bit), and then reading the value of the data out "DO" bit. During this "shifting in" process the data in "DI" bit should always be clear.

Definition at line 131 of file e1000e_nvm.c.

References E1000_EECD_DI, E1000_EECD_DO, e1000e_lower_eec_clk(), e1000e_raise_eec_clk(), er32, u16, and u32.

Referenced by e1000e_ready_nvm_eeprom().

{
        u32 eecd;
        u32 i;
        u16 data;

        eecd = er32(EECD);
        eecd &= ~(E1000_EECD_DO | E1000_EECD_DI);
        data = 0;

        for (i = 0; i < count; i++) {
                data <<= 1;
                e1000e_raise_eec_clk(hw, &eecd);

                eecd = er32(EECD);

                eecd &= ~E1000_EECD_DI;
                if (eecd & E1000_EECD_DO)
                        data |= 1;

                e1000e_lower_eec_clk(hw, &eecd);
        }

        return data;
}

s32 e1000e_poll_eerd_eewr_done	(	struct e1000_hw *	hw,
		int	ee_reg
	)

e1000e_poll_eerd_eewr_done - Poll for EEPROM read/write completion : pointer to the HW structure : EEPROM flag for polling

Polls the EEPROM status bit for either read or write completion based upon the value of 'ee_reg'.

Definition at line 165 of file e1000e_nvm.c.

References E1000_ERR_NVM, E1000_NVM_POLL_READ, E1000_NVM_RW_REG_DONE, E1000_SUCCESS, er32, u32, and udelay().

Referenced by e1000e_read_nvm_eerd(), and e1000e_write_nvm_eewr_82571().

{
        u32 attempts = 100000;
        u32 i, reg = 0;
        s32 ret_val = -E1000_ERR_NVM;

        for (i = 0; i < attempts; i++) {
                if (ee_reg == E1000_NVM_POLL_READ)
                        reg = er32(EERD);
                else
                        reg = er32(EEWR);

                if (reg & E1000_NVM_RW_REG_DONE) {
                        ret_val = E1000_SUCCESS;
                        break;
                }

                udelay(5);
        }

        return ret_val;
}

s32 e1000e_acquire_nvm

(

struct e1000_hw *

hw

)

e1000e_acquire_nvm - Generic request for access to EEPROM : pointer to the HW structure

Set the EEPROM access request bit and wait for EEPROM access grant bit. Return successful if access grant bit set, else clear the request for EEPROM access and return -E1000_ERR_NVM (-1).

Definition at line 196 of file e1000e_nvm.c.

References E1000_EECD_GNT, E1000_EECD_REQ, E1000_ERR_NVM, E1000_NVM_GRANT_ATTEMPTS, E1000_SUCCESS, e_dbg, er32, ew32, timeout(), u32, and udelay().

Referenced by e1000e_acquire_nvm_80003es2lan(), and e1000e_acquire_nvm_82571().

{
        u32 eecd = er32(EECD);
        s32 timeout = E1000_NVM_GRANT_ATTEMPTS;
        s32 ret_val = E1000_SUCCESS;

        ew32(EECD, eecd | E1000_EECD_REQ);
        eecd = er32(EECD);
        while (timeout) {
                if (eecd & E1000_EECD_GNT)
                        break;
                udelay(5);
                eecd = er32(EECD);
                timeout--;
        }

        if (!timeout) {
                eecd &= ~E1000_EECD_REQ;
                ew32(EECD, eecd);
                e_dbg("Could not acquire NVM grant\n");
                ret_val = -E1000_ERR_NVM;
        }

        return ret_val;
}

static void e1000e_standby_nvm

(

struct e1000_hw *

hw

)

[static]

e1000e_standby_nvm - Return EEPROM to standby state : pointer to the HW structure

Return the EEPROM to a standby state.

Definition at line 228 of file e1000e_nvm.c.

References e1000_nvm_info::delay_usec, E1000_EECD_CS, e1000_nvm_eeprom_spi, e1e_flush, er32, ew32, e1000_hw::nvm, e1000_nvm_info::type, u32, and udelay().

Referenced by e1000e_ready_nvm_eeprom(), and e1000e_write_nvm_spi().

{
        struct e1000_nvm_info *nvm = &hw->nvm;
        u32 eecd = er32(EECD);

        if (nvm->type == e1000_nvm_eeprom_spi) {
                /* Toggle CS to flush commands */
                eecd |= E1000_EECD_CS;
                ew32(EECD, eecd);
                e1e_flush();
                udelay(nvm->delay_usec);
                eecd &= ~E1000_EECD_CS;
                ew32(EECD, eecd);
                e1e_flush();
                udelay(nvm->delay_usec);
        }
}

void e1000e_release_nvm

(

struct e1000_hw *

hw

)

e1000e_release_nvm - Release exclusive access to EEPROM : pointer to the HW structure

Stop any current commands to the EEPROM and clear the EEPROM request bit.

Definition at line 270 of file e1000e_nvm.c.

References E1000_EECD_REQ, e1000e_stop_nvm(), er32, ew32, and u32.

Referenced by e1000e_release_nvm_80003es2lan(), and e1000e_release_nvm_82571().

{
        u32 eecd;

        e1000e_stop_nvm(hw);

        eecd = er32(EECD);
        eecd &= ~E1000_EECD_REQ;
        ew32(EECD, eecd);
}

static s32 e1000e_ready_nvm_eeprom

(

struct e1000_hw *

hw

)

[static]

e1000e_ready_nvm_eeprom - Prepares EEPROM for read/write : pointer to the HW structure

Setups the EEPROM for reading and writing.

Definition at line 287 of file e1000e_nvm.c.

References E1000_EECD_CS, E1000_EECD_SK, E1000_ERR_NVM, e1000_nvm_eeprom_spi, E1000_SUCCESS, e1000e_shift_in_eec_bits(), e1000e_shift_out_eec_bits(), e1000e_standby_nvm(), e_dbg, er32, ew32, e1000_hw::nvm, NVM_MAX_RETRY_SPI, NVM_RDSR_OPCODE_SPI, NVM_STATUS_RDY_SPI, e1000_nvm_info::opcode_bits, timeout(), e1000_nvm_info::type, u16, u32, u8, and udelay().

Referenced by e1000e_write_nvm_spi().

{
        struct e1000_nvm_info *nvm = &hw->nvm;
        u32 eecd = er32(EECD);
        s32 ret_val = E1000_SUCCESS;
        u16 timeout = 0;
        u8 spi_stat_reg;

        if (nvm->type == e1000_nvm_eeprom_spi) {
                /* Clear SK and CS */
                eecd &= ~(E1000_EECD_CS | E1000_EECD_SK);
                ew32(EECD, eecd);
                udelay(1);
                timeout = NVM_MAX_RETRY_SPI;

                /*
                 * Read "Status Register" repeatedly until the LSB is cleared.
                 * The EEPROM will signal that the command has been completed
                 * by clearing bit 0 of the internal status register.  If it's
                 * not cleared within 'timeout', then error out.
                 */
                while (timeout) {
                        e1000e_shift_out_eec_bits(hw, NVM_RDSR_OPCODE_SPI,
                                                 hw->nvm.opcode_bits);
                        spi_stat_reg = (u8)e1000e_shift_in_eec_bits(hw, 8);
                        if (!(spi_stat_reg & NVM_STATUS_RDY_SPI))
                                break;

                        udelay(5);
                        e1000e_standby_nvm(hw);
                        timeout--;
                }

                if (!timeout) {
                        e_dbg("SPI NVM Status error\n");
                        ret_val = -E1000_ERR_NVM;
                        goto out;
                }
        }

out:
        return ret_val;
}

s32 e1000e_read_nvm_eerd	(	struct e1000_hw *	hw,
		u16	offset,
		u16	words,
		u16 *	data
	)

e1000e_read_nvm_eerd - Reads EEPROM using EERD register : pointer to the HW structure : offset of word in the EEPROM to read : number of words to read : word read from the EEPROM

Reads a 16 bit word from the EEPROM using the EERD register.

Definition at line 340 of file e1000e_nvm.c.

References E1000_ERR_NVM, E1000_NVM_POLL_READ, E1000_NVM_RW_ADDR_SHIFT, E1000_NVM_RW_REG_DATA, E1000_NVM_RW_REG_START, E1000_SUCCESS, e1000e_poll_eerd_eewr_done(), e_dbg, er32, ew32, e1000_hw::nvm, u32, and e1000_nvm_info::word_size.

Referenced by e1000e_init_nvm_params_80003es2lan(), and e1000e_init_nvm_params_82571().

{
        struct e1000_nvm_info *nvm = &hw->nvm;
        u32 i, eerd = 0;
        s32 ret_val = E1000_SUCCESS;

        /*
         * A check for invalid values:  offset too large, too many words,
         * too many words for the offset, and not enough words.
         */
        if ((offset >= nvm->word_size) || (words > (nvm->word_size - offset)) ||
            (words == 0)) {
                e_dbg("nvm parameter(s) out of bounds\n");
                ret_val = -E1000_ERR_NVM;
                goto out;
        }

        for (i = 0; i < words; i++) {
                eerd = ((offset+i) << E1000_NVM_RW_ADDR_SHIFT) +
                       E1000_NVM_RW_REG_START;

                ew32(EERD, eerd);
                ret_val = e1000e_poll_eerd_eewr_done(hw, E1000_NVM_POLL_READ);
                if (ret_val)
                        break;

                data[i] = (er32(EERD) >>
                           E1000_NVM_RW_REG_DATA);
        }

out:
        return ret_val;
}

s32 e1000e_write_nvm_spi	(	struct e1000_hw *	hw,
		u16	offset,
		u16	words,
		u16 *	data
	)

e1000e_write_nvm_spi - Write to EEPROM using SPI : pointer to the HW structure : offset within the EEPROM to be written to : number of words to write : 16 bit word(s) to be written to the EEPROM

Writes data to EEPROM at offset using SPI interface.

If e1000e_update_nvm_checksum is not called after this function , the EEPROM will most likely contain an invalid checksum.

Definition at line 386 of file e1000e_nvm.c.

References e1000_nvm_operations::acquire, e1000_nvm_info::address_bits, E1000_ERR_NVM, e1000e_ready_nvm_eeprom(), e1000e_shift_out_eec_bits(), e1000e_standby_nvm(), e_dbg, msleep, e1000_hw::nvm, NVM_A8_OPCODE_SPI, NVM_WREN_OPCODE_SPI, NVM_WRITE_OPCODE_SPI, e1000_nvm_info::opcode_bits, e1000_nvm_info::ops, e1000_nvm_info::page_size, e1000_nvm_operations::release, u16, u8, and e1000_nvm_info::word_size.

Referenced by e1000e_write_nvm_80003es2lan(), and e1000e_write_nvm_82571().

{
        struct e1000_nvm_info *nvm = &hw->nvm;
        s32 ret_val;
        u16 widx = 0;

        /*
         * A check for invalid values:  offset too large, too many words,
         * and not enough words.
         */
        if ((offset >= nvm->word_size) || (words > (nvm->word_size - offset)) ||
            (words == 0)) {
                e_dbg("nvm parameter(s) out of bounds\n");
                ret_val = -E1000_ERR_NVM;
                goto out;
        }

        ret_val = nvm->ops.acquire(hw);
        if (ret_val)
                goto out;

        while (widx < words) {
                u8 write_opcode = NVM_WRITE_OPCODE_SPI;

                ret_val = e1000e_ready_nvm_eeprom(hw);
                if (ret_val)
                        goto release;

                e1000e_standby_nvm(hw);

                /* Send the WRITE ENABLE command (8 bit opcode) */
                e1000e_shift_out_eec_bits(hw, NVM_WREN_OPCODE_SPI,
                                         nvm->opcode_bits);

                e1000e_standby_nvm(hw);

                /*
                 * Some SPI eeproms use the 8th address bit embedded in the
                 * opcode
                 */
                if ((nvm->address_bits == 8) && (offset >= 128))
                        write_opcode |= NVM_A8_OPCODE_SPI;

                /* Send the Write command (8-bit opcode + addr) */
                e1000e_shift_out_eec_bits(hw, write_opcode, nvm->opcode_bits);
                e1000e_shift_out_eec_bits(hw, (u16)((offset + widx) * 2),
                                         nvm->address_bits);

                /* Loop to allow for up to whole page write of eeprom */
                while (widx < words) {
                        u16 word_out = data[widx];
                        word_out = (word_out >> 8) | (word_out << 8);
                        e1000e_shift_out_eec_bits(hw, word_out, 16);
                        widx++;

                        if ((((offset + widx) * 2) % nvm->page_size) == 0) {
                                e1000e_standby_nvm(hw);
                                break;
                        }
                }
        }

        msleep(10);
release:
        nvm->ops.release(hw);

out:
        return ret_val;
}

s32 e1000e_read_pba_num	(	struct e1000_hw *	hw,
		u32 *	pba_num
	)

e1000e_read_pba_num - Read device part number : pointer to the HW structure : pointer to device part number

Reads the product board assembly (PBA) number from the EEPROM and stores the value in pba_num.

Definition at line 464 of file e1000e_nvm.c.

References e1000e_read_nvm(), e_dbg, NVM_PBA_OFFSET_0, NVM_PBA_OFFSET_1, u16, and u32.

{
        s32  ret_val;
        u16 nvm_data;

        ret_val = e1000e_read_nvm(hw, NVM_PBA_OFFSET_0, 1, &nvm_data);
        if (ret_val) {
                e_dbg("NVM Read Error\n");
                goto out;
        }
        *pba_num = (u32)(nvm_data << 16);

        ret_val = e1000e_read_nvm(hw, NVM_PBA_OFFSET_1, 1, &nvm_data);
        if (ret_val) {
                e_dbg("NVM Read Error\n");
                goto out;
        }
        *pba_num |= nvm_data;

out:
        return ret_val;
}

s32 e1000e_read_mac_addr_generic

(

struct e1000_hw *

hw

)

e1000e_read_mac_addr_generic - Read device MAC address : pointer to the HW structure

Reads the device MAC address from the EEPROM and stores the value. Since devices with two ports use the same EEPROM, we increment the last bit in the MAC address for the second port.

Definition at line 495 of file e1000e_nvm.c.

References e1000_mac_info::addr, E1000_RAH_MAC_ADDR_LEN, E1000_RAL_MAC_ADDR_LEN, E1000_SUCCESS, er32, ETH_ADDR_LEN, e1000_hw::mac, e1000_mac_info::perm_addr, u16, u32, and u8.

Referenced by e1000e_init_mac_ops_generic(), e1000e_read_mac_addr(), e1000e_read_mac_addr_80003es2lan(), and e1000e_read_mac_addr_82571().

{
        u32 rar_high;
        u32 rar_low;
        u16 i;

        rar_high = er32(RAH(0));
        rar_low = er32(RAL(0));

        for (i = 0; i < E1000_RAL_MAC_ADDR_LEN; i++)
                hw->mac.perm_addr[i] = (u8)(rar_low >> (i*8));

        for (i = 0; i < E1000_RAH_MAC_ADDR_LEN; i++)
                hw->mac.perm_addr[i+4] = (u8)(rar_high >> (i*8));

        for (i = 0; i < ETH_ADDR_LEN; i++)
                hw->mac.addr[i] = hw->mac.perm_addr[i];

        return E1000_SUCCESS;
}

s32 e1000e_validate_nvm_checksum_generic

(

struct e1000_hw *

hw

)

e1000e_validate_nvm_checksum_generic - Validate EEPROM checksum : pointer to the HW structure

Calculates the EEPROM checksum by reading/adding each word of the EEPROM and then verifies that the sum of the EEPROM is equal to 0xBABA.

Definition at line 523 of file e1000e_nvm.c.

References E1000_ERR_NVM, E1000_SUCCESS, e1000e_read_nvm(), e_dbg, NVM_CHECKSUM_REG, NVM_SUM, and u16.

Referenced by e1000e_init_nvm_params_80003es2lan(), e1000e_validate_nvm_checksum_82571(), and e1000e_validate_nvm_checksum_ich8lan().

{
        s32 ret_val = E1000_SUCCESS;
        u16 checksum = 0;
        u16 i, nvm_data;

        for (i = 0; i < (NVM_CHECKSUM_REG + 1); i++) {
                ret_val = e1000e_read_nvm(hw, i, 1, &nvm_data);
                if (ret_val) {
                        e_dbg("NVM Read Error\n");
                        goto out;
                }
                checksum += nvm_data;
        }

        if (checksum != (u16) NVM_SUM) {
                e_dbg("NVM Checksum Invalid\n");
                ret_val = -E1000_ERR_NVM;
                goto out;
        }

out:
        return ret_val;
}

s32 e1000e_update_nvm_checksum_generic

(

struct e1000_hw *

hw

)

e1000e_update_nvm_checksum_generic - Update EEPROM checksum : pointer to the HW structure

Updates the EEPROM checksum by reading/adding each word of the EEPROM up to the checksum. Then calculates the EEPROM checksum and writes the value to the EEPROM.

Definition at line 556 of file e1000e_nvm.c.

References e1000e_read_nvm(), e1000e_write_nvm(), e_dbg, NVM_CHECKSUM_REG, NVM_SUM, and u16.

Referenced by e1000e_init_nvm_params_80003es2lan(), e1000e_update_nvm_checksum_82571(), and e1000e_update_nvm_checksum_ich8lan().

{
        s32  ret_val;
        u16 checksum = 0;
        u16 i, nvm_data;

        for (i = 0; i < NVM_CHECKSUM_REG; i++) {
                ret_val = e1000e_read_nvm(hw, i, 1, &nvm_data);
                if (ret_val) {
                        e_dbg("NVM Read Error while updating checksum.\n");
                        goto out;
                }
                checksum += nvm_data;
        }
        checksum = (u16) NVM_SUM - checksum;
        ret_val = e1000e_write_nvm(hw, NVM_CHECKSUM_REG, 1, &checksum);
        if (ret_val)
                e_dbg("NVM Write Error while updating checksum.\n");

out:
        return ret_val;
}