Add QCA chip reset

Signed-off-by: Cornelius Claussen <[email protected]>

lib/staging/slac/fsm/evse/include/slac/fsm/evse/context.hpp

@@ -27,6 +27,15 @@ template <> struct MMTYPE<slac::messages::cm_validate_cnf> {
 template <> struct MMTYPE<slac::messages::cm_slac_match_cnf> {
     static const uint16_t value = slac::defs::MMTYPE_CM_SLAC_MATCH | slac::defs::MMTYPE_MODE_CNF;
 };
+
+template <> struct MMTYPE<slac::messages::cm_reset_device_req> {
+    static const uint16_t value = slac::defs::MMTYPE_CM_RESET_DEVICE | slac::defs::MMTYPE_MODE_REQ;
+};
+
+template <> struct MMTYPE<slac::messages::cm_reset_device_cnf> {
+    static const uint16_t value = slac::defs::MMTYPE_CM_RESET_DEVICE | slac::defs::MMTYPE_MODE_CNF;
+};
+
 } // namespace _context_detail
 
 struct ContextCallbacks {
@@ -54,6 +63,11 @@ struct EvseSlacConfig {
     // timeout for CM_SET_KEY.REQ
     int set_key_timeout_ms = 500;
 
+    // Settings CM_DEVICE_RESET.REQ
+    bool do_chip_reset = true;
+    int chip_reset_timeout_ms = 500;
+    int chip_reset_delay_ms = 100;
+
     // offset for adjusting the calculated sounding attenuation
     int sounding_atten_adjustment = 0;
 };
@@ -68,8 +82,10 @@ struct Context {
     slac::messages::HomeplugMessage slac_message_payload;
 
     // FIXME (aw): message should be const, but libslac doesn't allow for const ptr - needs changes in libslac
-    template <typename SlacMessageType> void send_slac_message(const uint8_t* mac, SlacMessageType& message) {
+    template <typename SlacMessageType>
+    void send_slac_message(const uint8_t* mac, SlacMessageType& message, int protocol_version = 1) {
         slac::messages::HomeplugMessage hp_message;
+        hp_message.set_protocol_version(protocol_version);
         hp_message.setup_ethernet_header(mac);
         hp_message.setup_payload(&message, sizeof(message), _context_detail::MMTYPE<SlacMessageType>::value);
         callbacks.send_raw_slac(hp_message);

lib/staging/slac/fsm/evse/include/slac/fsm/evse/states/others.hpp

@@ -21,6 +21,21 @@ struct ResetState : public FSMSimpleState {
     bool setup_has_been_send{false};
 };
 
+struct ResetChipState : public FSMSimpleState {
+    using FSMSimpleState::FSMSimpleState;
+
+    HandleEventReturnType handle_event(AllocatorType&, Event) final;
+
+    void enter() final;
+    CallbackReturnType callback() final;
+
+    // for now returns true if CM_RESET_CNF is received
+    bool handle_slac_message(slac::messages::HomeplugMessage&);
+
+    bool reset_delay_done{false};
+    bool chip_reset_has_been_sent{false};
+};
+
 struct IdleState : public FSMSimpleState {
     using FSMSimpleState::FSMSimpleState;
 

lib/staging/slac/fsm/evse/src/states/others.cpp

@@ -32,9 +32,16 @@ void ResetState::enter() {
 }
 
 FSMSimpleState::HandleEventReturnType ResetState::handle_event(AllocatorType& sa, Event ev) {
+    const auto& cfg = ctx.slac_config;
     if (ev == Event::SLAC_MESSAGE) {
         if (handle_slac_message(ctx.slac_message_payload)) {
-            return sa.create_simple<IdleState>(ctx);
+            if (cfg.do_chip_reset) {
+                // If chip reset is enabled in config, go to ResetChipState and from there to IdleState
+                return sa.create_simple<ResetChipState>(ctx);
+            } else {
+                // If chip reset is disabled, go to IdleState directly
+                return sa.create_simple<IdleState>(ctx);
+            }
         } else {
             return sa.PASS_ON;
         }
@@ -76,6 +83,57 @@ bool ResetState::handle_slac_message(slac::messages::HomeplugMessage& message) {
     }
 }
 
+void ResetChipState::enter() {
+    ctx.log_info("Entered HW Chip Reset state");
+}
+
+FSMSimpleState::HandleEventReturnType ResetChipState::handle_event(AllocatorType& sa, Event ev) {
+    if (ev == Event::SLAC_MESSAGE) {
+        if (handle_slac_message(ctx.slac_message_payload)) {
+            return sa.create_simple<IdleState>(ctx);
+        } else {
+            return sa.PASS_ON;
+        }
+    } else {
+        return sa.PASS_ON;
+    }
+}
+
+FSMSimpleState::CallbackReturnType ResetChipState::callback() {
+    const auto& cfg = ctx.slac_config;
+    if (not reset_delay_done) {
+        reset_delay_done = true;
+        return cfg.chip_reset_delay_ms;
+    } else if (chip_reset_has_been_sent == false) {
+        slac::messages::cm_reset_device_req set_reset_req;
+
+        ctx.log_info("Resetting HW Chip using RS_DEV.REQ");
+
+        // RS_DEV.REQ is on protocol version 0
+        ctx.send_slac_message(cfg.plc_peer_mac, set_reset_req, 0);
+
+        chip_reset_has_been_sent = true;
+
+        return cfg.chip_reset_timeout_ms;
+    } else {
+        ctx.log_info("RS_DEV.REQ timeout, no response received - failed to reset the chip");
+        return {};
+    }
+}
+
+bool ResetChipState::handle_slac_message(slac::messages::HomeplugMessage& message) {
+    const auto mmtype = message.get_mmtype();
+    if (mmtype != (slac::defs::MMTYPE_CM_RESET_DEVICE | slac::defs::MMTYPE_MODE_CNF)) {
+        // unexpected message
+        // FIXME (aw): need to also deal with CM_VALIDATE.REQ
+        ctx.log_info("Received non-expected SLAC message of type " + format_mmtype(mmtype));
+        return false;
+    } else {
+        ctx.log_info("Received CM_RESET_CNF");
+        return true;
+    }
+}
+
 void IdleState::enter() {
     ctx.signal_state("UNMATCHED");
     ctx.log_info("Entered Idle state");

lib/staging/slac/io/src/io.cpp

@@ -33,6 +33,7 @@ void SlacIO::loop() {
 
     while (running) {
         if (slac_channel.read(incoming_msg, 10)) {
+            incoming_msg.set_protocol_version_from_rawmsg();
             input_handler(incoming_msg);
         }
     }

modules/EvseSlac/CMakeLists.txt

@@ -19,7 +19,6 @@ target_link_libraries(${MODULE_NAME}
         slac::io
         slac::fsm::evse
 )
-
 # ev@bcc62523-e22b-41d7-ba2f-825b493a3c97:v1
 
 target_sources(${MODULE_NAME}

modules/EvseSlac/main/slacImpl.cpp

@@ -84,6 +84,11 @@ void slacImpl::run() {
     fsm_ctx.slac_config.set_key_timeout_ms = config.set_key_timeout_ms;
     fsm_ctx.slac_config.ac_mode_five_percent = config.ac_mode_five_percent;
     fsm_ctx.slac_config.sounding_atten_adjustment = config.sounding_attenuation_adjustment;
+
+    fsm_ctx.slac_config.do_chip_reset = config.do_chip_reset;
+    fsm_ctx.slac_config.chip_reset_delay_ms = config.chip_reset_delay_ms;
+    fsm_ctx.slac_config.chip_reset_timeout_ms = config.chip_reset_timeout_ms;
+
     fsm_ctx.slac_config.generate_nmk();
 
     fsm_ctrl = std::make_unique<FSMController>(fsm_ctx);

modules/EvseSlac/main/slacImpl.hpp

@@ -29,6 +29,9 @@ struct Conf {
     int sounding_attenuation_adjustment;
     bool publish_mac_on_match_cnf;
     bool publish_mac_on_first_parm_req;
+    bool do_chip_reset;
+    int chip_reset_delay_ms;
+    int chip_reset_timeout_ms;
 };
 
 class slacImpl : public slacImplBase {

modules/EvseSlac/manifest.yaml

@@ -46,6 +46,18 @@ provides:
           It is better to wait for the matching to be done.
         type: boolean
         default: false
+      do_chip_reset:
+        description: Perform a chip reset after setting NMK using the RS_DEV.REQ Vendor MME Extension (QCA7k)
+        type: boolean
+        default: false
+      chip_reset_delay_ms:
+        description: Delay between SET_KEY.CNF and RS_DEV.REQ
+        type: integer
+        default: 100
+      chip_reset_timeout_ms:
+        description: Timeout for RS_DEV.REQ (waiting for RS_DEV.CNF)
+        type: integer
+        default: 500
 metadata:
   base_license: https://directory.fsf.org/wiki/License:BSD-3-Clause-Clear
   license: https://opensource.org/licenses/Apache-2.0