SctApiMConf.cxx

#include "primListWrapper.h"
#include "PrimBuilder.h"
#include "SctApi.h"
#include "SctApiRodInfo.h"
#include "crate.h"
#include "utility.h"
#include "SctApiDebug.h"

#include "CommonWithDsp/primParams.h"
#include "CommonWithDsp/registerIndices.h"
#include <boost/timer.hpp>
#include "Sct/FibreNumberConverters.h"
#include "ConfigurationUtility.h"
#include "sctConf/configuration.h"
#include "SctApiException.h"

using namespace std;
using namespace SctPixelRod;

namespace SctApi {

void SctApi::getABCDModules(BankType bank_type) {
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "getABCDModule (all). Bank: " << bank_type << endl;
  }
  for(map<UINT32, ABCDModule> ::const_iterator iter = moduleMap.begin();
      iter != moduleMap.end();
      iter ++) {
    getABCDModule(iter->first, bank_type);
  }
}


void SctApi::getABCDModule(UINT32 mid, BankType bank_type) {
  unsigned int partition, crate, rod, channel;
  Utility::getpcrc(mid, partition, crate, rod, channel);

  if(checkDebugOption(DEBUG_MODULE_CONFIG)) std::cout << "AJB getABCDModule mid " << mid << " bank " << bank_type << std::endl;
  boost::shared_ptr<SctApiConfigCache::ModuleBanks> the_banks=module_cache.getFromMid(mid);
  if (!the_banks.get()) {
    if(mrs) {
      *mrs << "ROD_BANK_CONFIG_CACHE" << MRS_ERROR << MRS_QUALIF("SCTAPI") 
           << MRS_PARAM<int>("mid", mid)
           << MRS_TEXT("Cant return cache for non-existant MID") << ENDM;
    }else{
      cerr << "Non-existant module mid=" << mid << std::endl; 
    }
    return;
  }
  boost::shared_ptr<ABCDModule> cached_config = the_banks->get(bank_type);
  if (!cached_config.get()){
    if(mrs) {
      *mrs << "ROD_BANK_CONFIG_CACHE" << MRS_ERROR << MRS_QUALIF("SCTAPI") 
           << MRS_PARAM<int>("mid", mid)
           << MRS_PARAM<int>("bank", bank_type)
           << MRS_TEXT("Cant return cache for non-existant BANK") << ENDM;
    }else{
      cerr << "Non-existant bank, mid=" << mid 
       << "api bank = " << bank_type << std::endl; 
    }
    if(checkDebugOption(DEBUG_API_CONFIG_CACHE_CHECK)){
      std::cout << "Bravely persisting to try to read unset bank... (but printing, not storing the results)";
      boost::shared_ptr<ABCDModule> rod_config = getABCDModuleRaw(rod, channel, bank_type);
      std::cout << config->printModuleConfig(*rod_config) << std::endl;
    }
    return;
  }

  ABCDModule *previous = lookupConfig(mid);
  if(previous) {
    *previous = *cached_config;
  } else {
    std::cout << "WARNING - no previous configuration existed for mid " << mid 
          << " BANK "<< bank_type << std::endl;
    moduleMap.insert(make_pair(mid, *cached_config));
  }

  // option to test cache of this bank against the real ROD bank:
  if(checkDebugOption(DEBUG_API_CONFIG_CACHE_CHECK)){
    if (ConfigUtility::diff(*previous, *cached_config)){
      std::cerr << "ERROR in setting equality " << __FILE__ << ":" << __LINE__ << std::endl;
    }
    boost::shared_ptr<ABCDModule> rod_config = getABCDModuleRaw(rod, channel, bank_type);
    
    // get bit-field of difference types
    unsigned differences=ConfigUtility::diff(*rod_config, *cached_config);
    if (differences){
      string diff_as_string = ConfigUtility::apiBitFieldToString(differences);
      if (mrs){
    *mrs << "ROD_BANK_CONFIG_CACHE" << MRS_WARNING << MRS_QUALIF("SCTAPI") 
         << MRS_PARAM<int>("module", mid)
         << MRS_TEXT("DEBUG error - configuration in CACHE and ROD differ!")             
         << MRS_PARAM<const char*>("diff bitfield", diff_as_string.c_str())
             << ENDM;
      }
      cout << "ERROR on module configuration cache:"
       << " mid " <<  mid << " bank " << bank_type
       << " differences:" << diff_as_string << endl;
      cout << "=====>>> MID:" << mid << " CACHE config" << endl;
      if(checkDebugOption(DEBUG_MODULE_CONFIG)) {
    cout << config->printModuleConfig(*cached_config);
      }
      cout << "=====>>> differs from MID:" << mid << " ROD config" << endl;
      if(checkDebugOption(DEBUG_MODULE_CONFIG)) {
    cout << config->printModuleConfig(*rod_config);
      }
      std::cout << "\tCache\tRod" << std::endl;
      ConfigUtility::diff(*cached_config, *rod_config, true);
    }else{
      if(checkDebugOption(DEBUG_MODULE_CONFIG)) std::cout << "Checked differences - ok for mid " << mid << " bank " << bank_type << std::endl;
    }
  }
}

void printBanks(list<BankType> banks, ostream& os){
   for (list<BankType>::const_iterator i=banks.begin(); i!=banks.end(); ++i){
      if (i!=banks.begin()) os << ",";
      switch (*i) {
      case 0 : os << "PHYSICS"; break; 
      case 1 : os << "SCAN"; break;
      case 2 : os << "CALIBRATION"; break;
      default : os << "UNKNOWN-BANK-TYPE!"; break;
      }
   }
   if (banks.begin()==banks.end()) os << "NONE!";
}

