Diff: xDotBridge/src/BaseboardIO.cpp

Revision:

55:79ab0bbc5008

Parent:

53:a1563574a980

Child:

56:40b454c952cc

--- a/xDotBridge/src/BaseboardIO.cpp	Wed Feb 22 15:39:40 2017 -0700
+++ b/xDotBridge/src/BaseboardIO.cpp	Mon Feb 27 08:06:36 2017 -0700
@@ -7,6 +7,7 @@
 
 #include "BaseboardIO.h"
 #include "MTSLog.h"
+#include "dot_util.h" // FIXME just need the reference to dot somehow
 
 const float COIL_ON_TIME = 0.030; // 30 ms
 
@@ -46,12 +47,6 @@
       mLed(GPIO0),
       mSwitchedIOCtrl(I2C_SCL, 0)
 {
-//    mCCInIntCallback = NULL;
-//    mTamperIntCallback = NULL;
-//    mPairBtnIntCallback = NULL;
-
-    std::memset(mPortExpanderROM0, 0x00, 8);
-    std::memset(mPortExpanderROM1, 0x00, 8);
     mPortExpanderVal0 = 0x00;
     mPortExpanderVal1 = 0x00;
 
@@ -62,19 +57,43 @@
 {
     // Setup port expanders
     if (readInfoFromNVM() == cmdSuccess) {
-        // Values stored just read them foo
-        logError("Not implemented yet!!!");
+        logInfo("Stored ROM0 Addr: %02x:%02x:%02x:%02x:%02x:%02x:%02x%02x found.",
+                mNvmObj.mPortExpanderROM0[7],
+                mNvmObj.mPortExpanderROM0[6],
+                mNvmObj.mPortExpanderROM0[5],
+                mNvmObj.mPortExpanderROM0[4],
+                mNvmObj.mPortExpanderROM0[3],
+                mNvmObj.mPortExpanderROM0[2],
+                mNvmObj.mPortExpanderROM0[1],
+                mNvmObj.mPortExpanderROM0[0]);
+        logInfo("Stored ROM1 Addr: %02x:%02x:%02x:%02x:%02x:%02x:%02x%02x found.",
+                mNvmObj.mPortExpanderROM1[7],
+                mNvmObj.mPortExpanderROM1[6],
+                mNvmObj.mPortExpanderROM1[5],
+                mNvmObj.mPortExpanderROM1[4],
+                mNvmObj.mPortExpanderROM1[3],
+                mNvmObj.mPortExpanderROM1[2],
+                mNvmObj.mPortExpanderROM1[1],
+                mNvmObj.mPortExpanderROM1[0]);
+        logInfo("BaseboardIO parameters successfully loaded from NVM");
     }
     else { // EEPROM values not there or corrupt.  Should only happen in factory.
+        mNvmObj.setDefaults();
         // Find ROM address and test which one is which.  Requires user
         // switches to be in known state.
         if (identifyPortExpanders() != cmdSuccess) {
             logError("Error identifying port expanders");
             return cmdError;
         }
+        if (writeInfoToNVM() == cmdSuccess) {
+            logInfo("Baseboard config saved to NVM");
+        }
+        else {
+            logError("Baseboard config failed to save to NVM");
+        }
     }
-    mPortEx0 = new DS2408(&mOWMaster, mPortExpanderROM0);
-    mPortEx1 = new DS2408(&mOWMaster, mPortExpanderROM1);
+    mPortEx0 = new DS2408(&mOWMaster, mNvmObj.mPortExpanderROM0);
+    mPortEx1 = new DS2408(&mOWMaster, mNvmObj.mPortExpanderROM1);
 
     // Put relay in known state
     if (relayNormal() != cmdSuccess) {
@@ -277,13 +296,37 @@
 // private
 CmdResult BaseboardIO::readInfoFromNVM()
 {
-    logError("Not implemented yet!!!");
-    return cmdError;
+    bool nvmReadResult;
+    uint8_t *data = new uint8_t [BASEBOARDIO_NVM_SIZE];
+
+    nvmReadResult = dot->nvmRead(BASEBOARDIO_NVM_START_ADDR, data, BASEBOARDIO_NVM_SIZE);
+    if (!nvmReadResult) {
+        delete [] data;
+        return cmdError;
+    }
+    mNvmObj.fromBytes(data, BASEBOARDIO_NVM_SIZE);
+    delete [] data;
+    if (!mNvmObj.validBaseboardIOFlag()) {
+        logWarning("Invalid BaseboardIO Flag.  Using default values.");
+        return cmdError;
+    }
+    else if (!mNvmObj.validBaseboardIORev()) {
+        logWarning("Invalid BaseboardIO Rev.  Using default values.");
+        return cmdError;
+    }
+    else {
+        return cmdSuccess;
+    }
 }
 CmdResult BaseboardIO::writeInfoToNVM()
 {
-    logError("Not implemented yet!!!");
-    return cmdError;
+    uint8_t *data = new uint8_t [BASEBOARDIO_NVM_SIZE];
+    uint8_t size = BASEBOARDIO_NVM_SIZE;
+    mNvmObj.toBytes(data, size);
+    dot->nvmWrite(BASEBOARDIO_NVM_START_ADDR, data, BASEBOARDIO_NVM_SIZE);
+
+    delete [] data;
+    return cmdSuccess;
 }
 CmdResult BaseboardIO::identifyPortExpanders()
 {
@@ -308,10 +351,10 @@
             logInfo("ROM Addr: %02x:%02x:%02x:%02x:%02x:%02x:%02x%02x found.",
                     addr[7],addr[6],addr[5],addr[4],addr[3],addr[2],addr[1],addr[0]);
             if (i == 0) {
-                std::memcpy(mPortExpanderROM0, addr, sizeof(mPortExpanderROM0));
+                std::memcpy(mNvmObj.mPortExpanderROM0, addr, sizeof(mNvmObj.mPortExpanderROM0));
             }
             else if (i == 1) {
-                std::memcpy(mPortExpanderROM1, addr, sizeof(mPortExpanderROM1));
+                std::memcpy(mNvmObj.mPortExpanderROM1, addr, sizeof(mNvmObj.mPortExpanderROM1));
             }
             i++;
         }
@@ -331,8 +374,8 @@
     // If switches are set in factory default mode then port expander 1 should read 0xFF and
     // port expander 2 should read 0xF0.
 
-    mPortEx0 = new DS2408(&mOWMaster, mPortExpanderROM0);
-    mPortEx1 = new DS2408(&mOWMaster, mPortExpanderROM1);
+    mPortEx0 = new DS2408(&mOWMaster, mNvmObj.mPortExpanderROM0);
+    mPortEx1 = new DS2408(&mOWMaster, mNvmObj.mPortExpanderROM1);
 
 
     enableSwitchedIO();
@@ -356,14 +399,14 @@
         logInfo("ROMS Swap Not Needed.");
     }
     else if ((mPortExpanderVal0 == 0xF0) and (mPortExpanderVal1 == 0xFF)) { // Just need to swap
-        std::memcpy(addr, mPortExpanderROM0, sizeof(addr)); // Store Orig ROM0 -> addr
-        std::memcpy(mPortExpanderROM0, mPortExpanderROM1, sizeof(mPortExpanderROM0)); // Store Orig ROM1 -> ROM0
-        std::memcpy(mPortExpanderROM1, addr, sizeof(mPortExpanderROM1)); // Store Orig ROM0 (addr) -> ROM1
+        std::memcpy(addr, mNvmObj.mPortExpanderROM0, sizeof(addr)); // Store Orig ROM0 -> addr
+        std::memcpy(mNvmObj.mPortExpanderROM0, mNvmObj.mPortExpanderROM1, sizeof(mNvmObj.mPortExpanderROM0)); // Store Orig ROM1 -> ROM0
+        std::memcpy(mNvmObj.mPortExpanderROM1, addr, sizeof(mNvmObj.mPortExpanderROM1)); // Store Orig ROM0 (addr) -> ROM1
         logInfo("Swapped ROMS.");
     }
     else {
         logError("Error during port expander ID.  Port expanders not in "
-                "expected states.  Check user switches.  Got %02X and %02X",
+                "expected states (0xFF and 0xF0).  Check user switches.  Got %02X and %02X",
                 mPortExpanderVal0, mPortExpanderVal1);
         delete mPortEx0;
         delete mPortEx1;
@@ -432,3 +475,97 @@
 
     return cmdSuccess;
 }
+
+// NvmBBIOObj
+NvmBBIOObj::NvmBBIOObj()
+{
+    setDefaults();
+}
+void NvmBBIOObj::setDefaults()
+{
+    mBaseboardIOFlag = BASEBOARDIO_FLAG;
+    mBaseboardIORev  = BASEBOARDIO_REV;
+    mSerialNum = 0x0000;
+    mBaseboardIOConfig = 0x0000;
+    std::memset(mPortExpanderROM0, 0x00, 8);
+    std::memset(mPortExpanderROM1, 0x00, 8);
+}
+CmdResult NvmBBIOObj::fromBytes(uint8_t *data, uint8_t size)
+{
+    if (size != BASEBOARDIO_NVM_SIZE) {
+        return cmdError;
+    }
+
+    mBaseboardIOFlag    = *((uint16_t *) (data));
+    mBaseboardIORev     = *((uint16_t *) (data+2));
+    mSerialNum          = *((uint32_t *) (data+4));
+    mBaseboardIOConfig  = *((uint32_t *) (data+6));
+
+    std::memcpy(&mPortExpanderROM0, data+0x10, 8);
+    std::memcpy(&mPortExpanderROM1, data+0x18, 8);
+
+    return cmdSuccess;
+}
+CmdResult NvmBBIOObj::toBytes(uint8_t *data, uint8_t &size) {
+    // TODO check data size
+
+    *((uint16_t *) (data))   = mBaseboardIOFlag;
+    *((uint16_t *) (data+2)) = mBaseboardIORev;
+    *((uint32_t *) (data+4)) = mSerialNum;
+    *((uint32_t *) (data+6)) = mBaseboardIOConfig;
+
+    std::memcpy(data+0x10, &mPortExpanderROM0, 8);
+    std::memcpy(data+0x18, &mPortExpanderROM1, 8);
+
+    size = BASEBOARDIO_NVM_SIZE;
+
+    return cmdSuccess;
+}
+uint16_t NvmBBIOObj::getBaseboardIOFlag()
+{
+    return mBaseboardIOFlag;
+}
+bool NvmBBIOObj::validBaseboardIOFlag()
+{
+    return mBaseboardIOFlag == BASEBOARDIO_FLAG;
+}
+uint16_t NvmBBIOObj::getBaseboardIORev()
+{
+    return mBaseboardIORev;
+}
+bool NvmBBIOObj::validBaseboardIORev()
+{
+    return mBaseboardIORev == BASEBOARDIO_REV;
+}
+uint16_t NvmBBIOObj::getSerialNum()
+{
+    return mSerialNum;
+}
+void NvmBBIOObj::setSerialNum(uint16_t in)
+{
+    mSerialNum = in;
+}
+uint32_t NvmBBIOObj::getBaseboardIOConfig()
+{
+    return mBaseboardIOConfig;
+}
+void NvmBBIOObj::setBaseboardIOConfig(uint32_t in)
+{
+    mBaseboardIOConfig = in;
+}
+void NvmBBIOObj::getPortExpanderROM0(uint8_t *addr)
+{
+    std::memcpy(addr, &mPortExpanderROM0, 8);
+}
+void NvmBBIOObj::setPortExpanderROM0(const uint8_t *addr)
+{
+    std::memcpy(&mPortExpanderROM0, addr, 8);
+}
+void NvmBBIOObj::getPortExpanderROM1(uint8_t *addr)
+{
+    std::memcpy(addr, &mPortExpanderROM1, 8);
+}
+void NvmBBIOObj::setPortExpanderROM1(const uint8_t *addr)
+{
+    std::memcpy(&mPortExpanderROM1, addr, 8);
+}