ra8_dfu_device.c

Go to the documentation of this file.

 
#include "ra8_dfu_device.h"
 
/* Firmware + USBX only. The host test build defines RA8_OFF_TARGET (no USBX),
 * and a firmware build that does not pull in USBX -- e.g. dfu_copy_to_run, which
 * only needs the ra8_dfu core (boot/program/launch) -- has no ux_api.h on the
 * include path. In both cases this whole TU is empty; the only consumers of the
 * DFU device API are apps that `USES usbx`. */
#if !defined(RA8_OFF_TARGET) && __has_include("ux_api.h")
 
#include <string.h>
 
#include "ra8_attributes.h"
#include "ra8_dfu.h"
#include "ra8_usb.h"
#include "ux_api.h"
#include "ux_dcd_ra8_usb.h"
#include "ux_device_class_dfu.h"
#include "ux_device_stack.h"

typedef enum : uint32_t {
  k_ra8_dfu_dev_block_bytes = 64U,         
  k_ra8_dfu_dev_page_mask   = 0x0000001FU, 
} ra8_dfu_dev_geom_t;

typedef enum : uint8_t {
  k_ra8_dfu_dev_reg_interface = 1U, 
  k_ra8_dfu_dev_reg_config    = 0U, 
} ra8_dfu_dev_reg_t;

typedef enum : uint8_t {
  k_ra8_dfu_dev_erased_byte = 0xFFU, 
} ra8_dfu_dev_fill_t;

typedef struct {
  ra8_dfu_slot_t     target;                           
  ra8_usb_speed_t    speed;                            
  volatile bool      prepared;                         
  volatile bool      manifest;                         
  volatile bool      committed;                        
  volatile uint32_t  img_len;                          
  volatile uint32_t  writes;                           
  volatile ra8_err_t prog_err;                         
  uint8_t            stage[k_ra8_dfu_dev_block_bytes]; 
} ra8_dfu_dev_ctx_t;

static ra8_dfu_dev_ctx_t s_dev = {
  .target = k_ra8_dfu_slot_b,
};
 
void ra8_dfu_device_set_target(ra8_dfu_slot_t target_slot)
{
  if ((target_slot == k_ra8_dfu_slot_a) || (target_slot == k_ra8_dfu_slot_b)) {
    s_dev.target = target_slot;
  }
}

RA8_INTERNAL static VOID internal_dfu_activate(VOID* dfu)
{
  (void)dfu;
}

RA8_INTERNAL static VOID internal_dfu_deactivate(VOID* dfu)
{
  (void)dfu;
}

RA8_INTERNAL static UINT
internal_dfu_write(VOID* dfu, ULONG block_number, UCHAR* data, ULONG length, ULONG* media_status)
{
  (void)dfu;
  if (length == 0UL) {
    s_dev.manifest = true;
  } else {
    uint32_t len = (uint32_t)length;
    if (len > (uint32_t)k_ra8_dfu_dev_block_bytes) {
      len = (uint32_t)k_ra8_dfu_dev_block_bytes;
    }
    (void)memcpy(s_dev.stage, data, (size_t)len);
    /* Pad the tail of a short final block to a 32-byte page with the erased
     * value so the 32-byte program granularity is satisfied. */
    const uint32_t plen =
      (uint32_t)((len + (uint32_t)k_ra8_dfu_dev_page_mask) & ~(uint32_t)k_ra8_dfu_dev_page_mask);
    for (uint32_t i = len; i < plen; i++) {
      s_dev.stage[i] = (uint8_t)k_ra8_dfu_dev_erased_byte;
    }
    const uint32_t  off = (uint32_t)block_number * (uint32_t)k_ra8_dfu_dev_block_bytes;
    const ra8_err_t we  = ra8_dfu_program_image(s_dev.target, off, s_dev.stage, plen);
    if (we != k_ra8_ok) {
      s_dev.prog_err = we;
    } else {
      s_dev.writes++;
      if ((off + plen) > s_dev.img_len) {
        s_dev.img_len = off + plen;
      }
    }
  }
  *media_status = (s_dev.prog_err == k_ra8_ok) ? (ULONG)UX_SLAVE_CLASS_DFU_MEDIA_STATUS_OK
                                               : (ULONG)UX_SLAVE_CLASS_DFU_MEDIA_STATUS_ERROR;
  return UX_SUCCESS;
}

RA8_INTERNAL static UINT
internal_dfu_read(VOID* dfu, ULONG block_number, UCHAR* data, ULONG length, ULONG* actual_length)
{
  (void)dfu;
  const uint32_t off = (uint32_t)block_number * (uint32_t)k_ra8_dfu_dev_block_bytes;
  if (off >= s_dev.img_len) {
    *actual_length = 0UL;
    return UX_SUCCESS;
  }
  uint32_t remain = s_dev.img_len - off;
  if (remain > (uint32_t)length) {
    remain = (uint32_t)length;
  }
  const uintptr_t src = ra8_dfu_slot_base(s_dev.target) + (uintptr_t)off;
  (void)memcpy(data, (const void*)src, (size_t)remain);
  *actual_length = (ULONG)remain;
  return UX_SUCCESS;
}

RA8_INTERNAL static UINT internal_dfu_get_status(VOID* dfu, ULONG* media_status)
{
  (void)dfu;
  *media_status = (s_dev.prog_err == k_ra8_ok) ? (ULONG)UX_SLAVE_CLASS_DFU_MEDIA_STATUS_OK
                                               : (ULONG)UX_SLAVE_CLASS_DFU_MEDIA_STATUS_ERROR;
  return UX_SUCCESS;
}

