ra8_dfu_host.c

Go to the documentation of this file.

 
#include "ra8_dfu_host.h"
 
#ifndef RA8_OFF_TARGET
 
#include <string.h>
 
#include "ra8_attributes.h"
#include "ra8_time.h"
#include "ra8_usb.h"

typedef enum : uint16_t {
  k_rdh_bm_std_dev_in     = 0x80U, 
  k_rdh_bm_std_dev_out    = 0x00U, 
  k_rdh_bm_class_if_out   = 0x21U, 
  k_rdh_bm_class_if_in    = 0xA1U, 
  k_rdh_breq_get_desc     = 0x06U, 
  k_rdh_breq_set_addr     = 0x05U, 
  k_rdh_breq_set_config   = 0x09U, 
  k_rdh_breq_dnload       = 0x01U, 
  k_rdh_breq_upload       = 0x02U, 
  k_rdh_breq_getstatus    = 0x03U, 
  k_rdh_breq_abort        = 0x06U, 
  k_rdh_desc_device       = 0x01U, 
  k_rdh_dev_desc_len      = 18U,   
  k_rdh_off_dev_pid       = 10U,   
  k_rdh_byte_bits         = 8U,    
  k_rdh_getstatus_len     = 6U,    
  k_rdh_off_status_state  = 4U,    
  k_rdh_state_dnload_idle = 5U,    
  k_rdh_state_idle        = 2U,    
  k_rdh_dev_addr          = 1U,    
  k_rdh_config_val        = 1U,    
  k_rdh_intf              = 0U,    
  k_rdh_xfer_size         = 64U,   
} rdh_proto_t;

typedef enum : uint32_t {
  k_rdh_vbus_settle_ms = 200U,        
  k_rdh_attach_to_ms   = 2000U,       
  k_rdh_debounce_ms    = 500U,        
  k_rdh_reset_hold_ms  = 50U,         
  k_rdh_recovery_ms    = 20U,         
  k_rdh_addr_settle_ms = 5U,          
  k_rdh_status_poll_ms = 2U,          
  k_rdh_status_tries   = 50U,         
  k_rdh_enum_tries     = 8U,          
  k_rdh_attach_spin    = 50000000U,   
  k_rdh_mismatch_none  = 0xFFFFFFFFU, 
} rdh_tune_t;

RA8_INTERNAL static ra8_err_t internal_get_dev_desc(ra8_usb_speed_t speed, uint8_t* desc)
{
  const ra8_usb_setup_t setup = {
    .bm_request_type = (uint8_t)k_rdh_bm_std_dev_in,
    .b_request       = (uint8_t)k_rdh_breq_get_desc,
    .w_value         = (uint16_t)((uint16_t)k_rdh_desc_device << (uint16_t)k_rdh_byte_bits),
    .w_index         = 0U,
    .w_length        = (uint16_t)k_rdh_dev_desc_len,
  };
  uint16_t        rx = 0U;
  const ra8_err_t err =
    ra8_usb_host_control_xfer(speed, &setup, desc, (uint16_t)k_rdh_dev_desc_len, &rx);
  if (err != k_ra8_ok) {
    return err;
  }
  return (rx == (uint16_t)k_rdh_dev_desc_len) ? k_ra8_ok : k_ra8_err_hw_error;
}

RA8_INTERNAL static ra8_err_t internal_enum_hunt(ra8_usb_speed_t speed, uint8_t* desc)
{
  ra8_delay_ms((uint32_t)k_rdh_vbus_settle_ms);
  const uint32_t t0 = ra8_time_ms();
  for (uint32_t spin = 0U; spin < (uint32_t)k_rdh_attach_spin; spin++) {
    if (ra8_usb_host_line_state(speed) != 0U) {
      break;
    }
    if ((ra8_time_ms() - t0) > (uint32_t)k_rdh_attach_to_ms) {
      break;
    }
  }
  ra8_delay_ms((uint32_t)k_rdh_debounce_ms);
  ra8_err_t err = k_ra8_err_hw_timeout;
  for (uint8_t attempt = 0U; attempt < (uint8_t)k_rdh_enum_tries; attempt++) {
    (void)ra8_usb_host_bus_reset(speed, true);
    ra8_delay_ms((uint32_t)k_rdh_reset_hold_ms);
    (void)ra8_usb_host_bus_reset(speed, false);
    (void)ra8_usb_host_set_uact(speed, true);
    ra8_delay_ms((uint32_t)k_rdh_recovery_ms);
    (void)ra8_usb_host_set_target(speed, 0U);
    err = internal_get_dev_desc(speed, desc);
    if (err == k_ra8_ok) {
      return k_ra8_ok;
    }
  }
  return err;
}

