e1000_nvm.h File Reference

Go to the source code of this file.

Defines
#define	E1000_STM_OPCODE   0xDB00
Functions
	FILE_LICENCE (GPL2_OR_LATER)
void	e1000_init_nvm_ops_generic (struct e1000_hw *hw)
	e1000_init_nvm_ops_generic - Initialize NVM function pointers : pointer to the HW structure
s32	e1000_null_read_nvm (struct e1000_hw *hw, u16 a, u16 b, u16 *c)
void	e1000_null_nvm_generic (struct e1000_hw *hw)
s32	e1000_null_led_default (struct e1000_hw *hw, u16 *data)
s32	e1000_null_write_nvm (struct e1000_hw *hw, u16 a, u16 b, u16 *c)
s32	e1000_acquire_nvm_generic (struct e1000_hw *hw)
	e1000_acquire_nvm_generic - Generic request for access to EEPROM : pointer to the HW structure
s32	e1000_poll_eerd_eewr_done (struct e1000_hw *hw, int ee_reg)
	e1000_poll_eerd_eewr_done - Poll for EEPROM read/write completion : pointer to the HW structure : EEPROM flag for polling
s32	e1000_read_mac_addr_generic (struct e1000_hw *hw)
	e1000_read_mac_addr_generic - Read device MAC address : pointer to the HW structure
s32	e1000_read_pba_num_generic (struct e1000_hw *hw, u32 *pba_num)
	e1000_read_pba_num_generic - Read device part number : pointer to the HW structure : pointer to device part number
s32	e1000_read_nvm_spi (struct e1000_hw *hw, u16 offset, u16 words, u16 *data)
	e1000_read_nvm_spi - Read EEPROM's using SPI : pointer to the HW structure : offset of word in the EEPROM to read : number of words to read : word read from the EEPROM
s32	e1000_read_nvm_microwire (struct e1000_hw *hw, u16 offset, u16 words, u16 *data)
	e1000_read_nvm_microwire - Reads EEPROM's using microwire : pointer to the HW structure : offset of word in the EEPROM to read : number of words to read : word read from the EEPROM
s32	e1000_read_nvm_eerd (struct e1000_hw *hw, u16 offset, u16 words, u16 *data)
	e1000_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	e1000_valid_led_default_generic (struct e1000_hw *hw, u16 *data)
	e1000_valid_led_default_generic - Verify a valid default LED config : pointer to the HW structure : pointer to the NVM (EEPROM)
s32	e1000_validate_nvm_checksum_generic (struct e1000_hw *hw)
	e1000_validate_nvm_checksum_generic - Validate EEPROM checksum : pointer to the HW structure
s32	e1000_write_nvm_eewr (struct e1000_hw *hw, u16 offset, u16 words, u16 *data)
s32	e1000_write_nvm_microwire (struct e1000_hw *hw, u16 offset, u16 words, u16 *data)
	e1000_write_nvm_microwire - Writes EEPROM using microwire : 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	e1000_write_nvm_spi (struct e1000_hw *hw, u16 offset, u16 words, u16 *data)
	e1000_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	e1000_update_nvm_checksum_generic (struct e1000_hw *hw)
	e1000_update_nvm_checksum_generic - Update EEPROM checksum : pointer to the HW structure
void	e1000_stop_nvm (struct e1000_hw *hw)
	e1000_stop_nvm - Terminate EEPROM command : pointer to the HW structure
void	e1000_release_nvm_generic (struct e1000_hw *hw)
	e1000_release_nvm_generic - Release exclusive access to EEPROM : pointer to the HW structure

---

Define Documentation

#define E1000_STM_OPCODE   0xDB00

Definition at line 61 of file e1000_nvm.h.

Referenced by e1000e_update_nvm_checksum_82571().

---

Function Documentation

FILE_LICENCE

(

GPL2_OR_LATER

)

void e1000_init_nvm_ops_generic

(

struct e1000_hw *

hw

)

e1000_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 41 of file e1000_nvm.c.