void SctApi::copyABCDModules(BankType source, list<BankType> to){
  if (to.empty()){
    std::cout << "ERROR - request to copy modules from " << source << "to empty bank list" << std::endl;
    return;
  }
  if(checkDebugOption(DEBUG_MODULE_CONFIG)) std::cout << "AJB copyABCDModules (all) from " << source << " to ";
  printBanks(to, cout); 
  std::cout << std::endl;

#if (R_RW_MODULE_DATA<103)
  if (true){
#else
  if (checkDebugOption(DEBUG_API_CONFIG_NO_COPY)){
#endif
    std::cout << " USING OLD get/set METHODS!" << endl;
    getABCDModules(source);
    setABCDModules(to);
  }else{
    boost::shared_ptr<PrimListWrapper> primList(new PrimListWrapper(1));
    UINT32 bank_bits = Utility::translateApiBanksToRodCfgBitSet(to);
    PrimBuilder::instance().copyModuleData(primList, source, bank_bits, ALL_MODULES);

    if (synchSendPrimListAll(primList, 3)!=0){
      if (mrs){
    *mrs << "COPY_BANKS" << MRS_ERROR << MRS_QUALIF("SCTAPI") 
         << MRS_TEXT("Copy of all module configuration data failed") << ENDM;   
      }else{
    std::cout << "ERROR : copy all modules primitives from " << source << " to ";
    printBanks(to, std::cout);
    std::cout << " failed" << std::endl;
      }
    }else{
      std::cout << "synch send returned sucessfully" << std::endl;
    }
  }
  module_cache.copyAllModules(source, to);
} 

void SctApi::copyABCDModule(UINT32 mid, BankType source, list<BankType> to){
  if (to.empty()){
    std::cout << "ERROR - request to copy modules from " << source << "to empty bank list" << std::endl;
    return;
  }
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "ERROR - request to copy modules from " << source << "to ";
    printBanks(to, log()); 
    log() << std::endl;
  }
  
  if (checkDebugOption(DEBUG_MODULE_CONFIG)) {
    std::cout << "copyABCDModules (all) from " << source << " to ";
    printBanks(to, cout); 
    std::cout << std::endl;
  }

#if (R_RW_MODULE_DATA<103)
  if (true){
#else
  if (checkDebugOption(DEBUG_API_CONFIG_NO_COPY)){
#endif
    std::cout << " USING OLD get/set METHODS!" << endl;
    getABCDModule(mid, source);
    setABCDModule(mid, to);  
  }else{
     if(checkDebugOption(DEBUG_MODULE_CONFIG)){
       cout << "copyABCDModule mid=" << mid << " from " << source << " to ";
       printBanks(to, cout);
       cout << endl;
     }
    unsigned int partition, crate, rod, channel;
    Utility::getpcrc(mid, partition, crate, rod, channel);
    
    boost::shared_ptr<PrimListWrapper> primList(new PrimListWrapper(1));
    
    UINT32 bank_bits =  Utility::translateApiBanksToRodCfgBitSet(to);
    PrimBuilder::instance().copyModuleData(primList, source, bank_bits, channel);

    sendPrimList(rod, primList);
    if(awaitResponse(rod, 4)!=0) {
      if (mrs){
    *mrs << "COPY_BANKS" << MRS_ERROR << MRS_QUALIF("SCTAPI") 
         << MRS_PARAM<int>("mid", mid)
         << MRS_TEXT("Copy of module configuration data failed") << ENDM;   
      }else{
    cout << "ERROR - copy module unsuccessful!\n";
      }
      return;
    }else{
       if(checkDebugOption(DEBUG_MODULE_CONFIG)) std::cout << "sucessful" << std::endl;
    }
    boost::shared_ptr<SctApiConfigCache::ModuleBanks> the_banks=module_cache.getFromMid(mid);
    if (the_banks.get()){
      the_banks->copy(source, to);
    }else{
      if (mrs){
    *mrs << "COPY_BANKS" << MRS_ERROR << MRS_QUALIF("SCTAPI")
         << MRS_PARAM<int>("mid", mid)
         << MRS_TEXT("Configuration not found in cache") << ENDM;
      }else{
    cout << "ERROR - cache not found" << std::endl;
      }
    }
  }
}

void SctApi::setABCDModule(UINT32 mid, list<BankType> bank_list) {
  UINT32 all_differences=0;
   if(checkDebugOption(DEBUG_MODULE_CONFIG)){
     cout << "setABCDModule mid=" << mid << " banks=";
     printBanks(bank_list, cout);
     cout << endl;
  }
  using boost::shared_ptr;
  ABCDModule* lookup=lookupConfig(mid);
  if (!lookup) {
    cerr << "setABCDModule : Could not find module config for mid = " << mid << endl;
    return;
  }

  shared_ptr<SctApiConfigCache::ModuleBanks> the_banks=module_cache.getFromMid(mid);

  // get cache of banks for this mid, or create it (in which case the config must be sent)
  if (!the_banks.get()) {
    //std::cout << "New module config to rod MID " << mid << std::endl;
    the_banks=shared_ptr<SctApiConfigCache::ModuleBanks>(new SctApiConfigCache::ModuleBanks);    
    module_cache.set(mid, the_banks);
    all_differences |= 1 << SCTAPI_CONFIG_ALL;
  }
  
  list<BankType> modified_bank_list;
  for (list<BankType>::const_iterator bank_iterator=bank_list.begin(); 
       bank_iterator!=bank_list.end(); ++bank_iterator){
    BankType bank_type=*bank_iterator;
    shared_ptr<ABCDModule> current_cache=the_banks->get(bank_type);
    
    // get ABCDModule for this bank, or create it (in which case the config must be sent)
    if (!current_cache.get()) {
      current_cache = shared_ptr<ABCDModule>(ConfigUtility::clone(*lookupConfig(mid)).release());
      the_banks->set(bank_type, current_cache);
      modified_bank_list.push_back(bank_type);
      if(checkDebugOption(DEBUG_MODULE_CONFIG)) std::cout << "  MID " << mid << " adding cache for bank " << bank_type << std::endl;
      all_differences |= 1 << SCTAPI_CONFIG_ALL;
    }else{
      /*
    Get bit-field of all differences between local config and ROD cache.
    1/3/2005 AJB has set the conditional below because at the end of the scan 
    the SCAN bank is in an odd state, hence we always should copy the scan bank,
    if that has been explicitly requested
      */
      unsigned differences=ConfigUtility::diff(*current_cache, *lookup);
      // gather up differences
      all_differences |= differences;
      if (differences){
    *current_cache = *lookup;
    modified_bank_list.push_back(bank_type);
    if(checkDebugOption(DEBUG_MODULE_CONFIG)) {
        std::cout << "  MID " << mid << " bank " << bank_type << " modifications: " 
          << ConfigUtility::apiBitFieldToString(differences) << std::endl;
        }
      }else{
    if(checkDebugOption(DEBUG_MODULE_CONFIG)) {
      cout << "No need to set ABCDModule type " << bank_type
           << " for mid = " << mid
           << " and bank_type  = " << bank_type
           << " as configuration hasnt changed, " << endl;
    }
    if(checkDebugOption(DEBUG_API_CONFIG_CACHE_SEND)){
      cout << "Debug option set so sending module configuration ANYWAY!" << endl;
      modified_bank_list.push_back(bank_type);
      differences |= SCTAPI_CONFIG_ALL;
    }
      }
    }
  }
  if (modified_bank_list.empty()){
    cout << ucid() << " mid " << mid << " no banks need setting" << endl;
  }else{
    really_setABCDModule(mid, modified_bank_list, all_differences);
  }
}

#warning "This isn't called from anywhere!"
void SctApi::really_getABCDModule(UINT32 mid, BankType bank_type) {
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "getABCDModule " << mid << " Bank: " << bank_type << endl;
  }

  // Find module channel in ROD
  unsigned int partition, crate, rod, channel;
  Utility::getpcrc(mid, partition, crate, rod, channel);

  // Which bank id to use
  int realBank = Utility::translateBank(bank_type);

  boost::shared_ptr<PrimListWrapper> primList(new PrimListWrapper(1));
  PrimBuilder::instance().readModuleData(primList, realBank, channel);

  sendPrimList(rod, primList);

  int responseCode = awaitResponse(rod, 5);

  unsigned long length;
  unsigned long *outBody = 0;
  if(responseCode == 0) {
    outBody = getResponse(rod, length);
  }

  if(outBody) {
//      unsigned long outLength = outBody[0];
//      unsigned long outIndex = outBody[1];
    unsigned long outNumPrims = outBody[2];
//      unsigned long outPrimVersion = outBody[3];

    if(outNumPrims == 1) {
      unsigned long primLength = outBody[4];
//        unsigned long primIndex = outBody[5];
      unsigned long primID = outBody[6];
//        unsigned long primVersion = outBody[7];

      if(primID == RW_MODULE_DATA) {
        if(primLength != (sizeof(ABCDModule)/sizeof(UINT32) + 4)) { // Prim length includes header
          cout << "Output primitive was " << primLength << " not " << sizeof(ABCDModule)/sizeof(UINT32) << endl;
        }

        // Data is at outBody[8]
        ABCDModule result;

        // Copy data
        for(unsigned int i=0; i<sizeof(ABCDModule)/sizeof(UINT32); i++) {
          ((unsigned long *)&result)[i] = outBody[8 + i];
        }

        ABCDModule *previous = lookupConfig(mid);

        if(previous) {
          cout << "Replacing previous module config\n";

          *previous = result;
        } else {
          cout << "New module config inserted\n";
          moduleMap.insert(make_pair(mid, result));
        }
      } else {
        cout << "Returned primitive was not RW_MODULE_DATA\n";
      }
    } else {
      cout << "Too many primitives in output list\n";
    }

    delete [] outBody;
  } else {
    cout << "No response to primitive list!\n";
  }
}