RA8_INTERNAL static ra8_err_t internal_set_address(ra8_usb_speed_t speed)
{
  const ra8_usb_setup_t setup = {
    .bm_request_type = (uint8_t)k_rdh_bm_std_dev_out,
    .b_request       = (uint8_t)k_rdh_breq_set_addr,
    .w_value         = (uint16_t)k_rdh_dev_addr,
    .w_index         = 0U,
    .w_length        = 0U,
  };
  const ra8_err_t err = ra8_usb_host_control_xfer(speed, &setup, nullptr, 0U, nullptr);
  if (err != k_ra8_ok) {
    return err;
  }
  ra8_delay_ms((uint32_t)k_rdh_addr_settle_ms);
  return ra8_usb_host_set_target(speed, (uint8_t)k_rdh_dev_addr);
}

RA8_INTERNAL static ra8_err_t internal_set_config(ra8_usb_speed_t speed)
{
  const ra8_usb_setup_t setup = {
    .bm_request_type = (uint8_t)k_rdh_bm_std_dev_out,
    .b_request       = (uint8_t)k_rdh_breq_set_config,
    .w_value         = (uint16_t)k_rdh_config_val,
    .w_index         = 0U,
    .w_length        = 0U,
  };
  return ra8_usb_host_control_xfer(speed, &setup, nullptr, 0U, nullptr);
}