References e1000_nvm_operations::acquire, DEBUGFUNC, e1000_null_led_default(), e1000_null_nvm_generic(), e1000_null_ops_generic(), e1000_null_read_nvm(), e1000_null_write_nvm(), e1000_reload_nvm_generic(), e1000_nvm_operations::init_params, e1000_hw::nvm, e1000_nvm_info::ops, e1000_nvm_operations::read, e1000_nvm_operations::release, e1000_nvm_operations::reload, e1000_nvm_operations::update, e1000_nvm_operations::valid_led_default, e1000_nvm_operations::validate, and e1000_nvm_operations::write.

Referenced by e1000_setup_init_funcs().

{
        struct e1000_nvm_info *nvm = &hw->nvm;
        DEBUGFUNC("e1000_init_nvm_ops_generic");

        /* Initialize function pointers */
        nvm->ops.init_params = e1000_null_ops_generic;
        nvm->ops.acquire = e1000_null_ops_generic;
        nvm->ops.read = e1000_null_read_nvm;
        nvm->ops.release = e1000_null_nvm_generic;
        nvm->ops.reload = e1000_reload_nvm_generic;
        nvm->ops.update = e1000_null_ops_generic;
        nvm->ops.valid_led_default = e1000_null_led_default;
        nvm->ops.validate = e1000_null_ops_generic;
        nvm->ops.write = e1000_null_write_nvm;
}

s32 e1000_null_read_nvm	(	struct e1000_hw *	hw,
		u16	a,
		u16	b,
		u16 *	c
	)

void e1000_null_nvm_generic

(

struct e1000_hw *

hw

)

s32 e1000_null_led_default	(	struct e1000_hw *	hw,
		u16 *	data
	)

s32 e1000_null_write_nvm	(	struct e1000_hw *	hw,
		u16	a,
		u16	b,
		u16 *	c
	)

s32 e1000_acquire_nvm_generic

(

struct e1000_hw *

hw

)

e1000_acquire_nvm_generic - 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 258 of file e1000_nvm.c.

References DEBUGFUNC, DEBUGOUT, E1000_EECD, E1000_EECD_GNT, E1000_EECD_REQ, E1000_ERR_NVM, E1000_NVM_GRANT_ATTEMPTS, E1000_READ_REG, E1000_SUCCESS, E1000_WRITE_REG, timeout(), u32, and usec_delay.

Referenced by e1000_init_nvm_params_82540(), and e1000_init_nvm_params_82541().

{
        u32 eecd = E1000_READ_REG(hw, E1000_EECD);
        s32 timeout = E1000_NVM_GRANT_ATTEMPTS;
        s32 ret_val = E1000_SUCCESS;

        DEBUGFUNC("e1000_acquire_nvm_generic");

        E1000_WRITE_REG(hw, E1000_EECD, eecd | E1000_EECD_REQ);
        eecd = E1000_READ_REG(hw, E1000_EECD);

        while (timeout) {
                if (eecd & E1000_EECD_GNT)
                        break;
                usec_delay(5);
                eecd = E1000_READ_REG(hw, E1000_EECD);
                timeout--;
        }

        if (!timeout) {
                eecd &= ~E1000_EECD_REQ;
                E1000_WRITE_REG(hw, E1000_EECD, eecd);
                DEBUGOUT("Could not acquire NVM grant\n");
                ret_val = -E1000_ERR_NVM;
        }

        return ret_val;
}

s32 e1000_poll_eerd_eewr_done	(	struct e1000_hw *	hw,
		int	ee_reg
	)

e1000_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 225 of file e1000_nvm.c.

References DEBUGFUNC, E1000_EERD, E1000_EEWR, E1000_ERR_NVM, E1000_NVM_POLL_READ, E1000_NVM_RW_REG_DONE, E1000_READ_REG, E1000_SUCCESS, u32, and usec_delay.