boost::shared_ptr<ABCDModule> SctApi::getABCDModuleRaw(unsigned int rod, 
                                                       UINT32 slot, BankType bank_type) {
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "getABCDModuleRaw Slot: " << slot << " Bank: " << bank_type << endl;
  }

  boost::shared_ptr<ABCDModule> result;

  // Which bank id to use
  int realBank = Utility::translateBank(bank_type);

  boost::shared_ptr<PrimListWrapper> primList(new PrimListWrapper(1));
  PrimBuilder::instance().readModuleData(primList, realBank, slot);
  sendPrimList(rod, primList);

  int responseCode = awaitResponse(rod, 5);

  unsigned long length;
  unsigned long *outBody = 0;
  if(responseCode == 0) {
    outBody = getResponse(rod, length);
  }

  if(outBody) {
    unsigned long outNumPrims = outBody[2];

    if(outNumPrims == 1) {
      unsigned long primLength = outBody[4];
      unsigned long primID = outBody[6];

      if(primID == RW_MODULE_DATA) {
        unsigned int expectedSize = (sizeof(ABCDModule)/sizeof(UINT32) + 4);
        if(primLength != expectedSize) { // Prim length includes header
          cout << "Output primitive was " << primLength << " not " << expectedSize << endl;
        }

        result.reset(new ABCDModule);

        // Data is at outBody[8]
        // Copy data
        for(unsigned int i=0; i<sizeof(ABCDModule)/sizeof(UINT32); i++) {
          ((unsigned long *)result.get())[i] = outBody[8 + i];
        }
      } else {
        cout << "Returned primitive was not RW_MODULE_DATA\n";
      }
    } else {
      cout << "Too many primitives in output list\n";
    }

    delete [] outBody;
  } else {
    cout << "No response to primitive list!\n";
  }

  return result;
}

