ota.hpp

Go to the documentation of this file.

/*
 *  SatNOGS-COMMS MCU software
 *
 *  Copyright (C) 2025, Libre Space Foundation <http://libre.space>
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 *  SPDX-License-Identifier: GNU General Public License v3.0 or later
 */
 
#pragma once
 
#include <time.hpp>
#include <zephyr/kernel.h>
 
namespace satnogs::comms
{

class ota
{
public:
  static constexpr size_t MAX_FILE_LEN = 64;
 
  static constexpr const char *LITTLEFS_MCU_DIR  = "/SD/ota-mcu/";
  static constexpr const char *LITTLEFS_FPGA_DIR = "/SD/ota-fpga/";
 
  static ota &
  get_instance()
  {
    static ota instance;
    return instance;
  }
 
  ota(ota const &) = delete;
 
  void
  operator=(ota const &) = delete;

  enum class subsys : uint8_t
  {
    MCU_SLOT0, 
    MCU_SLOT1, 
    FPGA_WIC, 
    MCU_LITTLEFS, 
    FPGA_LITTLEFS 
  };
 
  enum class status : uint8_t
  {
    OK,
    INVALID_SEQ,
    INVALID_SESSION,
    INVALID_DST,
    INVALID_SLOT,
    INVALID_HASH,
    INVALID_SIZE,
    INVALID_STATE,
    INVALID_DATA,
    NO_SESSIONS_LEFT,
    FIN_OPERATION_PENDING,
    INTERNAL_ERROR,
    CURRENT_IMG_NOT_CONFIRMED
  };
 
  class start_tlc
  {
  public:
    subsys                    dst;
    uint32_t                  crc;
    uint32_t                  size;
    uint8_t                   slot;
    uint8_t                   sha256[32];
    etl::string<MAX_FILE_LEN> name;
 
    start_tlc() : dst(subsys::MCU_LITTLEFS), crc(0), size(0), slot(0), name() {}
  };
 
  class data_tlc
  {
  public:
    uint8_t        session;
    uint32_t       seq;
    const uint8_t *data;
    uint32_t       len;
    data_tlc() : session(255), seq(0), data(nullptr), len(0) {}
  };
 
  class fin_tlc
  {
  public:
    uint8_t  session;
    uint8_t  method;
    uint32_t delay_secs;
 
    fin_tlc() : session(0), method(0), delay_secs(0) {}
  };
 
  class response_tlm
  {
  public:
    uint8_t  session;
    status   s;
    uint32_t ack;
 
    response_tlm()
        : session(CONFIG_OTA_MAX_SESSIONS), s(status::INVALID_STATE), ack(0)
    {
    }
  };
 
  class session
  {
  public:
    /*
     * @warning This is a custom hash that is used to discriminate possible
     * changes of the session class Make sure to change it if you do ANY
     * modification in the class. With this way, the retention memory will
     * invalidate its contents avoiding conflicts with a firmware previously
     * stored session information
     */
    static constexpr size_t HASH = 0x6713A79;
    session()
        : destination(subsys::MCU_LITTLEFS),
          slot(0),
          active(false),
          applied(false),
          total_size(0U),
          ack(0U),
          time_src(time::time_src::UPTIME),
          t{},
          name(),
          sha256{}
    {
    }
 
    subsys                    destination;
    uint8_t                   slot;
    bool                      active;
    bool                      applied;
    uint32_t                  total_size;
    uint32_t                  ack;
    time::time_src            time_src;
    struct tm                 t;
    etl::string<MAX_FILE_LEN> name;
    uint8_t                   sha256[32];
  };
 
  void
  reset_session(uint32_t id);
 
  void
  reset_sessions();
 
  void
  start(const start_tlc &req, response_tlm &tlm);
 
  void
  recv(const data_tlc &tlc, response_tlm &tlm);
 
  void
  finalize(const fin_tlc &tlc, response_tlm &tlm, int wdgid);
 
  void
  confirm_image();
 
  bool
  get_session_info(uint8_t id, session &out) const;
 
  class inval_session : public lib::exception
  {
  public:
    inval_session(const char *file_name, int line)
        : exception(exception::severity::MINOR, file_name, line,
                    error_msg{"Invalid OTA session", "otainvalsession", EINVAL})
    {
    }
  };
 
protected:
  static constexpr size_t OTA_RETENTION_MEM_SIZE = 1752;
  ota();
 
private:
  std::array<session, CONFIG_OTA_MAX_SESSIONS> m_sessions;
  mutable struct k_mutex                       m_mtx;
 
  void
  reset_retention();
 
  void
  update_retention(uint32_t idx);
 
  status
  write_slot(session &s, const data_tlc &tlc);
 
  status
  write_wic(session &s, const data_tlc &tlc);
 
  status
  write_littlefs(bool mcu, session &s, const data_tlc &tlc);
 
  bool
  sha256_check(const session &s, int wdgid);
 
  bool
  sha256_littlefs(const session &s, const etl::istring &path, int wdgid);
 
  bool
  sha256_fpga_wic(const session &s, int wdgid);
 
  bool
  sha256_mcu(const session &s);
 
  bool
  finalize_littlefs_to_mcu(session &s, response_tlm &tlm);
 
  bool
  finalize_mcu(session &s, response_tlm &tlm);
};
 
} // namespace satnogs::comms