WIB_Flash.cpp File Reference

#include "wibmod/WIB1/BNL_UDP_Exception.hh"
#include "wibmod/WIB1/WIB.hh"
#include "wibmod/WIB1/WIBException.hh"
#include <algorithm>
#include <assert.h>
#include <fstream>

Include dependency graph for WIB_Flash.cpp:

Go to the source code of this file.

Macros
#define	FLASH_TIMEOUT   400
#define	MIN_LINE_LENGTH   10
#define	MAX_LINE_LENGTH   266

Functions
static void	ParseIHexLine (std::string line, std::vector< uint8_t > &data, uint32_t &upperAddr)
void	LoadIHexFile (std::vector< uint8_t > &data, const char *file)
static std::vector< uint32_t >	firmwareFromIntelHexFile (std::string const &iHexFileName)

Macro Definition Documentation

FLASH_TIMEOUT

#define FLASH_TIMEOUT   400

Definition at line 7 of file WIB_Flash.cpp.

MAX_LINE_LENGTH

#define MAX_LINE_LENGTH   266

Definition at line 10 of file WIB_Flash.cpp.

MIN_LINE_LENGTH

#define MIN_LINE_LENGTH   10

Definition at line 9 of file WIB_Flash.cpp.

Function Documentation

firmwareFromIntelHexFile()

std::vector< uint32_t > firmwareFromIntelHexFile ( std::string const & iHexFileName )

static

Definition at line 97 of file WIB_Flash.cpp.

{
  // Ihex parser loads intel hex into a vector of bytes.
  std::vector<uint8_t> rawData;
  LoadIHexFile(rawData, iHexFileName.c_str());
 
  // We now need to convert it to a uint32_t
  // This has the issue of what to do if we are off by 32bit boundary.
  // For now we'll just die so we don't have to deal with the issue.
  // Make sure this is called before we erase the flash :-p
  if ((rawData.size() & 0x3) != 0x0) {
    BUException::WIB_FLASH_IHEX_ERROR e;
    e.Append("Flash data is not a multiple of 32bit words");
    throw e;
  } else if (0 == rawData.size()) {
    BUException::WIB_FLASH_IHEX_ERROR e;
    e.Append("Flash data is empty");
    throw e;
  }
 
  // Create a std::vector<uint32_t> and fill it with rawData;
  std::vector<uint32_t> ret;
  for (size_t iRawData = 0; iRawData < rawData.size(); iRawData += 4) {
    // Build the 32bit word
    uint32_t tempData = (rawData[iRawData + 0] << 0 | rawData[iRawData + 1] << 8 | rawData[iRawData + 2] << 16 |
                         rawData[iRawData + 3] << 24);
    ret.push_back(tempData);
  }
  return ret;
}

LoadIHexFile()

void LoadIHexFile	(	std::vector< uint8_t > &	data,
		const char *	file )

Definition at line 79 of file WIB_Flash.cpp.

{
  std::string line;
  std::ifstream datafile(file);
  uint32_t upperAddr = 0;
  if (datafile.is_open()) {
    while (getline(datafile, line)) {
      ParseIHexLine(line, data, upperAddr);
    }
  } else {
    BUException::WIB_FLASH_IHEX_ERROR e;
    e.Append("Unable to open file ");
    e.Append(file);
    throw e;
  }
}

ParseIHexLine()

void ParseIHexLine ( std::string line, std::vector< uint8_t > & data, uint32_t & upperAddr )

static

Definition at line 13 of file WIB_Flash.cpp.

{
  if (line.empty()) {
    BUException::WIB_FLASH_IHEX_ERROR e;
    e.Append("line is empty");
    throw e;
  } else if (line[0] != ':') {
    BUException::WIB_FLASH_IHEX_ERROR e;
    e.Append("BAD Line in file - does not start with ':'");
    throw e;
  } else {
    line.erase(0, 1);
  }
  if (line.size() < MIN_LINE_LENGTH) {
    BUException::WIB_FLASH_IHEX_ERROR e;
    e.Append("BAD Line in file - incomplete intel hex format\n");
    throw e;
  } else if (line.size() > MAX_LINE_LENGTH) {
    BUException::WIB_FLASH_IHEX_ERROR e;
    e.Append("BAD Line in file - intel hex format not supported, contains too many characters\n");
    throw e;
  } else if (line.size() & 1) {
    BUException::WIB_FLASH_IHEX_ERROR e;
    e.Append("BAD Line in file - uneven number of characters\n");
    throw e;
  } else {
    char const* entry = line.c_str();
    uint32_t line_sum = 0, byte_count = 0, address = 0, record_type = 0;
 
    uint32_t byte = 0;
    for (uint32_t iSum = 0; iSum < line.size(); iSum += 2) {
      sscanf(entry + iSum, "%2x", &byte);
      line_sum += byte;
    }
    // the content of the line is cancelled out through addition to its
    // two's complement which is the checksum if all data is intact
 
    if (0xFF & line_sum) {
      line_sum = 0xFF & line_sum;
      BUException::WIB_FLASH_IHEX_ERROR e;
      e.Append("BAD Line in file - content inconsistent with checksum.\n");
      throw e;
    } else {
      line_sum = 0;
    }
 
    sscanf(entry, "%2x %4x %2x ", &byte_count, &address, &record_type);
    if (4 == record_type) {
      upperAddr = 0;
      sscanf(entry + 8, "%4x", &upperAddr);
      upperAddr = upperAddr << 16;
    } else if (0 == record_type) {
      address = upperAddr + address;
      if (data.size() < (address + byte_count)) {
        data.resize(address + byte_count, 0xFF);
      }
      for (uint32_t iAddr = 0; iAddr < byte_count; iAddr++) {
        uint32_t tempData = 0;
        sscanf(entry + (iAddr * 2) + 8, "%02x", &tempData);
        data[address + iAddr] = (uint8_t)tempData;
      }
    }
  }
}