Add trace option to spi

Author: engdoreis

app/main.cc

@@ -39,6 +39,7 @@ new_flash_command(const std::string& name, const std::string& desc) {
   auto cmd = std::make_unique<argparse::ArgumentParser>(name);
   cmd->add_description(desc);
   cmd->add_argument("--interface", "-i").help("One of [spi, i2c, gpio]");
+  cmd->add_argument("--traces", "-t").help("Enable ftdi traces").default_value(false).implicit_value(true);
   cmd->add_argument("--ftdi")
       .default_value(std::string("FT4222"))
       .help("Filter ftdi chips connected to USB");
@@ -48,13 +49,15 @@ new_flash_command(const std::string& name, const std::string& desc) {
 static std::optional<ftdi::SpiHost>
 handle_flash_command(std::unique_ptr<argparse::ArgumentParser>& cmd) {
   auto ftdi     = cmd->get<std::string>("--ftdi");
+  auto traces     = cmd->get<bool>("--traces");
   auto devices  = scan();
   auto filtered = ftdi::DeviceInfo::filter_by_description(devices, ftdi);
   if (filtered.empty()) {
     std::print("No supported ftdi found.\n");
     exit(0);
   }
   if (auto opt = ftdi::SpiHost::from_device_info(filtered[0])) {
+    opt->with_traces(traces);
     return opt;
   }
   std::println("Can't open spi.");

lib/flash/flash.hh

@@ -83,7 +83,8 @@ class Generic {
   }
 
   Option<Sfdp> sfdp() {
-    std::array<uint8_t, 5 + sizeof(Sfdp)> cmd = {Opcode::ReadSfdp, 0x00, 0x00, 0x00, 0x00};
+    std::array<uint8_t, 5 + sizeof(Sfdp)> cmd = {Opcode::ReadSfdp, 0x00, 0x00, 0x00,
+                                                 0xDB};  // DB=DummyByte
 
     std::span<uint8_t> ret = TRY_OPT(spih.transfer(cmd));
     return Sfdp::try_from(ret.subspan(5));

lib/ftdi/log.hh

@@ -14,7 +14,7 @@ struct std::formatter<std::array<uint8_t, N>> : std::formatter<std::string_view>
 
   auto format(const std::array<uint8_t, N>& arr, format_context& ctx) const {
     auto out = ctx.out();
-    out      = std::format_to(out, "Array<uint8_t, {} >: {{", N);
+    out      = std::format_to(out, "Array<{}>: {{", N);
 
     for (std::size_t i = 0; i < N; ++i) {
       out = std::format_to(out, "{:02x}", arr[i]);
@@ -32,7 +32,7 @@ struct std::formatter<std::span<uint8_t, N>> : std::formatter<std::string_view>
 
   auto format(const std::span<uint8_t, N>& arr, format_context& ctx) const {
     auto out = ctx.out();
-    out      = std::format_to(out, "Span<uint8_t, {} >: {{", N);
+    out      = std::format_to(out, "Span<{}>: {{", N);
 
     for (std::size_t i = 0; i < N; ++i) {
       out = std::format_to(out, "{:02x}", arr[i]);
@@ -50,7 +50,7 @@ struct std::formatter<std::span<uint8_t>> : std::formatter<std::string_view> {
 
   auto format(const std::span<uint8_t>& arr, format_context& ctx) const {
     auto out = ctx.out();
-    out      = std::format_to(out, "Span<uint8_t, {}> = {{", arr.size());
+    out      = std::format_to(out, "Span<{}> = {{", arr.size());
 
     for (std::size_t i = 0; i < arr.size(); ++i) {
       out = std::format_to(out, "{:02x}", arr[i]);
@@ -68,7 +68,7 @@ struct std::formatter<std::vector<uint8_t>> : std::formatter<std::string_view> {
 
   auto format(const std::vector<uint8_t>& arr, format_context& ctx) const {
     auto out = ctx.out();
-    out      = std::format_to(out, "Vector<uint8_t, {}> = {{", arr.size());
+    out      = std::format_to(out, "Vector<{}> = {{", arr.size());
 
     for (std::size_t i = 0; i < arr.size(); ++i) {
       out = std::format_to(out, "{:02x}", arr[i]);

lib/ftdi/spi_host.cc

@@ -17,6 +17,7 @@
 namespace ftdi {
 embeddedpp::Result<std::span<uint8_t>> SpiHost::transfer(std::span<uint8_t> payload) {
   uint16_t received = 0;
+  log("SPI -->> {}", payload);
 
   FT4222_SPIMaster_SetLines(handle, SPI_IO_SINGLE);
 
@@ -32,7 +33,7 @@ embeddedpp::Result<std::span<uint8_t>> SpiHost::transfer(std::span<uint8_t> payl
     std::cerr << std::format("Wrote only {}/{}\n", received, payload.size());
     return embeddedpp::Code::Generic;
   }
-
+  log("SPI <<-- {}", payload);
   return payload;
 }
 
@@ -96,13 +97,15 @@ embeddedpp::Status SpiHost::transaction(embeddedpp::Transfers transfers) {
     return embeddedpp::Code::Generic;
   }
 
+  log("SPI -->> {}", payload);
   status =
       FT4222_SPIMaster_MultiReadWrite(handle, rd_buffer.data(), payload.data(), single_bytes_wr,
                                       multi_bytes_wr, multi_bytes_rd, &received);
   if (FT4222_OK != status) {
     std::cerr << std::format("MultiReadWrite:{}\n", status);
     return embeddedpp::Code::Generic;
   }
+  log("SPI <<-- {}", rd_buffer);
 
   return embeddedpp::Code::Ok;
 };

lib/ftdi/spi_host.hh

@@ -21,9 +21,10 @@ using Result = std::optional<std::span<uint8_t>>;
 
 class SpiHost {
   FT_HANDLE handle;
+  bool traces = false;
 
  public:
-  explicit SpiHost(FT_HANDLE handle) noexcept : handle(handle) {}
+  explicit SpiHost(FT_HANDLE handle) noexcept : handle(handle), traces(false) {}
   ~SpiHost() { FT_Close(handle); }
 
   embeddedpp::Result<std::span<uint8_t>> transfer(std::span<uint8_t> payload);
@@ -34,6 +35,16 @@ class SpiHost {
 
   Result read(uint32_t size, bool deassert_cs = true);
 
+  void with_traces(bool enable) { traces = enable; };
+
   static std::optional<SpiHost> from_device_info(DeviceInfo& device);
+
+ private:
+  template <typename... Args>
+  void log(std::format_string<Args...> fmt, Args&&... args) {
+    if (this->traces) {
+      std::println(fmt, std::forward<Args>(args)...);
+    }
+  }
 };
 }  // namespace ftdi