void e300_eeprom_manager::write_db_eeprom(const dboard_eeprom_t& eeprom)
{
boost::mutex::scoped_lock(_mutex);
_db_eeprom = eeprom;
std::vector<boost::uint8_t> bytes;
bytes.resize(sizeof(db_eeprom_map_t));
db_eeprom_map_t *map_ptr = reinterpret_cast<db_eeprom_map_t*>(&bytes[0]);
memset(map_ptr, 0xff, sizeof(db_eeprom_map_t));
// get the old contents
for(size_t i = 0; i < sizeof(db_eeprom_map_t); i++)
bytes[i] = _i2c->get_i2c_reg16(DB_ADDR, i);
db_eeprom_map_t &map = *map_ptr;
if (_db_eeprom.id != dboard_id_t::none()) {
map.hw_product = uhd::htonx<boost::uint16_t>(
_db_eeprom.id.to_uint16());
}
if (not _db_eeprom.revision.empty()) {
map.hw_revision = uhd::htonx<boost::uint16_t>(
boost::lexical_cast<boost::uint16_t>(_db_eeprom.revision));
}
if (not _db_eeprom.serial.empty()) {
_string_to_bytes(_db_eeprom.serial, DB_SERIAL_LEN, map.serial);
}
for(size_t i = 0; i < sizeof(mb_eeprom_map_t); i++)
_i2c->set_i2c_reg16(DB_ADDR, i, bytes[i]);
}
void e300_eeprom_manager::write_mb_eeprom(const mboard_eeprom_t& eeprom)
{
boost::mutex::scoped_lock(_mutex);
_mb_eeprom = eeprom;
std::vector<boost::uint8_t> bytes;
bytes.resize(sizeof(mb_eeprom_map_t));
mb_eeprom_map_t *map_ptr = reinterpret_cast<mb_eeprom_map_t*>(&bytes[0]);
memset(map_ptr, 0xff, sizeof(mb_eeprom_map_t));
// get the old contents
for(size_t i = 0; i < sizeof(mb_eeprom_map_t); i++)
bytes[i] = _i2c->get_i2c_reg8(MB_ADDR, i);
mb_eeprom_map_t &map = *map_ptr;
// set the data version, that can be used to distinguish eeprom layouts
map.data_version_major = E310_MB_MAP_MAJOR;
map.data_version_minor = E310_MB_MAP_MINOR;
if (_mb_eeprom.has_key("product")) {
map.hw_product = uhd::htonx<boost::uint16_t>(
boost::lexical_cast<boost::uint16_t>(_mb_eeprom["product"]));
}
if (_mb_eeprom.has_key("revision")) {
map.hw_revision = uhd::htonx<boost::uint16_t>(
boost::lexical_cast<boost::uint16_t>(_mb_eeprom["revision"]));
}
if (_mb_eeprom.has_key("serial")) {
_string_to_bytes(_mb_eeprom["serial"], MB_SERIAL_LEN, map.serial);
}
if (_mb_eeprom.has_key("mac-addr")) {
byte_vector_t mac_addr = mac_addr_t::from_string(_mb_eeprom["mac-addr"]).to_bytes();
std::copy(mac_addr.begin(), mac_addr.end(), map.mac_addr);
}
//store the name
if (_mb_eeprom.has_key("name")) {
_string_to_bytes(_mb_eeprom["name"], MB_NAME_LEN, map.user_name);
}
for(size_t i = 0; i < sizeof(mb_eeprom_map_t); i++)
_i2c->set_i2c_reg8(MB_ADDR, i, bytes[i]);
}
void n230_eeprom_manager::write_mb_eeprom(const mboard_eeprom_t& eeprom)
{
boost::mutex::scoped_lock lock(_mutex);
_mb_eeprom = eeprom;
n230_eeprom_map_t* map_ptr = reinterpret_cast<n230_eeprom_map_t*>(_request.data);
memset(map_ptr, 0xff, sizeof(n230_eeprom_map_t)); //Initialize to erased state
//Read EEPROM from device
_transact(N230_FLASH_COMM_CMD_READ_NV_DATA);
memcpy(map_ptr, _response.data, sizeof(n230_eeprom_map_t));
n230_eeprom_map_t& map = *map_ptr;
// Automatic version upgrade handling
uint16_t old_ver_major = uhd::htonx<uint16_t>(map.data_version_major);
uint16_t old_ver_minor = uhd::htonx<uint16_t>(map.data_version_minor);
//The revision_compat field does not exist for version 1.0 so force write it
//EEPROM version 1.0 will only exist on HW revision 1 so it is safe to set
//revision_compat = revision for the upgrade
bool force_write_version_compat = (old_ver_major == 1 and old_ver_minor == 0);
map.data_version_major = uhd::htonx<uint16_t>(N230_EEPROM_VER_MAJOR);
map.data_version_minor = uhd::htonx<uint16_t>(N230_EEPROM_VER_MINOR);
if (_mb_eeprom.has_key("product")) {
map.hw_product = uhd::htonx<uint16_t>(
boost::lexical_cast<uint16_t>(_mb_eeprom["product"]));
}
if (_mb_eeprom.has_key("revision")) {
map.hw_revision = uhd::htonx<uint16_t>(
boost::lexical_cast<uint16_t>(_mb_eeprom["revision"]));
}
if (_mb_eeprom.has_key("revision_compat")) {
map.hw_revision_compat = uhd::htonx<uint16_t>(
boost::lexical_cast<uint16_t>(_mb_eeprom["revision_compat"]));
} else if (force_write_version_compat) {
map.hw_revision_compat = map.hw_revision;
}
if (_mb_eeprom.has_key("serial")) {
_string_to_bytes(_mb_eeprom["serial"], N230_EEPROM_SERIAL_LEN, map.serial);
}
//Push ethernet info
if (_mb_eeprom.has_key("gateway")){
map.gateway = uhd::htonx<uint32_t>(
boost::asio::ip::address_v4::from_string(_mb_eeprom["gateway"]).to_ulong());
}
for (size_t i = 0; i < N230_MAX_NUM_ETH_PORTS; i++) {
const std::string n(1, i+'0');
if (_mb_eeprom.has_key("ip-addr"+n)){
map.eth_info[i].ip_addr = uhd::htonx<uint32_t>(
boost::asio::ip::address_v4::from_string(_mb_eeprom["ip-addr"+n]).to_ulong());
}
if (_mb_eeprom.has_key("subnet"+n)){
map.eth_info[i].subnet = uhd::htonx<uint32_t>(
boost::asio::ip::address_v4::from_string(_mb_eeprom["subnet"+n]).to_ulong());
}
if (_mb_eeprom.has_key("mac-addr"+n)) {
byte_vector_t mac_addr = mac_addr_t::from_string(_mb_eeprom["mac-addr"+n]).to_bytes();
std::copy(mac_addr.begin(), mac_addr.end(), map.eth_info[i].mac_addr);
}
}
//store the name
if (_mb_eeprom.has_key("name")) {
_string_to_bytes(_mb_eeprom["name"], N230_EEPROM_NAME_LEN, map.user_name);
}
//Write EEPROM to device
_transact(N230_FLASH_COMM_CMD_WRITE_NV_DATA);
}