/* Store config in ROD */
void SctApi::setABCDModules(list<BankType> banks) {
  boost::timer set_modules_timer;
  cout << "setABCDModules (all) banks=";
  printBanks(banks, cout);
  cout << endl;
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "setABCDModule called for all modules. Banks : ";
    for (list<BankType>::const_iterator it=banks.begin(); it!=banks.end(); ++it){
      log() << *it <<",";
    }
    log() << endl;
  }
  for(map<UINT32, ABCDModule>::const_iterator iter = moduleMap.begin();
      iter != moduleMap.end();
      iter ++) {
    setABCDModule(iter->first, banks);
  }
  
  /* AJB commented out following bruces changes in R4-updated of 29-6-2005 
  // Off-ROD modules need to be sent from the "wrong" ROD
  for(list<RodLabel>::const_iterator rl = rodList.begin();
      rl!=rodList.end();
      rl++){
    RodInfo info = getRodInfo(*rl);

    for(map<unsigned long, unsigned long>::const_iterator iter = info.offRODRX.begin();
        iter != info.offRODRX.end(); iter++) {
      cout << "Set config " << hex << iter->first << " (off ROD pair of " << iter->second << ")" << dec << endl;
      setABCDModule(iter->first, banks);
    }
  }
  */

  std::cout << "set all modules in " << set_modules_timer.elapsed() << " seconds" << std::endl;
  return;
}

/* Store config in ROD */
void SctApi::really_setABCDModule(UINT32 mid, list<BankType> bank_list, UINT32 api_cfg_type_bitfield) {
  if(checkDebugOption(DEBUG_MODULE_CONFIG)) {
    cout << "really_setABCDModule mid=" << mid << " banks=";
    printBanks(bank_list, cout);
    cout << " cfgbits=" << api_cfg_type_bitfield << endl;
  }
  if(mid==0xffffffff){
    cout << "setABCDModule with 0xffffffff\n";
    throw SctApiException("mid out of range");
  }

  string moduleName;
  ABCDModule *moduleConfig;
  
  moduleConfig = lookupConfig(mid);
  
  if(!moduleConfig) {
    if(mrs) {
      *mrs << "ROD_BANKS" << MRS_ERROR << MRS_QUALIF("SCTAPI") 
       << MRS_PARAM<int>("module", mid)
       << MRS_TEXT("Cant send module configuration - module not in configuration") << ENDM;
    }
    cout << "ERROR - NO module configuration for mid = " << mid << " in set module" << endl;
    return;
  }
  
  cout << "Module config: ";
  cout << " primary channel " << (int)moduleConfig->pTTC 
       << " red channel " << (int)moduleConfig->rTTC 
       << " group " << (int)moduleConfig->groupId
       << " select " << (int)moduleConfig->select 
       << " apicfgbits=" << api_cfg_type_bitfield << endl;

  boost::shared_ptr<PrimListWrapper> primList(new PrimListWrapper(1));

  unsigned int partition, crate, rod, channel;
  Utility::getpcrc(mid, partition, crate, rod, channel);
  UINT32 bank_bits       = Utility::translateApiBanksToRodCfgBitSet(bank_list);
  UINT32 module_bits     = Utility::translateConfigTypeBitset(api_cfg_type_bitfield);
  UINT32 setablecfgtype = Utility::getSetableConfigType(module_bits, true);  
  PrimBuilder::instance().writeModuleData(primList, moduleConfig, bank_bits, channel, setablecfgtype);

#if USE_DUAL_PORTS
  // Set up module masks so config can be sent using both serial ports
  setupModuleMask(SP_BOTH, 0xf, primList);
#else
  // This will be a null op if it doesn't exist
#ifdef CMD_BUFFER_0
#warning "Use of old header files detected"
  setupModuleMask(CMD_BUFFER_0, 0xf, primList);
#else
  setupModuleMask(SP0, 0xf, primList);
#endif
#endif
  sendPrimList(rod, primList);
  
  int responseCode = awaitResponse(rod, 10);
  
  if(responseCode!=0) {
    if (mrs) {
      *mrs << "SctApi" << MRS_WARNING << MRS_TEXT("set module unsucessful") 
       << MRS_PARAM<long>("MID",mid) 
       << MRS_PARAM<const char*>("serial number",moduleConfig->serialNumber)
       << ENDM;
    } else {
      cout << "SctApi: ERROR : set module unsucessful" << endl;
      return;
    }
  }
}

