SctApiBlock.cxx

#include <iostream>

#include <boost/lexical_cast.hpp>

#include "Sct/Env.h"

#include "SctApi.h"
#include "SctApiDebug.h"
#include "crate.h"
#include "utility.h"

#include "primListWrapper.h"
#include "PrimBuilder.h"

#include "VmeDecode.h"

#include "SctApiCounters.h"

// For exceptions
#include "RodCrate/RodModule.h"
#include "SctApiException.h"

using namespace std;
using namespace SctPixelRod;
using namespace boost;
using namespace SctApi::Utility;

namespace SctApi {
#warning "Should some of these return smart pointers?"

/*
  Dump contents of a block of DSP memory to cout.
  Use dspNumber -1 to refer to the master DSP.
*/
int SctApi::dspBlockDump(unsigned int rod,
                         long dspStart, long numWords, long dspNumber, bool usePrim) {
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "DspBlockDump (" << ucid() << " " << rod << ") "
        << dspStart << " " << numWords << " " << dspNumber << endl;
  }

  // read data
  unsigned long length;
  unsigned long *buffer = dspBlockRead(rod, dspStart, numWords, dspNumber, length, usePrim);

  if(!buffer) {
    // Something didn't work
    return 1;
  }

  printMemoryBlock(cout, buffer, numWords, 8, 0);

  char *name = tempnam("./", "textB");
  if(checkDebugOption(DEBUG_DIAG))
    cout << "Write output to " << name << endl;
  ofstream output(name);
  free(name);

  output.write((char *)buffer, numWords * 4);
 
  delete [] buffer;

  return 0;
}

/*
  Dump contents of a block of DSP memory to a file.
  Use dspNumber -1 to refer to the master DSP.
*/
int SctApi::dspBlockDumpFile(unsigned int rod,
                             long dspStart, long numWords, long dspNumber, string filename, bool usePrim){
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "DspBlockDumpFile (" << ucid() << rod << ") "
        << hex << "0x" << dspStart << hex << " " << numWords << " " << dspNumber << " to " << filename << endl;
  }

  unsigned long length;
  unsigned long * buffer = dspBlockRead(rod, dspStart, numWords, dspNumber, length, usePrim);

  if(buffer) {
    if(checkDebugOption(DEBUG_DIAG2)) 
      cout << "Writing output to " << filename << endl;
    ofstream output(filename.c_str());

    output.write((char *)buffer, numWords * 4);

    // delete the buffer
    delete [] buffer;
  } else {
    cout << "Block read failed!\n";
    return 1;
  }

  return 0;
}

/*
  Read contents of a block of DSP memory 

  Use dspNumber -1 to refer to the master DSP.
*/
unsigned long *SctApi::dspBlockRead(unsigned int rod,
                                    long dspStart, long numWords, long dspNumber, unsigned long &length, bool usePrim){
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "DspBlockRead (" << ucid() << " " << rod << ") "
        << hex << "0x" << dspStart << dec << " " << numWords << " " << dspNumber << endl << flush;
  }
  Crate* myCrate = getCrate();

  if(!myCrate) {
    cout << "Request for non-existent crate " << ucid() << endl;
    return 0;
  }

  if(dspNumber < -1 || dspNumber > 3) {
    cout << "dspBlockRead slave out of range " << dspNumber << endl;
    throw SctApiException("DspBlockRead slave out of range");
  }

  // create buffer
  unsigned long * buffer = new unsigned long[numWords];

  for(int i=0; i<numWords; i++) {
    buffer[i] = 0;
  }

  // read data
  if (dspNumber == -1) {
    if(checkDebugOption(DEBUG_DIAG2))
      cout << "Reading from mdsp\n";
    myCrate->mdspBlockRead(rod, dspStart, buffer, numWords);

    currentStats.mdspMemoryBlockCounter ++;
    currentStats.mdspMemoryBlockLengthCounter += numWords;

    updateISStats();
  } else {
    if(checkDebugOption(DEBUG_DIAG2))
      cout << "Reading from dsp " << dspNumber << endl;

    if(usePrim) {
      delete [] buffer;
      buffer = primReadSlaveDsp(rod, dspNumber, dspStart, numWords);
    } else {
      myCrate->slvBlockRead(rod, dspStart, buffer, numWords, dspNumber);
    }
  }

  length = numWords;

  // Don't delete the buffer!!!
  return buffer;
}

