|
|
|
|
@ -0,0 +1,243 @@
|
|
|
|
|
/*
|
|
|
|
|
* This file is part of the coreboot project.
|
|
|
|
|
*
|
|
|
|
|
* Copyright (C) 2014 Siemens AG.
|
|
|
|
|
*
|
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
|
* the Free Software Foundation; version 2 of the License.
|
|
|
|
|
*
|
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
|
*
|
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include "i210.h"
|
|
|
|
|
#include <device/device.h>
|
|
|
|
|
#include <console/console.h>
|
|
|
|
|
#include <device/pci.h>
|
|
|
|
|
#include <device/pci_ids.h>
|
|
|
|
|
#include <device/pci_ops.h>
|
|
|
|
|
#include <string.h>
|
|
|
|
|
#include <types.h>
|
|
|
|
|
#include <delay.h>
|
|
|
|
|
|
|
|
|
|
/* We need one function we can call to get a MAC address to use */
|
|
|
|
|
/* This function can be coded somewhere else but must exist. */
|
|
|
|
|
extern enum cb_err mainboard_get_mac_address(u16 bus, u8 devfn, u8 mac[6]);
|
|
|
|
|
|
|
|
|
|
/* This is a private function to wait for a bit mask in a given register */
|
|
|
|
|
/* To avoid endless loops, a time-out is implemented here. */
|
|
|
|
|
static int wait_done(u32* reg, u32 mask)
|
|
|
|
|
{
|
|
|
|
|
u32 timeout = I210_POLL_TIMEOUT_US;
|
|
|
|
|
|
|
|
|
|
while (!(*reg & mask)) {
|
|
|
|
|
udelay(1);
|
|
|
|
|
if (!--timeout)
|
|
|
|
|
return I210_NOT_READY;
|
|
|
|
|
}
|
|
|
|
|
return I210_SUCCESS;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/** \brief This function can read the configuration space of the MACPHY
|
|
|
|
|
* For this purpose, the EEPROM interface is used. No direct access
|
|
|
|
|
* to the flash memory will be done.
|
|
|
|
|
* @param *dev Pointer to the PCI device of this MACPHY
|
|
|
|
|
* @param address Address inside the flash where reading will start
|
|
|
|
|
* @param count Number of words (16 bit values) to read
|
|
|
|
|
* @param *buffer Pointer to the buffer where to store read data
|
|
|
|
|
* @return void I210_NO_ERROR or an error code
|
|
|
|
|
*/
|
|
|
|
|
static u32 read_flash(struct device *dev, u32 address, u32 count, u16 *buffer)
|
|
|
|
|
{
|
|
|
|
|
u32 bar;
|
|
|
|
|
u32 *eeprd;
|
|
|
|
|
u32 i;
|
|
|
|
|
|
|
|
|
|
/* Get the BAR to memory mapped space*/
|
|
|
|
|
bar = pci_read_config32(dev, PCI_BASE_ADDRESS_0);
|
|
|
|
|
if ((!bar) || ((address + count) > 0x40))
|
|
|
|
|
return I210_INVALID_PARAM;
|
|
|
|
|
eeprd = (u32*)(bar + I210_REG_EEREAD);
|
|
|
|
|
/* Prior to start ensure flash interface is ready by checking DONE-bit */
|
|
|
|
|
if (wait_done(eeprd, I210_DONE))
|
|
|
|
|
return I210_NOT_READY;
|
|
|
|
|
|
|
|
|
|
/*OK, interface is ready, we can use it now */
|
|
|
|
|
for (i = 0; i < count; i++) {
|
|
|
|
|
/* To start a read cycle write desired address in bits 12..2 */
|
|
|
|
|
*eeprd = ((address + i) << 2) & 0x1FFC;
|
|
|
|
|
/* Wait until read is done */
|
|
|
|
|
if (wait_done(eeprd, I210_DONE))
|
|
|
|
|
return I210_READ_ERROR;
|
|
|
|
|
/* Here, we can read back desired word in bits 31..16 */
|
|
|
|
|
buffer[i] = (*eeprd & 0xffff0000) >> 16;
|
|
|
|
|
}
|
|
|
|
|
return I210_SUCCESS;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/** \brief This function computes the checksum for the configuration space.
|
|
|
|
|
* The address range for the checksum is 0x00..0x3e.
|
|
|
|
|
* @param *dev Pointer to the PCI device of this MACPHY
|
|
|
|
|
* @param *checksum Pointer to the buffer where to store the checksum
|
|
|
|
|
* @return void I210_NO_ERROR or an error code
|
|
|
|
|
*/
|
|
|
|
|
static u32 compute_checksum(struct device *dev, u16 *checksum)
|
|
|
|
|
{
|
|
|
|
|
u16 eep_data[0x40];
|
|
|
|
|
u32 i;
|
|
|
|
|
|
|
|
|
|
/* First read back data to compute the checksum for */
|
|
|
|
|
if (read_flash(dev, 0, 0x3f, eep_data))
|
|
|
|
|
return I210_READ_ERROR;
|
|
|
|
|
/* The checksum is computed in that way that after summarize all the */
|
|
|
|
|
/* data from word address 0 to 0x3f the result is 0xBABA. */
|
|
|
|
|
*checksum = 0;
|
|
|
|
|
for (i = 0; i < 0x3f; i++)
|
|
|
|
|
*checksum += eep_data[i];
|
|
|
|
|
*checksum = I210_TARGET_CHECKSUM - *checksum;
|
|
|
|
|
return I210_SUCCESS;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/** \brief This function can write the configuration space of the MACPHY
|
|
|
|
|
* For this purpose, the EEPROM interface is used. No direct access
|
|
|
|
|
* to the flash memory will be done. This function will update
|
|
|
|
|
* the checksum after a value was changed.
|
|
|
|
|
* @param *dev Pointer to the PCI device of this MACPHY
|
|
|
|
|
* @param address Address inside the flash where writing will start
|
|
|
|
|
* @param count Number of words (16 bit values) to write
|
|
|
|
|
* @param *buffer Pointer to the buffer where data to write is stored in
|
|
|
|
|
* @return void I210_NO_ERROR or an error code
|
|
|
|
|
*/
|
|
|
|
|
static u32 write_flash(struct device *dev, u32 address, u32 count, u16 *buffer)
|
|
|
|
|
{
|
|
|
|
|
u32 bar;
|
|
|
|
|
u32 *eepwr;
|
|
|
|
|
u32 *eectrl;
|
|
|
|
|
u16 checksum;
|
|
|
|
|
u32 i;
|
|
|
|
|
|
|
|
|
|
/* Get the BAR to memory mapped space */
|
|
|
|
|
bar = pci_read_config32(dev, 0x10);
|
|
|
|
|
if ((!bar) || ((address + count) > 0x40))
|
|
|
|
|
return I210_INVALID_PARAM;
|
|
|
|
|
eepwr = (u32*)(bar + I210_REG_EEWRITE);
|
|
|
|
|
eectrl = (u32*)(bar + I210_REG_EECTRL);
|
|
|
|
|
/* Prior to start ensure flash interface is ready by checking DONE-bit */
|
|
|
|
|
if (wait_done(eepwr, I210_DONE))
|
|
|
|
|
return I210_NOT_READY;
|
|
|
|
|
|
|
|
|
|
/* OK, interface is ready, we can use it now */
|
|
|
|
|
for (i = 0; i < count; i++) {
|
|
|
|
|
/* To start a write cycle write desired address in bits 12..2 */
|
|
|
|
|
/* and data to write in bits 31..16 into EEWRITE-register */
|
|
|
|
|
*eepwr = ((((address + i) << 2) & 0x1FFC) | (buffer[i] << 16));
|
|
|
|
|
/* Wait until write is done */
|
|
|
|
|
if (wait_done(eepwr, I210_DONE))
|
|
|
|
|
return I210_WRITE_ERROR;
|
|
|
|
|
}
|
|
|
|
|
/* Since we have modified data, we need to update the checksum */
|
|
|
|
|
if (compute_checksum(dev, &checksum))
|
|
|
|
|
return I210_CHECKSUM_ERROR;
|
|
|
|
|
*eepwr = (0x3f << 2) | checksum << 16;
|
|
|
|
|
if (wait_done(eepwr, I210_DONE))
|
|
|
|
|
return I210_WRITE_ERROR;
|
|
|
|
|
/* Up to now, desired data was written into shadowed RAM. We now need */
|
|
|
|
|
/* to perform a flash cycle to bring the shadowed RAM into flash memory. */
|
|
|
|
|
/* To start a flash cycle we need to set FLUPD-bit and wait for FLDONE. */
|
|
|
|
|
*eectrl = *eectrl | I210_FLUPD;
|
|
|
|
|
if (wait_done(eectrl, I210_FLUDONE))
|
|
|
|
|
return I210_FLASH_UPDATE_ERROR;
|
|
|
|
|
return I210_SUCCESS;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/** \brief This function can read the MAC address out of the MACPHY
|
|
|
|
|
* @param *dev Pointer to the PCI device of this MACPHY
|
|
|
|
|
* @param *MACAdr Pointer to the buffer where to store read MAC address
|
|
|
|
|
* @return void I210_NO_ERROR or an error code
|
|
|
|
|
*/
|
|
|
|
|
static u32 read_mac_adr(struct device *dev, u8 *mac_adr)
|
|
|
|
|
{
|
|
|
|
|
u16 adr[3];
|
|
|
|
|
if (!dev || !mac_adr)
|
|
|
|
|
return I210_INVALID_PARAM;
|
|
|
|
|
if (read_flash(dev, 0, 3, adr))
|
|
|
|
|
return I210_READ_ERROR;
|
|
|
|
|
/* Copy the address into destination. This is done because of */
|
|
|
|
|
/* possible not matching alignment for destination to u16 boundary. */
|
|
|
|
|
memcpy(mac_adr, (u8*)adr, 6);
|
|
|
|
|
return I210_SUCCESS;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/** \brief This function can write the MAC address to the MACPHY
|
|
|
|
|
* @param *dev Pointer to the PCI device of this MACPHY
|
|
|
|
|
* @param *MACAdr Pointer to the buffer where the desired MAC address is
|
|
|
|
|
* @return void I210_NO_ERROR or an error code
|
|
|
|
|
*/
|
|
|
|
|
static u32 write_mac_adr(struct device *dev, u8 *mac_adr)
|
|
|
|
|
{
|
|
|
|
|
u16 adr[3];
|
|
|
|
|
if (!dev || !mac_adr)
|
|
|
|
|
return I210_INVALID_PARAM;
|
|
|
|
|
/* Copy desired address into a local buffer to avoid alignment issues */
|
|
|
|
|
memcpy((u8*)adr, mac_adr, 6);
|
|
|
|
|
return write_flash(dev, 0, 3, adr);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/** \brief This function is the driver entry point for the init phase
|
|
|
|
|
* of the PCI bus allocator. It will program a MAC address
|
|
|
|
|
* into the MACPHY.
|
|
|
|
|
* @param *dev Pointer to the used PCI device
|
|
|
|
|
* @return void Nothing is given back
|
|
|
|
|
*/
|
|
|
|
|
static void init(struct device *dev)
|
|
|
|
|
{
|
|
|
|
|
u8 cur_adr[6];
|
|
|
|
|
u8 adr_to_set[6];
|
|
|
|
|
enum cb_err status;
|
|
|
|
|
|
|
|
|
|
/*Check first whether there is a valid MAC address available */
|
|
|
|
|
status = mainboard_get_mac_address(dev->bus->subordinate,
|
|
|
|
|
dev->path.pci.devfn, adr_to_set);
|
|
|
|
|
if (status != CB_SUCCESS) {
|
|
|
|
|
printk(BIOS_ERR, "I210: No valid MAC address found\n");
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
/* Before we will write a new address, check the existing one */
|
|
|
|
|
if (read_mac_adr(dev, cur_adr)) {
|
|
|
|
|
printk(BIOS_ERR, "I210: Not able to read MAC address.\n");
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
if (memcmp(cur_adr, adr_to_set, 6)) {
|
|
|
|
|
if (write_mac_adr(dev, adr_to_set))
|
|
|
|
|
printk(BIOS_ERR, "I210: Error setting MAC address\n");
|
|
|
|
|
else
|
|
|
|
|
printk(BIOS_INFO, "I210: MAC address changed.\n");
|
|
|
|
|
} else {
|
|
|
|
|
printk(BIOS_INFO, "I210: MAC address is up to date.\n");
|
|
|
|
|
}
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static struct device_operations i210_ops = {
|
|
|
|
|
.read_resources = pci_dev_read_resources,
|
|
|
|
|
.set_resources = pci_dev_set_resources,
|
|
|
|
|
.enable_resources = pci_dev_enable_resources,
|
|
|
|
|
.init = init,
|
|
|
|
|
.scan_bus = 0,
|
|
|
|
|
.ops_pci = 0,
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static const unsigned short i210_device_ids[] = { 0x1538, 0x1533, 0 };
|
|
|
|
|
|
|
|
|
|
static const struct pci_driver i210_driver __pci_driver = {
|
|
|
|
|
.ops = &i210_ops,
|
|
|
|
|
.vendor = PCI_VENDOR_ID_INTEL,
|
|
|
|
|
.devices = i210_device_ids,
|
|
|
|
|
};
|
Werner Zeh