void SctApi::setErrorMasks(){
  std::string errorText="";
  // first set them all to zero:
  {
    unsigned efb_value = 0x0;
    boost::shared_ptr<PrimListWrapper> zeroMasksList(new PrimListWrapper(1));
    for(int i=0; i<48; i++) {
      PrimBuilder::instance().writeRegister(zeroMasksList, Utility::EfbErrorMask(0, i), 0, 12, efb_value);
      PrimBuilder::instance().writeRegister(zeroMasksList, Utility::EfbErrorMask(1, i), 0, 12, efb_value);
    }
    //std::cout << "Setting all error masks to 0x" << hex << efb_value << dec << std::endl;
    if (synchSendPrimListAll(zeroMasksList, 5)!=0) errorText+="Error zeroing module error masks\n";
  }
  
  // now set non-zero values for special cases.
  // build up prim list for each rod
  map<int, boost::shared_ptr<PrimListWrapper> > primlists;
  
  for (std::map<RodLabel, RodInfo>::const_iterator ri=rodInfoList.begin(); ri!=rodInfoList.end(); ++ri){
    for(int l=0; l<96; l++) {
      const unsigned int val = ri->second.linkErrorMasks[l];
      if (val!=0){
    // make the list if necessary:
    if (primlists.find(ri->first.rod)==primlists.end()){
      primlists[ri->first.rod]=boost::shared_ptr<PrimListWrapper>(new PrimListWrapper(1));
    }
    PrimBuilder::instance().writeRegister(primlists[ri->first.rod], Utility::EfbErrorMask(l/48, l%48), 0, 12, val);
      }
    }
  }
  if (primlists.empty()){
    std::cout << "No need to set any special values for error masks" << std::endl;
  }
  for (map<int, boost::shared_ptr<PrimListWrapper> >::const_iterator ri = primlists.begin(); 
       ri!= primlists.end(); ++ri){
    const unsigned rod=ri->first;
    std::cout << "sending error mask prim list to rod " << rod << std::endl;
    sendPrimList(rod, ri->second);
    if (awaitResponse(rod, 3)!=0){
      errorText += "\nError sending error mask prim list to rod ";
      errorText += rod;
    }
  }
  if (errorText!=""){
    if (mrs){
      *mrs << "SctApi" << MRS_WARNING << MRS_TEXT(errorText) << ENDM;
    }else{
      cout << errorText << std::endl;
    }
  }
}

void SctApi::sendAllABCDModules(BankType bank_type,
                                ConfigType config_type,
                                const bool enableDataMode /* enableDataMode should have default value true to ensure compatibility with old code*/) {

  cout << "AJB AJB sendAllABCDModules bank=" << bank_type << " config_type="
            << config_type << " enableDataMode=" << enableDataMode << endl;
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "sendABCDModule called for all modules. Bank: " << bank_type << endl;
  }

  /*
    This method is far too long...

    1) Change to ROD mode that allows configuration to be sent to the modules
    2) Check the BOC isn't interlocked
    3) Build and send a primitive list
     a) Disable trigger decoder
     b) Disable formatters
     c) Send configuration
     d) Reenable trigger decoder
    4) Change "back" to CALIBRATION_MODE

    option 2 (for early versions of the DSP code, probably not every stage necessary)
    1) Disable formatters
    2) Send configuration for each module in turn using sendABCDModule
    3) Setup module masks
    4) Reset some FIFOs...

*/

  cout << "Send config to all modules\n";

  PrimBuilder &builder = PrimBuilder::instance();

  // Set ROD mode to something appropriate (may be in TIM mode!)
  boost::shared_ptr<PrimListWrapper> rodModeList1(new PrimListWrapper(1));
  // Should CALIBRATION_SLINK_OVERRIDE_MODE be added to this (it works without!)
  builder.rodMode(rodModeList1, CALIBRATION_MODE, 0, 1, 1, 1, 1);

  synchSendPrimListAll(rodModeList1);


  // If new primitive use it instead of doing a loop
#if (R_SEND_CONFIG >= 104)
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "\tUsing one SEND_CONFIG primitive\n";
  }

  {
    for(list<RodLabel>::const_iterator rl = rodList.begin();
        rl!=rodList.end();
        rl++){
      if(!getCrate()->checkBOCLasersOn(rl->rod)) {
        cout << "Trying to send module configuration using BOC that has its lasers cut out\n";
        if(mrs) {
          *mrs << "BOC_INTERLOCKED" << MRS_ERROR << MRS_QUALIF("SCTAPI") 
               << MRS_PARAM<int>("crate", rl->crate) 
               << MRS_PARAM<int>("rod", rl->rod)
               << MRS_TEXT("Can't send all module config (BOC interlocked)") << ENDM;
        }

        throw SctApiException("Send modules aborted due to interlock status");
      }
    }
  }

  boost::shared_ptr<PrimListWrapper> sendConfigList(new PrimListWrapper(1));

  // Write "Disable trigger decoder" to primList
#ifdef RRIF_CMND_1
  builder.writeRegister(sendConfigList, RRIF_CMND_1, 18, 1, 0);
#else
#error "Unsupported no registers"
#endif   // RRIF_CMND_1

  // Disable all formatters
