usb_selftest_dfu_steps.c

Go to the documentation of this file.

 
#include "usb_selftest_dfu_steps.h"
 
#include <stdint.h>
#include <string.h>
 
#include "ra8_board_ek_ra8d2.h"
#include "ra8_err.h"
#include "ra8_time.h"
#include "ra8_usb.h"
 
#ifndef RA8_OFF_TARGET
 
/* -------------------------------------------------------------------------- */
/* J-Link probes (host ladder) */
/* -------------------------------------------------------------------------- */

static volatile uint32_t s_dbg_phase;
static volatile uint32_t s_dbg_pid;
static volatile uint32_t s_dbg_blocks_ok;
static volatile uint32_t s_dbg_mismatch = (uint32_t)k_dfu_no_mismatch;
static volatile uint32_t s_dbg_pass_count;
 
/* -------------------------------------------------------------------------- */
/* Shared per-block pattern */
/* -------------------------------------------------------------------------- */

static void dfu_pattern_fill(uint32_t block, uint8_t* out, uint32_t len)
{
  for (uint32_t i = 0U; i < len; i++) {
    const uint32_t v = (block * (uint32_t)k_dfu_pat_blk_mul) + (i * (uint32_t)k_dfu_pat_idx_mul) +
                       (uint32_t)k_dfu_pat_bias;
    out[i]           = (uint8_t)(v & (uint32_t)k_dfu_byte_mask);
  }
}
 
/* -------------------------------------------------------------------------- */
/* Console helpers (SCI8 -> J-Link OB CDC) */
/* -------------------------------------------------------------------------- */

static uint8_t dfu_nibble_to_hex(uint32_t nibble)
{
  if (nibble < k_dfu_hex_digit_split) {
    return (uint8_t)((uint8_t)'0' + (uint8_t)nibble);
  }
  return (uint8_t)((uint8_t)'A' + (uint8_t)nibble - (uint8_t)k_dfu_hex_digit_split);
}

static uint32_t dfu_str_len(const char* text)
{
  uint32_t len = 0U;
  while (len < (uint32_t)k_dfu_print_cap) {
    if (text[len] == '\0') {
      break;
    }
    len++;
  }
  return len;
}

[[nodiscard]] static ra8_err_t dfu_sci_write(const uint8_t* data, uint32_t len)
{
  return ra8_board_uart_console_write(data, (size_t)len);
}

[[nodiscard]] static ra8_err_t dfu_print(const char* text)
{
  return dfu_sci_write((const uint8_t*)text, dfu_str_len(text));
}

[[nodiscard]] static ra8_err_t dfu_print_hex(uint32_t value, uint8_t digits)
{
  uint8_t out[k_dfu_hex_chars_u32] = {};
  uint8_t width                    = digits;
  if (width > (uint8_t)k_dfu_hex_chars_u32) {
    width = (uint8_t)k_dfu_hex_chars_u32;
  }
  for (uint8_t i = 0U; i < width; i++) {
    const uint8_t shift = (uint8_t)((width - 1U - i) * k_dfu_nibble_bits);
    out[i]              = dfu_nibble_to_hex((value >> shift) & k_dfu_nibble_mask);
  }
  return dfu_sci_write(out, (uint32_t)width);
}

[[nodiscard]] static ra8_err_t dfu_print_dec(uint32_t value)
{
  uint8_t  scratch[k_dfu_dec_chars_u32] = {};
  uint8_t  out[k_dfu_dec_chars_u32]     = {};
  uint8_t  count                        = 0U;
  uint32_t v                            = value;
  if (v == 0U) {
    out[0] = (uint8_t)'0';
    return dfu_sci_write(out, 1U);
  }
  while (v != 0U) {
    if (count >= (uint8_t)k_dfu_dec_chars_u32) {
      break;
    }
    scratch[count] = (uint8_t)((uint8_t)'0' + (uint8_t)(v % k_dfu_dec_radix));
    v              = v / k_dfu_dec_radix;
    count++;
  }
  for (uint8_t i = 0U; i < count; i++) {
    out[i] = scratch[count - 1U - i];
  }
  return dfu_sci_write(out, (uint32_t)count);
}