int SctApi::dspBlockWrite(unsigned int rod,
                          unsigned long *buffer, unsigned long dspAddress, long numWords, 
                          long dspNumber, bool usePrim){
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "DspBlockWrite (" << ucid() << " " << rod << ") "
        << dspAddress << " " << numWords << " " << dspNumber << endl << flush;
  }

  Crate* myCrate = getCrate();

  if(!myCrate) {
    cout << "Request for non-existent crate " << ucid() << endl;
    return 0;
  }

  // Write data
  if (dspNumber == -1) {
    if(checkDebugOption(DEBUG_DIAG))
      cout << "Writing to mdsp\n";
    myCrate->mdspBlockWrite(rod, dspAddress, buffer, numWords);

    currentStats.mdspMemoryBlockCounter ++;
    currentStats.mdspMemoryBlockLengthCounter += numWords;

    updateISStats();
  } else {
    if(checkDebugOption(DEBUG_DIAG))
      cout << "Writing to dsp " << dspNumber << endl;
    if(usePrim) {
      primWriteSlaveDsp(rod, dspNumber, dspAddress, numWords, buffer);
    } else {
      myCrate->slvBlockWrite(rod, dspAddress, buffer, numWords, dspNumber);
    }
  }

  return 0;
}

unsigned long SctApi::dspSingleBlockRead(unsigned int rod,
                                         long dspStart, long dspNumber) {
  unsigned long length;
  unsigned long *buffer = dspBlockRead(rod, dspStart, 1, dspNumber, length, true);
  if(length != 1) {
    cerr << "dspSingleBlockRead failed!\n";
  }

  unsigned long val = buffer[0];
  delete [] buffer;
  return val;
}

void SctApi::dspSingleBlockWrite(unsigned int rod,
                                 unsigned long dspAddress, unsigned long val, long dspNumber){
  unsigned long buffer[1];
  buffer[0] = val;
  // Use primitive to be on safe side
  dspBlockWrite(rod, buffer, dspAddress, 1, dspNumber, true);
}


void SctApi::setSlaveBlock(unsigned int rod, int s, 
                           long sAdd, int words, long value, bool usePrim) {
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "SetSlaveBlock to " << value << endl;
  }

  if(usePrim) {
    shared_ptr<PrimListWrapper> slList(new PrimListWrapper(1));
    PrimBuilder::instance().setMemory(slList, sAdd, words, value);

    shared_ptr<PrimListWrapper> primList(new PrimListWrapper(1));
    PrimBuilder::instance().slavePrimList(primList, slList, s, true, false);

    sendPrimList(rod, primList);

    int responseCode = awaitResponse(rod, 10);
    if(responseCode == 0) {
      cout << "Slave " << s << " block set to " << value << " at address 0x" << hex << sAdd << dec << "\n";
    } else {
      cout << "Slave set failed\n";
    }
  } else {
    // "Safe" way
    unsigned long *buffer = new unsigned long[words];
    for(int i=0; i<words; i++) {
      buffer[i+5] = value;
    }
    dspBlockWrite(rod, buffer, sAdd, words, s, usePrim);
  }
}

unsigned long *SctApi::primReadSlaveDsp(unsigned int rod,
                                        int s, int add, int words) {
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "Read slave (" << s << ") memory 0x" << hex << add << dec << endl;
  }

  unsigned long *result = new unsigned long[words];

  /*
    Also in buffer:
     List header (4) and trailer (2)
     Primitive header (4)
    (no other primitive data necessary)
  */
  const int maxLength = (REPLY_BUFF_SIZE)/4 - 6 - 4;

  int wordsDone = 0;
  while(wordsDone < words) {
    int primLength = min(maxLength, words-wordsDone);

    shared_ptr<PrimListWrapper> rwList(new PrimListWrapper(2));

    PrimBuilder::instance().readSlaveMemory(rwList, s, add+wordsDone*4, primLength);

    sendPrimList(rod, rwList);

    int responseCode = awaitResponse(rod, 10);

    if(responseCode != 0) {
      cout << "Read slave memory failed!\n";
      return 0;
    }

    unsigned long length;
    unsigned long *mem = getResponse(rod, length);

    if(!mem) {
      return 0;
    }

    copy(mem+8, mem+8+primLength, result + wordsDone);
    delete [] mem;

    wordsDone += primLength;
  }

  currentStats.sdspMemoryBlockCounter ++;
  currentStats.sdspMemoryBlockLengthCounter += wordsDone;

  updateISStats();

  return result;
}