Referenced by e1000_read_nvm_eerd().

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

        DEBUGFUNC("e1000_poll_eerd_eewr_done");

        for (i = 0; i < attempts; i++) {
                if (ee_reg == E1000_NVM_POLL_READ)
                        reg = E1000_READ_REG(hw, E1000_EERD);
                else
                        reg = E1000_READ_REG(hw, E1000_EEWR);

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

                usec_delay(5);
        }

        return ret_val;
}

s32 e1000_read_mac_addr_generic

(

struct e1000_hw *

hw

)

e1000_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 817 of file e1000_nvm.c.

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

Referenced by e1000_init_mac_ops_generic(), and e1000_read_mac_addr().

{
        u32 rar_high;
        u32 rar_low;
        u16 i;

        rar_high = E1000_READ_REG(hw, E1000_RAH(0));
        rar_low = E1000_READ_REG(hw, E1000_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 e1000_read_pba_num_generic	(	struct e1000_hw *	hw,
		u32 *	pba_num
	)

e1000_read_pba_num_generic - 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 784 of file e1000_nvm.c.

References DEBUGFUNC, DEBUGOUT, e1000_hw::nvm, NVM_PBA_OFFSET_0, NVM_PBA_OFFSET_1, e1000_nvm_info::ops, e1000_nvm_operations::read, u16, and u32.

Referenced by e1000_read_pba_num().

{
        s32  ret_val;
        u16 nvm_data;

        DEBUGFUNC("e1000_read_pba_num_generic");

        ret_val = hw->nvm.ops.read(hw, NVM_PBA_OFFSET_0, 1, &nvm_data);
        if (ret_val) {
                DEBUGOUT("NVM Read Error\n");
                goto out;
        }
        *pba_num = (u32)(nvm_data << 16);

        ret_val = hw->nvm.ops.read(hw, NVM_PBA_OFFSET_1, 1, &nvm_data);
        if (ret_val) {
                DEBUGOUT("NVM Read Error\n");
                goto out;
        }
        *pba_num |= nvm_data;

out:
        return ret_val;
}

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

e1000_read_nvm_spi - Read EEPROM's using SPI : 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.

Definition at line 443 of file e1000_nvm.c.

References e1000_nvm_operations::acquire, e1000_nvm_info::address_bits, DEBUGFUNC, DEBUGOUT, E1000_ERR_NVM, e1000_ready_nvm_eeprom(), e1000_shift_in_eec_bits(), e1000_shift_out_eec_bits(), e1000_standby_nvm(), e1000_hw::nvm, NVM_A8_OPCODE_SPI, NVM_READ_OPCODE_SPI, e1000_nvm_info::opcode_bits, e1000_nvm_info::ops, e1000_nvm_operations::release, u16, u32, u8, and e1000_nvm_info::word_size.

Referenced by e1000_init_nvm_params_82541().

{
        struct e1000_nvm_info *nvm = &hw->nvm;
        u32 i = 0;
        s32 ret_val;
        u16 word_in;
        u8 read_opcode = NVM_READ_OPCODE_SPI;

        DEBUGFUNC("e1000_read_nvm_spi");

        /*
         * 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)) {
                DEBUGOUT("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;

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

        e1000_standby_nvm(hw);

        if ((nvm->address_bits == 8) && (offset >= 128))
                read_opcode |= NVM_A8_OPCODE_SPI;

        /* Send the READ command (opcode + addr) */
        e1000_shift_out_eec_bits(hw, read_opcode, nvm->opcode_bits);
        e1000_shift_out_eec_bits(hw, (u16)(offset*2), nvm->address_bits);

        /*
         * Read the data.  SPI NVMs increment the address with each byte
         * read and will roll over if reading beyond the end.  This allows
         * us to read the whole NVM from any offset
         */
        for (i = 0; i < words; i++) {
                word_in = e1000_shift_in_eec_bits(hw, 16);
                data[i] = (word_in >> 8) | (word_in << 8);
        }

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

out:
        return ret_val;
}

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

e1000_read_nvm_microwire - Reads EEPROM's using microwire : 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.

Definition at line 507 of file e1000_nvm.c.

References e1000_nvm_operations::acquire, e1000_nvm_info::address_bits, DEBUGFUNC, DEBUGOUT, E1000_ERR_NVM, e1000_ready_nvm_eeprom(), e1000_shift_in_eec_bits(), e1000_shift_out_eec_bits(), e1000_standby_nvm(), e1000_hw::nvm, NVM_READ_OPCODE_MICROWIRE, e1000_nvm_info::opcode_bits, e1000_nvm_info::ops, e1000_nvm_operations::release, u16, u32, u8, and e1000_nvm_info::word_size.

Referenced by e1000_init_nvm_params_82540(), e1000_init_nvm_params_82541(), e1000_init_nvm_params_82542(), and e1000_init_nvm_params_82543().

{
        struct e1000_nvm_info *nvm = &hw->nvm;
        u32 i = 0;
        s32 ret_val;
        u8 read_opcode = NVM_READ_OPCODE_MICROWIRE;

        DEBUGFUNC("e1000_read_nvm_microwire");

        /*
         * 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)) {
                DEBUGOUT("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;

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

        for (i = 0; i < words; i++) {
                /* Send the READ command (opcode + addr) */
                e1000_shift_out_eec_bits(hw, read_opcode, nvm->opcode_bits);
                e1000_shift_out_eec_bits(hw, (u16)(offset + i),
                                        nvm->address_bits);

                /*
                 * Read the data.  For microwire, each word requires the
                 * overhead of setup and tear-down.
                 */
                data[i] = e1000_shift_in_eec_bits(hw, 16);
                e1000_standby_nvm(hw);
        }

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

out:
        return ret_val;
}

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

e1000_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 566 of file e1000_nvm.c.

References DEBUGFUNC, DEBUGOUT, E1000_EERD, E1000_ERR_NVM, E1000_NVM_POLL_READ, E1000_NVM_RW_ADDR_SHIFT, E1000_NVM_RW_REG_DATA, E1000_NVM_RW_REG_START, e1000_poll_eerd_eewr_done(), E1000_READ_REG, E1000_SUCCESS, E1000_WRITE_REG, e1000_hw::nvm, u32, and e1000_nvm_info::word_size.

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

        DEBUGFUNC("e1000_read_nvm_eerd");

        /*
         * 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)) {
                DEBUGOUT("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;

                E1000_WRITE_REG(hw, E1000_EERD, eerd);
                ret_val = e1000_poll_eerd_eewr_done(hw, E1000_NVM_POLL_READ);
                if (ret_val)
                        break;

                data[i] = (E1000_READ_REG(hw, E1000_EERD) >>
                           E1000_NVM_RW_REG_DATA);
        }

out:
        return ret_val;
}

s32 e1000_valid_led_default_generic	(	struct e1000_hw *	hw,
		u16 *	data
	)

e1000_valid_led_default_generic - Verify a valid default LED config : pointer to the HW structure : pointer to the NVM (EEPROM)

Read the EEPROM for the current default LED configuration. If the LED configuration is not valid, set to a valid LED configuration.

Definition at line 1775 of file e1000_mac.c.

References DEBUGFUNC, DEBUGOUT, ID_LED_DEFAULT, ID_LED_RESERVED_0000, ID_LED_RESERVED_FFFF, e1000_hw::nvm, NVM_ID_LED_SETTINGS, e1000_nvm_info::ops, and e1000_nvm_operations::read.

Referenced by e1000_init_nvm_params_82540(), e1000_init_nvm_params_82541(), and e1000_init_nvm_params_82543().

{
        s32 ret_val;

        DEBUGFUNC("e1000_valid_led_default_generic");

        ret_val = hw->nvm.ops.read(hw, NVM_ID_LED_SETTINGS, 1, data);
        if (ret_val) {
                DEBUGOUT("NVM Read Error\n");
                goto out;
        }

        if (*data == ID_LED_RESERVED_0000 || *data == ID_LED_RESERVED_FFFF)
                *data = ID_LED_DEFAULT;

out:
        return ret_val;
}

s32 e1000_validate_nvm_checksum_generic

(

struct e1000_hw *

hw

)

e1000_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 845 of file e1000_nvm.c.

References DEBUGFUNC, DEBUGOUT, E1000_ERR_NVM, E1000_SUCCESS, e1000_hw::nvm, NVM_CHECKSUM_REG, NVM_SUM, e1000_nvm_info::ops, e1000_nvm_operations::read, and u16.

Referenced by e1000_init_nvm_params_82540(), e1000_init_nvm_params_82541(), e1000_init_nvm_params_82542(), and e1000_init_nvm_params_82543().

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

        DEBUGFUNC("e1000_validate_nvm_checksum_generic");

        for (i = 0; i < (NVM_CHECKSUM_REG + 1); i++) {
                ret_val = hw->nvm.ops.read(hw, i, 1, &nvm_data);
                if (ret_val) {
                        DEBUGOUT("NVM Read Error\n");
                        goto out;
                }
                checksum += nvm_data;
        }

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

out:
        return ret_val;
}

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

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

e1000_write_nvm_microwire - Writes EEPROM using microwire : 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 microwire interface.

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

Definition at line 698 of file e1000_nvm.c.

References e1000_nvm_operations::acquire, e1000_nvm_info::address_bits, DEBUGFUNC, DEBUGOUT, E1000_EECD, E1000_EECD_DO, E1000_ERR_NVM, E1000_READ_REG, e1000_ready_nvm_eeprom(), e1000_shift_out_eec_bits(), e1000_standby_nvm(), e1000_hw::nvm, NVM_EWDS_OPCODE_MICROWIRE, NVM_EWEN_OPCODE_MICROWIRE, NVM_WRITE_OPCODE_MICROWIRE, e1000_nvm_info::opcode_bits, e1000_nvm_info::ops, e1000_nvm_operations::release, u16, u32, usec_delay, and e1000_nvm_info::word_size.

Referenced by e1000_init_nvm_params_82540(), e1000_init_nvm_params_82541(), e1000_init_nvm_params_82542(), and e1000_init_nvm_params_82543().

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

        DEBUGFUNC("e1000_write_nvm_microwire");

        /*
         * 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)) {
                DEBUGOUT("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;

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

        e1000_shift_out_eec_bits(hw, NVM_EWEN_OPCODE_MICROWIRE,
                                 (u16)(nvm->opcode_bits + 2));

        e1000_shift_out_eec_bits(hw, 0, (u16)(nvm->address_bits - 2));

        e1000_standby_nvm(hw);

        while (words_written < words) {
                e1000_shift_out_eec_bits(hw, NVM_WRITE_OPCODE_MICROWIRE,
                                         nvm->opcode_bits);

                e1000_shift_out_eec_bits(hw, (u16)(offset + words_written),
                                         nvm->address_bits);

                e1000_shift_out_eec_bits(hw, data[words_written], 16);

                e1000_standby_nvm(hw);

                for (widx = 0; widx < 200; widx++) {
                        eecd = E1000_READ_REG(hw, E1000_EECD);
                        if (eecd & E1000_EECD_DO)
                                break;
                        usec_delay(50);
                }

                if (widx == 200) {
                        DEBUGOUT("NVM Write did not complete\n");
                        ret_val = -E1000_ERR_NVM;
                        goto release;
                }

                e1000_standby_nvm(hw);

                words_written++;
        }

        e1000_shift_out_eec_bits(hw, NVM_EWDS_OPCODE_MICROWIRE,
                                 (u16)(nvm->opcode_bits + 2));

        e1000_shift_out_eec_bits(hw, 0, (u16)(nvm->address_bits - 2));

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

out:
        return ret_val;
}

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

e1000_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 e1000_update_nvm_checksum is not called after this function , the EEPROM will most likely contain an invalid checksum.

Definition at line 614 of file e1000_nvm.c.

References e1000_nvm_operations::acquire, e1000_nvm_info::address_bits, DEBUGFUNC, DEBUGOUT, E1000_ERR_NVM, e1000_ready_nvm_eeprom(), e1000_shift_out_eec_bits(), e1000_standby_nvm(), msec_delay, 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 e1000_init_nvm_params_82541().

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

        DEBUGFUNC("e1000_write_nvm_spi");

        /*
         * 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)) {
                DEBUGOUT("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 = e1000_ready_nvm_eeprom(hw);
                if (ret_val)
                        goto release;

                e1000_standby_nvm(hw);

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

                e1000_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) */
                e1000_shift_out_eec_bits(hw, write_opcode, nvm->opcode_bits);
                e1000_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);
                        e1000_shift_out_eec_bits(hw, word_out, 16);
                        widx++;

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

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