RA8_INTERNAL static UINT internal_dfu_notify(VOID* dfu, ULONG notification)
{
  (void)dfu;
  if (notification == (ULONG)UX_SLAVE_CLASS_DFU_NOTIFICATION_END_DOWNLOAD) {
    s_dev.manifest = true;
  }
  return UX_SUCCESS;
}

RA8_INTERNAL static UINT internal_class_register(unsigned char* framework, uint32_t framework_len)
{
  static UCHAR s_class_name[] = "ux_slave_class_dfu";
 
  UX_SLAVE_CLASS_DFU_PARAMETER p = {
    .ux_slave_class_dfu_parameter_will_detach = 0UL,
    .ux_slave_class_dfu_parameter_capabilities =
      (ULONG)(UX_SLAVE_CLASS_DFU_CAPABILITY_CAN_DOWNLOAD |
              UX_SLAVE_CLASS_DFU_CAPABILITY_CAN_UPLOAD),
    .ux_slave_class_dfu_parameter_instance_activate   = internal_dfu_activate,
    .ux_slave_class_dfu_parameter_instance_deactivate = internal_dfu_deactivate,
    .ux_slave_class_dfu_parameter_read                = internal_dfu_read,
    .ux_slave_class_dfu_parameter_write               = internal_dfu_write,
    .ux_slave_class_dfu_parameter_get_status          = internal_dfu_get_status,
    .ux_slave_class_dfu_parameter_notify              = internal_dfu_notify,
    .ux_slave_class_dfu_parameter_framework           = (UCHAR*)framework,
    .ux_slave_class_dfu_parameter_framework_length    = (ULONG)framework_len,
  };
  return _ux_device_stack_class_register(s_class_name,
                                         _ux_device_class_dfu_entry,
                                         (ULONG)k_ra8_dfu_dev_reg_interface,
                                         (ULONG)k_ra8_dfu_dev_reg_config,
                                         &p);
}
 
ra8_err_t ra8_dfu_device_start(ra8_usb_speed_t speed,
                               void*           usbx_pool,
                               uint32_t        pool_bytes,
                               unsigned char*  framework,
                               uint32_t        framework_len,
                               unsigned char*  strings,
                               uint32_t        strings_len,
                               unsigned char*  langids,
                               uint32_t        langids_len)
{
  if ((usbx_pool == nullptr) || (framework == nullptr) || (strings == nullptr) ||
      (langids == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  if (_ux_system_initialize(usbx_pool, (ULONG)pool_bytes, UX_NULL, 0) != UX_SUCCESS) {
    return k_ra8_err_invalid_state;
  }
  if (_ux_device_stack_initialize((UCHAR*)UX_NULL,
                                  0,
                                  (UCHAR*)framework,
                                  (ULONG)framework_len,
                                  (UCHAR*)strings,
                                  (ULONG)strings_len,
                                  (UCHAR*)langids,
                                  (ULONG)langids_len,
                                  UX_NULL) != UX_SUCCESS) {
    return k_ra8_err_invalid_state;
  }
  if (internal_class_register(framework, framework_len) != UX_SUCCESS) {
    return k_ra8_err_invalid_state;
  }
  s_dev.speed       = speed;
  ra8_err_t dcd_err = ux_dcd_ra8_usb_initialize(speed);
  if (dcd_err != k_ra8_ok) {
    return dcd_err;
  }
  /* Open the target slot once, here in thread context, so the synchronous
   * per-block program path in internal_dfu_write never runs the controller
   * bring-up (which logs over UART) from the USB control-request context. */
  const ra8_err_t pe = ra8_dfu_program_prepare(s_dev.target);
  if (pe != k_ra8_ok) {
    return pe;
  }
  s_dev.prepared = true;
  return ra8_usb_device_attach(speed, true);
}
 
ra8_err_t ra8_dfu_device_worker_step(void)
{
  /* Per-block programming now happens synchronously in internal_dfu_write, so
   * the worker only finalizes the image header once the host signals
   * end-of-download (zero-length DFU_DNLOAD). The self-test twins use DFU_ABORT
   * instead of a manifest, so they never reach this branch -- only the
   * bootloader's real download path does. */
  if (s_dev.manifest && !s_dev.committed && s_dev.prepared && (s_dev.prog_err == k_ra8_ok)) {
    uint32_t other_seq = 0U;
    (void)ra8_dfu_slot_seq(ra8_dfu_other_slot(s_dev.target), &other_seq);
    const ra8_err_t ce = ra8_dfu_program_commit(s_dev.target, s_dev.img_len, other_seq + 1U);
    if (ce != k_ra8_ok) {
      s_dev.prog_err = ce;
    }
    s_dev.committed = true;
    return ce;
  }
  return s_dev.prog_err;
}
 
uint32_t ra8_dfu_device_image_len(void)
{
  return s_dev.img_len;
}
 
uint32_t ra8_dfu_device_block_writes(void)
{
  return s_dev.writes;
}
 
bool ra8_dfu_device_manifested(void)
{
  return s_dev.manifest;
}
 
ra8_err_t ra8_dfu_device_last_error(void)
{
  return s_dev.prog_err;
}
 
bool ra8_dfu_device_committed(void)
{
  return s_dev.committed;
}
 
#endif /* !RA8_OFF_TARGET */