void SctApi::primWriteSlaveDsp(unsigned int rod,
                               int s, int add, int numWords, unsigned long *data) {
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "Write slave (" << s << ") memory 0x" << hex << add << dec << endl;
  }

  /*
    Also in buffer:
     List header (4) and trailer (2)
     Primitive header (4)
     Primitive (sizeof(RW_SLAVE_MEMORY_IN)/4)
  */
  const int maxLength = (PRIM_BUFF_SIZE)/4 - 6 - 4 - sizeof(RW_SLAVE_MEMORY_IN)/4;

  int wordsDone = 0;
  while(wordsDone < numWords) {
    int primLength = min(maxLength, numWords-wordsDone);

    shared_ptr<PrimListWrapper> rwList(new PrimListWrapper(2));

    long *primData = new long[sizeof(RW_SLAVE_MEMORY_IN)/4 + primLength];

    RW_SLAVE_MEMORY_IN &rwPrim = *(RW_SLAVE_MEMORY_IN*)primData;

#if (R_RW_SLAVE_MEMORY == 100)
    rwPrim.slaveNumber = s;
    rwPrim.readNotWrite = 0;
    rwPrim.slaveAddress = (UINT32 *)add + wordsDone;
    rwPrim.masterAddress = (UINT32 *)0xffffffff;
    rwPrim.numWords = primLength;
#else
#error "RW_SLAVE_MEMORY revision change"
#endif

    copy(data + wordsDone, data + wordsDone + primLength, primData + 5);

    rwList->addPrimitive(RodPrimitive(4 + sizeof(RW_SLAVE_MEMORY_IN)/4 + primLength, 
                                      1, RW_SLAVE_MEMORY, R_RW_SLAVE_MEMORY, primData),
                         primData);

    sendPrimList(rod, rwList);
    int responseCode = awaitResponse(rod, 10);

    if(responseCode != 0) {
      cout << "Write slave memory failed!\n";
      return;
    }

    wordsDone += primLength;
  }

  currentStats.sdspMemoryBlockCounter ++;
  currentStats.sdspMemoryBlockLengthCounter += wordsDone;

  updateISStats();

  return;
}

shared_array<unsigned long> SctApi::loadFile(string fileName, unsigned long & length) {
  shared_array<unsigned long> buffer;
  ifstream fin;
  fin.open(fileName.c_str(), ios::binary);
  if (fin.is_open()) {
    unsigned long fileSize;

    // Get size of file
    fin.seekg(0, std::ios::end);  // go to end of file
    fileSize = fin.tellg();  // file size is current location
    fin.seekg(0, std::ios::beg);  // go back to beginning of file

    buffer.reset(new unsigned long[fileSize / 4]);

    fin.read((char *)buffer.get(), fileSize);

    length = fileSize / 4;
  }

  return buffer;
}

// Mainly for starting slaves
void SctApi::writeSlaveFile(unsigned int rod, unsigned int slave, 
                            const string fileName, unsigned long address, bool usePrim) {
  cout << "Writing " << fileName << " to slave " << slave << " at 0x" << hex << address << dec << endl;

  unsigned long length;
  string nameCopy(fileName);
  nameCopy = Sct::Env::substituteVariables(nameCopy);

  shared_array<unsigned long> buffer = loadFile(nameCopy, length);

  if(buffer) {
    if(usePrim) {
      primWriteSlaveDsp(rod,
                        slave, address, length, buffer.get());
    } else {
      dspBlockWrite(rod,
                    buffer.get(), address, length, slave, usePrim);
    }
  } else {
    cout << "Load of file \"" << nameCopy << "\" failed\n";
    throw SctApiException("Load of file \"" + nameCopy + "\" failed");
  }

  shared_array<unsigned long> readBuffer(primReadSlaveDsp(rod, 
                                                          slave, address, length));

  for(unsigned int i=0; i<length; i++) {
    if(buffer[i] != readBuffer[i]) {
      cout << "Slave write verification failed at " << i << endl;
      cout << "\t0x" << hex << buffer[i] << " != 0x" << readBuffer[i] << dec << endl;

      throw SctApiException("Slave verification error: word " + boost::lexical_cast<string>(i));
    }
  }
}

} // End namespace

---