WIB_Flash.cpp File Reference

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

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()

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

static

Definition at line 93 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 77 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()

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

static

Definition at line 12 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;
      }  
 
    }  
  }  
}