#ifdef FMT_LINK_EN
  for(int i=0; i<8; i++) {
    builder.writeRegister(sendConfigList, FMT_LINK_EN(i), 0, 32, 0);
  }
#else
#warning "Probably don't need to turn off formatters!?"
#endif // FMT_LINK_EN

  int realBank = Utility::translateBank(bank_type);
  int realConfig = Utility::translateConfigTypeForSendPrimitive(config_type);
  
  //#warning "AJB Line below added for *debugging*" 
  //realConfig = CONFIG_MODULE_ALL;

  //@todo SP_BOTH doesn't work with current DSP code
#if USE_DUAL_PORTS
  // Send module configuration from both serial ports (ie two modules at a time)
  builder.sendConfig(sendConfigList, SP_BOTH, 0, ALL_MODULES, ALL_MODULES, ALL_CHIPS, 1, 1,
                     realBank, MODULE_GROUP_ALL, realConfig, 0, enableDataMode);
#else
  builder.sendConfig(sendConfigList, SP0, 0, ALL_MODULES, ALL_MODULES, ALL_CHIPS, 1, 1,
                     realBank, MODULE_GROUP_ALL, realConfig, 0, enableDataMode);
#endif

  // Write "Re-enable trigger decoder" to primList
#ifdef RRIF_CMND_1
  builder.writeRegister(sendConfigList, RRIF_CMND_1, 18, 1, 1);
#else
#error "Unsupported no registers"
#endif  // RRIF_CMND_1

  // setupModuleMask to reenable appropriate formatters??

  sendPrimListAll(sendConfigList);
  
  {
    int responseCode = awaitResponseAll(10);
    
    if(responseCode != 0) {
      cout << "Send modules unsuccessful\n";
    }
  }

  boost::shared_ptr<PrimListWrapper> rodModeList(new PrimListWrapper(1));
  // Should CALIBRATION_SLINK_OVERRIDE_MODE be added to this (it works without!)
  builder.rodMode(rodModeList, CALIBRATION_MODE, 0, 1, 1, 1, 1);

  sendPrimListAll(rodModeList);

  {
    int responseCode = awaitResponseAll(10);
    
    if(responseCode != 0) {
      cout << "Send modules rod mode unsuccessful\n";
    }
  }
#else   // Use slow config (loop over modules)
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "\tUsing multiple SEND_CONFIG primitives\n";
  }

#warning "Slow module sending"

  // Disable all formatters to avoid bus error!
#ifdef FMT_LINK_EN
  boost::shared_ptr<PrimListWrapper> clearFormatList(new PrimListWrapper(1));

  for(int i=0; i<8; i++) {
    builder.writeRegister(clearFormatList, FMT_LINK_EN(i), 0, 32, 0);
  }

  sendPrimListAll(clearFormatList);
  
  {
    int responseCode = awaitResponseAll(10);
    
    if(responseCode != 0) {
      cout << "Clear formatters unsuccessful\n";
    }
  }
#else
#warning "Probably don't need to turn off formatters! (old version)"
#endif   // FMT_LINK_EN

  for(map<UINT32, ABCDModule>::const_iterator iter = moduleMap.begin();
      iter != moduleMap.end();
      iter ++) {
    sendABCDModule(iter->first, bank_type, config_type, enableDataMode);
  }
#endif   // End of slow config sending

  // Restore link masks etc
  boost::shared_ptr<PrimListWrapper> setupMasks(new PrimListWrapper(1));

#if USE_DUAL_PORTS
  // Masks also have to be both serial ports
  setupModuleMask(SP_BOTH, 0xf, setupMasks);
#else
#ifdef CMD_BUFFER_0
  setupModuleMask(CMD_BUFFER_0, 0xf, setupMasks);
#else
  setupModuleMask(SP0, 0xf, setupMasks);
#endif   // CMD_BUFFER_0
#endif

  sendPrimListAll(setupMasks);
  
  {
    int responseCode = awaitResponseAll(10);
    
    if(responseCode != 0) {
      cout << "Setup masks unsuccessful\n";
    }
  }
  // Reset everything so its not confused by the clk/2
  boost::shared_ptr<PrimListWrapper> resetList(new PrimListWrapper(1));

  cout << "Resetting front end interface\n";
#ifdef RRIF_CMND_0
  builder.writeRegister(resetList, RRIF_CMND_0, 0, 8, 0xff);  // Reset everything
  builder.writeRegister(resetList, RRIF_CMND_0, 0, 8, 0x78);  // Leave debug FIFO in reset
#else
#error "Unsupported no registers"
#endif   // RRIF_CMND_0

  sendPrimListAll(resetList);

  int responseCode = awaitResponseAll(10);

  if(responseCode != 0) {
      cout << "ROD front end reset unsuccessful\n";
  }

  return;
}