RA8_INTERNAL static ra8_err_t internal_getstatus(ra8_usb_speed_t speed, uint8_t* out_state)
{
  uint8_t               status[k_rdh_getstatus_len] = {};
  const ra8_usb_setup_t setup                       = {
    .bm_request_type = (uint8_t)k_rdh_bm_class_if_in,
    .b_request       = (uint8_t)k_rdh_breq_getstatus,
    .w_value         = 0U,
    .w_index         = (uint16_t)k_rdh_intf,
    .w_length        = (uint16_t)k_rdh_getstatus_len,
  };
  uint16_t        rx = 0U;
  const ra8_err_t err =
    ra8_usb_host_control_xfer(speed, &setup, status, (uint16_t)k_rdh_getstatus_len, &rx);
  if (err != k_ra8_ok) {
    return err;
  }
  if (rx != (uint16_t)k_rdh_getstatus_len) {
    return k_ra8_err_hw_error;
  }
  *out_state = status[k_rdh_off_status_state];
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_wait_state(ra8_usb_speed_t speed, uint8_t want_state)
{
  for (uint32_t i = 0U; i < (uint32_t)k_rdh_status_tries; i++) {
    uint8_t         state = 0U;
    const ra8_err_t err   = internal_getstatus(speed, &state);
    if (err != k_ra8_ok) {
      return err;
    }
    if (state == want_state) {
      return k_ra8_ok;
    }
    ra8_delay_ms((uint32_t)k_rdh_status_poll_ms);
  }
  return k_ra8_err_hw_timeout;
}

RA8_INTERNAL static ra8_err_t
internal_dnload_block(ra8_usb_speed_t speed, uint16_t block, uint8_t* data, uint16_t len)
{
  const ra8_usb_setup_t setup = {
    .bm_request_type = (uint8_t)k_rdh_bm_class_if_out,
    .b_request       = (uint8_t)k_rdh_breq_dnload,
    .w_value         = block,
    .w_index         = (uint16_t)k_rdh_intf,
    .w_length        = len,
  };
  const ra8_err_t err = ra8_usb_host_control_xfer(speed, &setup, data, len, nullptr);
  if (err != k_ra8_ok) {
    return err;
  }
  return internal_wait_state(speed, (uint8_t)k_rdh_state_dnload_idle);
}

RA8_INTERNAL static ra8_err_t
internal_download_all(ra8_usb_speed_t speed, const uint8_t* img, uint32_t img_len)
{
  const uint16_t blocks = (uint16_t)(img_len / (uint32_t)k_rdh_xfer_size);
  for (uint16_t b = 0U; b < blocks; b++) {
    uint8_t blk[k_rdh_xfer_size] = {};
    (void)memcpy(blk, &img[(uint32_t)b * (uint32_t)k_rdh_xfer_size], (size_t)k_rdh_xfer_size);
    const ra8_err_t err = internal_dnload_block(speed, b, blk, (uint16_t)k_rdh_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_rdh_bm_class_if_out,
    .b_request       = (uint8_t)k_rdh_breq_abort,
    .w_value         = 0U,
    .w_index         = (uint16_t)k_rdh_intf,
    .w_length        = 0U,
  };
  const ra8_err_t err = ra8_usb_host_control_xfer(speed, &setup, nullptr, 0U, nullptr);
  if (err != k_ra8_ok) {
    return err;
  }
  return internal_wait_state(speed, (uint8_t)k_rdh_state_idle);
}

RA8_INTERNAL static ra8_err_t
internal_download_manifest(ra8_usb_speed_t speed, const uint8_t* img, uint32_t img_len)
{
  const uint16_t blocks = (uint16_t)(img_len / (uint32_t)k_rdh_xfer_size);
  for (uint16_t b = 0U; b < blocks; b++) {
    uint8_t blk[k_rdh_xfer_size] = {};
    (void)memcpy(blk, &img[(uint32_t)b * (uint32_t)k_rdh_xfer_size], (size_t)k_rdh_xfer_size);
    const ra8_err_t err = internal_dnload_block(speed, b, blk, (uint16_t)k_rdh_xfer_size);
    if (err != k_ra8_ok) {
      return err;
    }
  }
  /* Zero-length DFU_DNLOAD = end-of-download: the device commits the slot header
   * and enters dfuMANIFEST. This is the real flash flow (what dfu-util does),
   * versus internal_download_all's DFU_ABORT that the self-test round-trip uses
   * to keep the device enumerable for the UPLOAD comparison. The caller drives
   * the device half on the same chip, so it polls ::ra8_dfu_device_committed
   * rather than waiting on a manifest-state GETSTATUS here. */
  const ra8_usb_setup_t setup = {
    .bm_request_type = (uint8_t)k_rdh_bm_class_if_out,
    .b_request       = (uint8_t)k_rdh_breq_dnload,
    .w_value         = blocks,
    .w_index         = (uint16_t)k_rdh_intf,
    .w_length        = 0U,
  };
  return ra8_usb_host_control_xfer(speed, &setup, nullptr, 0U, nullptr);
}

RA8_INTERNAL static ra8_err_t internal_upload_verify(ra8_usb_speed_t        speed,
                                                     const uint8_t*         img,
                                                     uint32_t               img_len,
                                                     ra8_dfu_host_result_t* out)
{
  const uint16_t blocks = (uint16_t)(img_len / (uint32_t)k_rdh_xfer_size);
  out->blocks_ok        = 0U;
  for (uint16_t b = 0U; b < blocks; b++) {
    uint8_t               got[k_rdh_xfer_size] = {};
    const ra8_usb_setup_t setup                = {
      .bm_request_type = (uint8_t)k_rdh_bm_class_if_in,
      .b_request       = (uint8_t)k_rdh_breq_upload,
      .w_value         = b,
      .w_index         = (uint16_t)k_rdh_intf,
      .w_length        = (uint16_t)k_rdh_xfer_size,
    };
    uint16_t        rx = 0U;
    const ra8_err_t err =
      ra8_usb_host_control_xfer(speed, &setup, got, (uint16_t)k_rdh_xfer_size, &rx);
    if (err != k_ra8_ok) {
      return err;
    }
    if (rx != (uint16_t)k_rdh_xfer_size) {
      out->mismatch = (uint32_t)b;
      return k_ra8_err_invalid_size;
    }
    if (memcmp(got, &img[(uint32_t)b * (uint32_t)k_rdh_xfer_size], (size_t)k_rdh_xfer_size) != 0) {
      out->mismatch = (uint32_t)b;
      return k_ra8_err_invalid_state;
    }
    out->blocks_ok++;
  }
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_run_seq(ra8_usb_speed_t        speed,
                                               const uint8_t*         img,
                                               uint32_t               img_len,
                                               ra8_dfu_host_result_t* out)
{
  uint8_t   desc[k_rdh_dev_desc_len] = {};
  ra8_err_t err                      = internal_enum_hunt(speed, desc);
  if (err != k_ra8_ok) {
    return err;
  }
  out->pid = (uint32_t)desc[k_rdh_off_dev_pid] |
             ((uint32_t)desc[(uint32_t)k_rdh_off_dev_pid + 1U] << (uint32_t)k_rdh_byte_bits);
  err      = internal_set_address(speed);
  if (err != k_ra8_ok) {
    return err;
  }
  err = internal_set_config(speed);
  if (err != k_ra8_ok) {
    return err;
  }
  err = internal_download_all(speed, img, img_len);
  if (err != k_ra8_ok) {
    return err;
  }
  return internal_upload_verify(speed, img, img_len, out);
}
 
ra8_err_t ra8_dfu_host_run(ra8_usb_speed_t        host_speed,
                           const uint8_t*         img,
                           uint32_t               img_len,
                           ra8_dfu_host_result_t* out)
{
  if ((img == nullptr) || (out == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  out->pid       = 0U;
  out->blocks_ok = 0U;
  out->mismatch  = (uint32_t)k_rdh_mismatch_none;
  out->last_err  = k_ra8_ok;
  if ((img_len == 0U) || ((img_len % (uint32_t)k_rdh_xfer_size) != 0U)) {
    out->last_err = k_ra8_err_invalid_arg;
    return k_ra8_err_invalid_arg;
  }
  ra8_err_t err = ra8_usb_host_init(host_speed);
  if (err != k_ra8_ok) {
    out->last_err = err;
    return err;
  }
  err           = internal_run_seq(host_speed, img, img_len, out);
  out->last_err = err;
  if (err != k_ra8_ok) {
    (void)ra8_usb_host_deinit(host_speed);
  }
  return err;
}

RA8_INTERNAL static ra8_err_t internal_program_seq(ra8_usb_speed_t        speed,
                                                   const uint8_t*         img,
                                                   uint32_t               img_len,
                                                   ra8_dfu_host_result_t* out)
{
  uint8_t   desc[k_rdh_dev_desc_len] = {};
  ra8_err_t err                      = internal_enum_hunt(speed, desc);
  if (err != k_ra8_ok) {
    return err;
  }
  out->pid = (uint32_t)desc[k_rdh_off_dev_pid] |
             ((uint32_t)desc[(uint32_t)k_rdh_off_dev_pid + 1U] << (uint32_t)k_rdh_byte_bits);
  err      = internal_set_address(speed);
  if (err != k_ra8_ok) {
    return err;
  }
  err = internal_set_config(speed);
  if (err != k_ra8_ok) {
    return err;
  }
  return internal_download_manifest(speed, img, img_len);
}
 
ra8_err_t ra8_dfu_host_program(ra8_usb_speed_t        host_speed,
                               const uint8_t*         img,
                               uint32_t               img_len,
                               ra8_dfu_host_result_t* out)
{
  if ((img == nullptr) || (out == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  out->pid       = 0U;
  out->blocks_ok = 0U;
  out->mismatch  = (uint32_t)k_rdh_mismatch_none;
  out->last_err  = k_ra8_ok;
  if ((img_len == 0U) || ((img_len % (uint32_t)k_rdh_xfer_size) != 0U)) {
    out->last_err = k_ra8_err_invalid_arg;
    return k_ra8_err_invalid_arg;
  }
  ra8_err_t err = ra8_usb_host_init(host_speed);
  if (err != k_ra8_ok) {
    out->last_err = err;
    return err;
  }
  err           = internal_program_seq(host_speed, img, img_len, out);
  out->last_err = err;
  if (err != k_ra8_ok) {
    (void)ra8_usb_host_deinit(host_speed);
  }
  return err;
}
 
#endif /* !RA8_OFF_TARGET */