[[nodiscard]] static ra8_err_t dfu_print_fail(const char* what, ra8_err_t err)
{
  ra8_err_t e = dfu_print("ra8d2 dfu: FAIL ");
  if (e != k_ra8_ok) {
    return e;
  }
  e = dfu_print(what);
  if (e != k_ra8_ok) {
    return e;
  }
  e = dfu_print(" err=0x");
  if (e != k_ra8_ok) {
    return e;
  }
  e = dfu_print_hex((uint32_t)err, (uint8_t)k_dfu_hex_chars_u32);
  if (e != k_ra8_ok) {
    return e;
  }
  return dfu_print("\r\n");
}
 
/* -------------------------------------------------------------------------- */
/* Host side: enumerate, then DFU download + upload-verify */
/* -------------------------------------------------------------------------- */

[[nodiscard]] static ra8_err_t dfu_ctrl_get_dev_desc(uint8_t* desc)
{
  const ra8_usb_setup_t setup = {
    .bm_request_type = (uint8_t)k_dfu_bm_std_dev_in,
    .b_request       = (uint8_t)k_dfu_breq_get_desc,
    .w_value         = (uint16_t)((uint16_t)k_dfu_desc_device << (uint16_t)k_dfu_byte_bits),
    .w_index         = 0U,
    .w_length        = (uint16_t)k_dfu_dev_desc_len,
  };
  uint16_t        rx = 0U;
  const ra8_err_t err =
    ra8_usb_host_control_xfer(k_ra8_usb_speed_hs, &setup, desc, (uint16_t)k_dfu_dev_desc_len, &rx);
  if (err != k_ra8_ok) {
    return err;
  }
  return (rx == (uint16_t)k_dfu_dev_desc_len) ? k_ra8_ok : k_ra8_err_hw_error;
}

[[nodiscard]] static ra8_err_t dfu_enum_hunt(uint8_t* desc)
{
  ra8_delay_ms(k_dfu_vbus_settle_ms);
  const uint32_t t0 = ra8_time_ms();
  for (uint32_t spin = 0U; spin < (uint32_t)k_dfu_attach_spin; spin++) {
    if (ra8_usb_host_line_state(k_ra8_usb_speed_hs) != 0U) {
      break;
    }
    if ((ra8_time_ms() - t0) > (uint32_t)k_dfu_attach_to_ms) {
      break;
    }
  }
  ra8_delay_ms(k_dfu_debounce_ms);
  ra8_err_t err = k_ra8_err_hw_timeout;
  for (uint8_t attempt = 0U; attempt < (uint8_t)k_dfu_enum_tries; attempt++) {
    (void)ra8_usb_host_bus_reset(k_ra8_usb_speed_hs, true);
    ra8_delay_ms(k_dfu_reset_hold_ms);
    (void)ra8_usb_host_bus_reset(k_ra8_usb_speed_hs, false);
    (void)ra8_usb_host_set_uact(k_ra8_usb_speed_hs, true);
    ra8_delay_ms(k_dfu_recovery_ms);
    (void)ra8_usb_host_set_target(k_ra8_usb_speed_hs, 0U);
    err = dfu_ctrl_get_dev_desc(desc);
    if (err == k_ra8_ok) {
      return k_ra8_ok;
    }
  }
  return err;
}

[[nodiscard]] static ra8_err_t dfu_enum_set_address(void)
{
  const ra8_usb_setup_t setup = {
    .bm_request_type = (uint8_t)k_dfu_bm_std_dev_out,
    .b_request       = (uint8_t)k_dfu_breq_set_addr,
    .w_value         = (uint16_t)k_dfu_dev_addr,
    .w_index         = 0U,
    .w_length        = 0U,
  };
  const ra8_err_t err = ra8_usb_host_control_xfer(k_ra8_usb_speed_hs, &setup, nullptr, 0U, nullptr);
  if (err != k_ra8_ok) {
    return err;
  }
  ra8_delay_ms(k_dfu_addr_settle_ms);
  return ra8_usb_host_set_target(k_ra8_usb_speed_hs, (uint8_t)k_dfu_dev_addr);
}

[[nodiscard]] static ra8_err_t dfu_enum_set_config(void)
{
  const ra8_usb_setup_t setup = {
    .bm_request_type = (uint8_t)k_dfu_bm_std_dev_out,
    .b_request       = (uint8_t)k_dfu_breq_set_config,
    .w_value         = (uint16_t)k_dfu_config_val,
    .w_index         = 0U,
    .w_length        = 0U,
  };
  return ra8_usb_host_control_xfer(k_ra8_usb_speed_hs, &setup, nullptr, 0U, nullptr);
}