#warning "TODO: fix so send configuration using different ROD if necessary"
void SctApi::sendABCDModule(UINT32 mid,
                BankType bank_type, 
                ConfigType config_type, 
                const bool enableDataMode) {

  /* enableDataMode should have default value true to ensure compatibility with old code*/
  if(mid==0xffffffff){
    cout << "sendABCDModule with 0xffffffff\n";
    throw SctApiException("mid out of range");
  }
  
  int realConfig=Utility::translateConfigTypeForSendPrimitive(config_type);

  cout << "Send config to module " << mid << endl;

  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "sendABCDModule: Mid: " << mid << " Bank: " << bank_type << " Type: " << config_type << endl;
  }

  unsigned int partition, crate, rod, channel;
  Utility::getpcrc(mid, partition, crate, rod, channel);

  if(!getCrate()) {
    cout << "Send module for non-existent crate " << partition << " " << crate << endl;
    return;
  }

  {
    boost::shared_ptr<SctApiConfigCache::ModuleBanks> the_banks = module_cache.getFromMid(mid);
    if (!the_banks.get()){
      if(mrs) {
    *mrs << "SEND_CONFIG" << MRS_ERROR << MRS_QUALIF("SCTAPI") 
         << MRS_PARAM<int>("module", mid)
         << MRS_TEXT("No module configuration existant") << ENDM;
      }else{
    std::cerr << "ERROR - No module configuration existant" << std::endl;
      }
      return;
    }else if (!the_banks->get(bank_type)){
      if(mrs) {
    *mrs << "SEND_CONFIG" << MRS_ERROR << MRS_QUALIF("SCTAPI") 
         << MRS_PARAM<int>("module", mid)
         << MRS_PARAM<int>("bank", bank_type)
         << MRS_TEXT("No module configuration existant for this bank") << ENDM;
      }else{
    std::cerr << "ERROR - No module configuration existant for this bank" << std::endl;
      }
    }
  }

  if(!getCrate()->checkBOCLasersOn(rod)) {
    cout << "Trying to send module configuration using BOC that has its lasers cut out\n";
    if(mrs) {
      *mrs << "BOC_INTERLOCKED" << MRS_ERROR << MRS_QUALIF("SCTAPI") 
           << MRS_PARAM<int>("module", mid) << MRS_PARAM<int>("crate", crate) 
           << MRS_PARAM<int>("rod", rod)
           << MRS_TEXT("Can't send module config (BOC interlocked)") << ENDM;
    }

    return;
  }

  boost::shared_ptr<PrimListWrapper> primList(new PrimListWrapper(1));
  PrimBuilder &builder = PrimBuilder::instance();

  int realBank = Utility::translateBank(bank_type);

  // Write "Disable trigger decoder" to primList
#ifdef RRIF_CMND_1
  builder.writeRegister(primList, RRIF_CMND_1, 18, 1, 0);
#else
#error "Unsupported no registers"
#endif

  // Seeing as we're only sending one module, use only one serial port
  builder.sendConfig(primList, SP0, 0, channel, NO_MODULE, ALL_CHIPS, 1, 1,
                     realBank, MODULE_GROUP_ALL, realConfig, 0, enableDataMode);

  // Write "Re-enable trigger decoder" to primList
#ifdef RRIF_CMND_1
  builder.writeRegister(primList, RRIF_CMND_1, 18, 1, 1);
#else
#error "Unsupported no registers"
#endif

  sendPrimList(rod, primList);

  int responseCode = awaitResponse(rod, 10);

  if(responseCode != 0) {
    cout << "Send module unsuccessful\n";
  }
}

#warning "TODO: fix so send configuration using different ROD if necessary"
void SctApi::modifyABCDVarROD(UINT32 mid, UINT32 chip, UINT32 type, FLOAT32 value, list<BankType> banks) {
  if (checkDebugOption(DEBUG_MODULE_CONFIG)){
    std::cout << "AJB modifyABCDVarROD type " << type << " value " << value << " banks ";
    printBanks(banks, std::cout);
    std::cout << endl;
  }
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "modifyABCDVarROD (module " << mid << ": chip " << chip  << ") " << type << " " << value << " banks";
    printBanks(banks, log());
    log() << endl;
  }

  unsigned int partition, crate, rod, channel;
  Utility::getpcrc(mid, partition, crate, rod, channel);

  if(!isRODPresent(rod)) {
    cout << "Trying to change module configuration on a non existant ROD\n";
    if(mrs) {
      *mrs << "ROD_UNCONFIGURED" << MRS_ERROR << MRS_QUALIF("SCTAPI") 
           << MRS_PARAM<int>("module", mid) << MRS_PARAM<int>("crate", crate) 
           << MRS_PARAM<int>("rod", rod)
           << MRS_TEXT("Can't modify module config (ROD non-existant)") << ENDM;
    }

    return;
  }

  boost::shared_ptr<PrimListWrapper> primList(new PrimListWrapper(1));

  UINT32 real_banks_bits = Utility::translateApiBanksToRodCfgBitSet(banks);
  UINT32 chipid = Utility::translateChip(chip);
  PrimBuilder::instance().writeModuleVariable(primList, real_banks_bits, MODULE_GROUP_ALL,
                          channel, chipid, type, value);
  sendPrimList(rod, primList);
  awaitResponse(rod, 5);
  
  // also update the cache!
  // update cache...
  boost::shared_ptr<SctApiConfigCache::ModuleBanks> the_banks=module_cache.getFromMid(mid);
  if (!the_banks.get()) {
    if(mrs) {
      *mrs << "ROD_BANK_CONFIG_CACHE" << MRS_ERROR << MRS_QUALIF("SCTAPI") 
       << MRS_PARAM<int>("module", mid) << MRS_PARAM<int>("crate", crate) 
       << MRS_PARAM<int>("rod", rod)
       << MRS_TEXT("Cant update cache for non-existant MID") << ENDM;
    }else{
      cout << "Cant update cache for non-existant MID "<< mid << std::endl;
    }
    return;
  }
  for (list<BankType>::const_iterator bank_iterator=banks.begin(); bank_iterator!=banks.end(); ++bank_iterator){
    boost::shared_ptr<ABCDModule> cached_config = the_banks->get(*bank_iterator);
    if (!cached_config.get()){
      if(mrs) {
    *mrs << "ROD_BANK_CONFIG_CACHE" << MRS_ERROR << MRS_QUALIF("SCTAPI") 
         << MRS_PARAM<int>("module", mid) << MRS_PARAM<int>("crate", crate) 
         << MRS_PARAM<int>("rod", rod)
         << MRS_PARAM<int>("bank", *bank_iterator)
         << MRS_TEXT("Cant update cache for non-existant BANK") << ENDM;
      }else{
    cout << "Cant update cache for non-existant BANK " << *bank_iterator << endl;
      }
      return;
    }
    ConfigUtility::modifyVar(cached_config.get(), chip, type, value);
  }
}
 