out:
        return ret_val;
}

s32 e1000_update_nvm_checksum_generic

(

struct e1000_hw *

hw

)

e1000_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 880 of file e1000_nvm.c.

References DEBUGFUNC, DEBUGOUT, e1000_hw::nvm, NVM_CHECKSUM_REG, NVM_SUM, e1000_nvm_info::ops, e1000_nvm_operations::read, u16, and e1000_nvm_operations::write.

Referenced by e1000_init_nvm_params_82540(), e1000_init_nvm_params_82541(), e1000_init_nvm_params_82542(), and e1000_init_nvm_params_82543().

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

        DEBUGFUNC("e1000_update_nvm_checksum");

        for (i = 0; i < NVM_CHECKSUM_REG; i++) {
                ret_val = hw->nvm.ops.read(hw, i, 1, &nvm_data);
                if (ret_val) {
                        DEBUGOUT("NVM Read Error while updating checksum.\n");
                        goto out;
                }
                checksum += nvm_data;
        }
        checksum = (u16) NVM_SUM - checksum;
        ret_val = hw->nvm.ops.write(hw, NVM_CHECKSUM_REG, 1, &checksum);
        if (ret_val)
                DEBUGOUT("NVM Write Error while updating checksum.\n");

out:
        return ret_val;
}