[[nodiscard]] static ra8_err_t dfu_getstatus(uint8_t* out_state)
{
  uint8_t               status[k_dfu_getstatus_len] = {};
  const ra8_usb_setup_t setup                       = {
    .bm_request_type = (uint8_t)k_dfu_bm_class_if_in,
    .b_request       = (uint8_t)k_dfu_breq_getstatus,
    .w_value         = 0U,
    .w_index         = (uint16_t)k_dfu_intf,
    .w_length        = (uint16_t)k_dfu_getstatus_len,
  };
  uint16_t        rx  = 0U;
  const ra8_err_t err = ra8_usb_host_control_xfer(k_ra8_usb_speed_hs,
                                                  &setup,
                                                  status,
                                                  (uint16_t)k_dfu_getstatus_len,
                                                  &rx);
  if (err != k_ra8_ok) {
    return err;
  }
  if (rx != (uint16_t)k_dfu_getstatus_len) {
    return k_ra8_err_hw_error;
  }
  *out_state = status[k_dfu_off_status_state];
  return k_ra8_ok;
}

[[nodiscard]] static ra8_err_t dfu_wait_state(uint8_t want_state)
{
  for (uint32_t i = 0U; i < (uint32_t)k_dfu_status_tries; i++) {
    uint8_t         state = 0U;
    const ra8_err_t err   = dfu_getstatus(&state);
    if (err != k_ra8_ok) {
      return err;
    }
    if (state == want_state) {
      return k_ra8_ok;
    }
    ra8_delay_ms(k_dfu_status_poll_ms);
  }
  return k_ra8_err_hw_timeout;
}

[[nodiscard]] static ra8_err_t dfu_dnload_block(uint16_t block, uint8_t* data, uint16_t len)
{
  const ra8_usb_setup_t setup = {
    .bm_request_type = (uint8_t)k_dfu_bm_class_if_out,
    .b_request       = (uint8_t)k_dfu_breq_dnload,
    .w_value         = block,
    .w_index         = (uint16_t)k_dfu_intf,
    .w_length        = len,
  };
  const ra8_err_t err = ra8_usb_host_control_xfer(k_ra8_usb_speed_hs, &setup, data, len, nullptr);
  if (err != k_ra8_ok) {
    return err;
  }
  return dfu_wait_state((uint8_t)k_dfu_state_dnload_idle);
}

[[nodiscard]] static ra8_err_t dfu_download_all(void)
{
  for (uint16_t b = 0U; b < (uint16_t)k_dfu_blocks; b++) {
    uint8_t block[k_dfu_xfer_size] = {};
    dfu_pattern_fill((uint32_t)b, block, (uint32_t)k_dfu_xfer_size);
    const ra8_err_t err = dfu_dnload_block(b, block, (uint16_t)k_dfu_xfer_size);
    if (err != k_ra8_ok) {
      return err;
    }
  }
  /* DFU_ABORT closes the download (dfuDNLOAD-IDLE -> dfuIDLE) without the
   * manifest's wait-for-reset, so the UPLOAD phase runs on the same device. */
  const ra8_usb_setup_t setup = {
    .bm_request_type = (uint8_t)k_dfu_bm_class_if_out,
    .b_request       = (uint8_t)k_dfu_breq_abort,
    .w_value         = 0U,
    .w_index         = (uint16_t)k_dfu_intf,
    .w_length        = 0U,
  };
  const ra8_err_t err = ra8_usb_host_control_xfer(k_ra8_usb_speed_hs, &setup, nullptr, 0U, nullptr);
  if (err != k_ra8_ok) {
    return err;
  }
  return dfu_wait_state((uint8_t)k_dfu_state_idle);
}