void SctApi::modifyABCDVarROD(UINT32 mid, UINT32 type, FLOAT32 value, list<BankType> banks) {
  modifyABCDVarROD(mid, ALL_CHIPS, type, value, banks);
}


void SctApi::modifyABCDVarROD(UINT32 type, FLOAT32 value, list<BankType> banks) {
  std::cout << "AJB modifyABCDVarROD type " << type << " value " << value << " banks ";
  printBanks(banks, std::cout);
  std::cout << endl;
  {
    boost::mutex::scoped_lock lock(log().mutex());
    log() << "modifyABCDVarROD (all modules, all chips) " << type << " " << value << " Banks: ";
    printBanks(banks, log());
    log() << endl;
  }

  boost::shared_ptr<PrimListWrapper> primList(new PrimListWrapper(1));
#if (R_RW_MODULE_DATA < 103 ) 
#warning "older version of RwModuleVariable may be slower"
  std::cout << "using old version of RwModuleVariable - may be slower" << std::endl;
  for (list<BankType>::const_iterator bank_iterator=banks.begin(); bank_iterator!=banks.end(); ++bank_iterator){
    BankType bank_type=*bank_iterator;
    int realBank = Utility::translateBank(bank_type);    
    PrimBuilder::instance().writeModuleVariable(primList, realBank, MODULE_GROUP_ALL, 
                        ALL_MODULES, ALL_CHIPS, type, value);
  }
#else
  UINT32 real_banks_bits = Utility::translateApiBanksToRodCfgBitSet(banks);
  PrimBuilder::instance().writeModuleVariable(primList, real_banks_bits, MODULE_GROUP_ALL,
                          ALL_MODULES, ALL_CHIPS, type, value);
  
#endif
  for(list<RodLabel>::const_iterator rl = rodList.begin();
      rl!=rodList.end();
      rl++){
    
    unsigned int rod = rl->rod;
    
    if(!isRODPresent(rod)) {
      std::cout << "Trying to change module configuration on a non existant ROD\n";
      if(mrs) {
    *mrs << "ROD_UNCONFIGURED" << MRS_ERROR << MRS_QUALIF("SCTAPI") 
         << MRS_PARAM<int>("rod", rod)
         << MRS_TEXT("Can't modify module config (ROD non-existant)") << ENDM;
      }else{
    std::cout << "ERROR - Rod " << rod << " does not exist" << std::endl;
      } 
      return;
    }
    sendPrimList(rod, primList);
    if (awaitResponse(rod, 2)!=0){
      if (mrs){
    *mrs << "MODIFY_VAR_ERROR" << MRS_ERROR << MRS_QUALIF("SCTAPI")
         << MRS_PARAM<int>("rod",rod)
         << MRS_TEXT("Error setting ABCDVariable on all modules") << ENDM;
      }else{
    std::cout << "ERROR in response from ROD " << rod << " modifying variable all modules" << std::endl;
      }
      return;
    }
  }

  // update cache
  for(map<UINT32, ABCDModule>::const_iterator iter = moduleMap.begin(); iter != moduleMap.end(); iter ++) {
      UINT32 mid = iter->first;
      boost::shared_ptr<SctApiConfigCache::ModuleBanks> the_banks=module_cache.getFromMid(mid);
      if (!the_banks.get()) {
    if(mrs) {
      *mrs << "ROD_BANK_CONFIG_CACHE" << MRS_ERROR << MRS_QUALIF("SCTAPI") 
           << MRS_PARAM<int>("mid", mid)
           << MRS_TEXT("Cant update cache for non-existant MID") << ENDM;
    }else{
      std::cout << "Cant update cache for non-existant MID "<< mid << endl;
    }
    return;
      }
      for (list<BankType>::const_iterator bank_iterator=banks.begin(); bank_iterator!=banks.end(); ++bank_iterator){
    boost::shared_ptr<ABCDModule> cached_config = the_banks->get(*bank_iterator);
    if (!cached_config.get()){
      if(mrs) {
        *mrs << "ROD_BANK_CONFIG_CACHE" << MRS_ERROR << MRS_QUALIF("SCTAPI") 
         << MRS_PARAM<int>("mid", mid)
         << MRS_PARAM<int>("bank", *bank_iterator)
         << MRS_TEXT("Cant update cache for non-existant BANK") << ENDM;
      }else{
        std::cout << "Cant update cache for non-existant BANK " << *bank_iterator << endl;
      }
      return;
    }
    ConfigUtility::modifyVar(cached_config.get(), type, value); 
      }
  }
}

} // Close namespace

---