void e1000_stop_nvm

(

struct e1000_hw *

hw

)

e1000_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 335 of file e1000_nvm.c.

References DEBUGFUNC, E1000_EECD, E1000_EECD_CS, E1000_EECD_DI, e1000_lower_eec_clk(), e1000_nvm_eeprom_microwire, e1000_nvm_eeprom_spi, e1000_raise_eec_clk(), E1000_READ_REG, E1000_WRITE_REG, e1000_hw::nvm, e1000_nvm_info::type, and u32.

Referenced by e1000_init_nvm_params_82542(), and e1000_release_nvm_generic().

{
        u32 eecd;

        DEBUGFUNC("e1000_stop_nvm");

        eecd = E1000_READ_REG(hw, E1000_EECD);
        if (hw->nvm.type == e1000_nvm_eeprom_spi) {
                /* Pull CS high */
                eecd |= E1000_EECD_CS;
                e1000_lower_eec_clk(hw, &eecd);
        } else if (hw->nvm.type == e1000_nvm_eeprom_microwire) {
                /* CS on Microwire is active-high */
                eecd &= ~(E1000_EECD_CS | E1000_EECD_DI);
                E1000_WRITE_REG(hw, E1000_EECD, eecd);
                e1000_raise_eec_clk(hw, &eecd);
                e1000_lower_eec_clk(hw, &eecd);
        }
}

void e1000_release_nvm_generic

(

struct e1000_hw *

hw

)

e1000_release_nvm_generic - 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 361 of file e1000_nvm.c.

References DEBUGFUNC, E1000_EECD, E1000_EECD_REQ, E1000_READ_REG, e1000_stop_nvm(), E1000_WRITE_REG, and u32.

Referenced by e1000_init_nvm_params_82540(), and e1000_init_nvm_params_82541().

{
        u32 eecd;

        DEBUGFUNC("e1000_release_nvm_generic");

        e1000_stop_nvm(hw);

        eecd = E1000_READ_REG(hw, E1000_EECD);
        eecd &= ~E1000_EECD_REQ;
        E1000_WRITE_REG(hw, E1000_EECD, eecd);
}