[[nodiscard]] static ra8_err_t dfu_upload_verify(void)
{
  s_dbg_blocks_ok = 0U;
  for (uint16_t b = 0U; b < (uint16_t)k_dfu_blocks; b++) {
    uint8_t               got[k_dfu_xfer_size] = {};
    const ra8_usb_setup_t setup                = {
      .bm_request_type = (uint8_t)k_dfu_bm_class_if_in,
      .b_request       = (uint8_t)k_dfu_breq_upload,
      .w_value         = b,
      .w_index         = (uint16_t)k_dfu_intf,
      .w_length        = (uint16_t)k_dfu_xfer_size,
    };
    uint16_t        rx = 0U;
    const ra8_err_t err =
      ra8_usb_host_control_xfer(k_ra8_usb_speed_hs, &setup, got, (uint16_t)k_dfu_xfer_size, &rx);
    if (err != k_ra8_ok) {
      return err;
    }
    if (rx != (uint16_t)k_dfu_xfer_size) {
      s_dbg_mismatch = (uint32_t)b;
      return k_ra8_err_invalid_size;
    }
    uint8_t want[k_dfu_xfer_size] = {};
    dfu_pattern_fill((uint32_t)b, want, (uint32_t)k_dfu_xfer_size);
    if (memcmp(got, want, (size_t)k_dfu_xfer_size) != 0) {
      s_dbg_mismatch = (uint32_t)b;
      return k_ra8_err_invalid_state;
    }
    s_dbg_blocks_ok++;
  }
  return k_ra8_ok;
}

[[nodiscard]] static ra8_err_t dfu_host_enumerate(void)
{
  s_dbg_phase                        = (uint32_t)k_dfu_phase_enum;
  uint8_t   desc[k_dfu_dev_desc_len] = {};
  ra8_err_t err                      = dfu_enum_hunt(desc);
  if (err != k_ra8_ok) {
    (void)dfu_print_fail("enumerate", err);
    (void)ra8_usb_host_deinit(k_ra8_usb_speed_hs);
    return err;
  }
  s_dbg_pid = (uint32_t)desc[k_dfu_off_dev_pid] |
              ((uint32_t)desc[(uint32_t)k_dfu_off_dev_pid + 1U] << (uint32_t)k_dfu_byte_bits);
  err       = dfu_enum_set_address();
  if (err != k_ra8_ok) {
    (void)dfu_print_fail("set_address", err);
    (void)ra8_usb_host_deinit(k_ra8_usb_speed_hs);
    return err;
  }
  err = dfu_enum_set_config();
  if (err != k_ra8_ok) {
    (void)dfu_print_fail("set_config", err);
    (void)ra8_usb_host_deinit(k_ra8_usb_speed_hs);
    return err;
  }
  err = dfu_print("ra8d2 dfu: enumerated pid=0x");
  if (err == k_ra8_ok) {
    err = dfu_print_hex(s_dbg_pid, (uint8_t)k_dfu_hex_chars_u16);
  }
  if (err == k_ra8_ok) {
    err = dfu_print("\r\n");
  }
  return err;
}
 
[[nodiscard]] ra8_err_t dfu_host_pass(void)
{
  s_dbg_phase   = (uint32_t)k_dfu_phase_init;
  ra8_err_t err = dfu_print("ra8d2 dfu: host up on USB-HS, probing the loop...\r\n");
  if (err != k_ra8_ok) {
    return err;
  }
  err = ra8_usb_host_init(k_ra8_usb_speed_hs);
  if (err != k_ra8_ok) {
    (void)dfu_print_fail("host init", err);
    return err;
  }
 
  err = dfu_host_enumerate();
  if (err != k_ra8_ok) {
    return err;
  }
 
  s_dbg_phase = (uint32_t)k_dfu_phase_download;
  err         = dfu_download_all();
  if (err != k_ra8_ok) {
    (void)dfu_print_fail("dnload", err);
    (void)ra8_usb_host_deinit(k_ra8_usb_speed_hs);
    return err;
  }
 
  s_dbg_phase = (uint32_t)k_dfu_phase_upload;
  err         = dfu_upload_verify();
  if (err != k_ra8_ok) {
    (void)dfu_print_fail("upload verify", err);
    (void)ra8_usb_host_deinit(k_ra8_usb_speed_hs);
    return err;
  }
 
  s_dbg_phase = (uint32_t)k_dfu_phase_pass;
  s_dbg_pass_count++;
  err = dfu_print("ra8d2 dfu: ");
  if (err == k_ra8_ok) {
    err = dfu_print_dec((uint32_t)k_dfu_blocks);
  }
  if (err == k_ra8_ok) {
    err = dfu_print(" blocks downloaded + verified -- USB SELFTEST DFU PASS\r\n");
  }
  if (err != k_ra8_ok) {
    return err;
  }
  (void)ra8_board_led_on(k_ra8_board_led2);
  return k_ra8_ok;
}
 
#endif /* !RA8_OFF_TARGET */