usb_msc_mram_hs_steps.c

Go to the documentation of this file.

 
#include "usb_msc_mram_hs_steps.h"
 
#include <stdint.h>
#include <string.h>
 
#ifndef RA8_OFF_TARGET

typedef enum : uint32_t {
  k_mram_base_addr = 0x02000000U, 
  k_mram_bytes     = 0x00100000U, 
} demo_mram_t;

typedef enum : uint32_t {
  k_boot_jmp0        = 0xEBU,       
  k_boot_jmp1        = 0x3CU,       
  k_boot_jmp2        = 0x90U,       
  k_boot_media       = 0xF8U,       
  k_boot_sec_per_trk = 32U,         
  k_boot_num_heads   = 16U,         
  k_boot_drive_num   = 0x80U,       
  k_boot_ext_sig     = 0x29U,       
  k_boot_volume_id   = 0x52A8D200U, 
  k_boot_sig_lo      = 0x55U,       
  k_boot_sig_hi      = 0xAAU,       
  k_boot_sig_lo_off  = 510U,        
  k_boot_sig_hi_off  = 511U,        
} demo_fat_boot_t;

typedef enum : uint8_t {
  k_bpb_off_jmp        = 0U,    
  k_bpb_off_oem        = 3U,    
  k_bpb_off_bps        = 11U,   
  k_bpb_off_spc        = 13U,   
  k_bpb_off_rsvd       = 14U,   
  k_bpb_off_nfats      = 16U,   
  k_bpb_off_rootent    = 17U,   
  k_bpb_off_totsec16   = 19U,   
  k_bpb_off_media      = 21U,   
  k_bpb_off_fatsz16    = 22U,   
  k_bpb_off_spt        = 24U,   
  k_bpb_off_heads      = 26U,   
  k_bpb_off_drvnum     = 36U,   
  k_bpb_off_bootsig    = 38U,   
  k_bpb_off_volid      = 39U,   
  k_bpb_off_label      = 43U,   
  k_bpb_off_fstype     = 54U,   
  k_dir_entry_bytes    = 32U,   
  k_dir_off_attr       = 11U,   
  k_dir_off_cluster_lo = 26U,   
  k_dir_off_size       = 28U,   
  k_dir_attr_volume    = 0x08U, 
  k_dir_attr_read_only = 0x01U, 
  k_dir_name_bytes     = 11U,   
  k_byte_shift         = 8U,    
  k_byte_mask          = 0xFFU, 
} demo_fat_off_t;

typedef enum : uint32_t {
  k_word_shift = 16U,     
  k_word_mask  = 0xFFFFU, 
} demo_word_pack_t;

static const UCHAR s_fat_oem_name[8] = {'R', 'A', '8', 'D', '2', 'F', 'W', ' '};

static const UCHAR s_fat_volume_label[11] = {'R', 'A', '8', 'D', '2', ' ', 'M', 'R', 'A', 'M', ' '};

static const UCHAR s_fat_fs_type[8] = {'F', 'A', 'T', '1', '6', ' ', ' ', ' '};

static const UCHAR s_fat_file_name[11] = {'M', 'R', 'A', 'M', ' ', ' ', ' ', ' ', 'B', 'I', 'N'};

static void demo_put16(UCHAR* dst, uint16_t value)
{
  dst[0] = (UCHAR)(value & (uint16_t)k_byte_mask);
  dst[1] = (UCHAR)((value >> (uint16_t)k_byte_shift) & (uint16_t)k_byte_mask);
}

static void demo_put32(UCHAR* dst, uint32_t value)
{
  demo_put16(dst, (uint16_t)(value & (uint32_t)k_word_mask));
  demo_put16(dst + 2U, (uint16_t)(value >> (uint32_t)k_word_shift));
}

static void demo_fat_fill_boot(UCHAR* out)
{
  out[k_bpb_off_jmp]      = (UCHAR)k_boot_jmp0;
  out[k_bpb_off_jmp + 1U] = (UCHAR)k_boot_jmp1;
  out[k_bpb_off_jmp + 2U] = (UCHAR)k_boot_jmp2;
  (void)memcpy(&out[k_bpb_off_oem], s_fat_oem_name, sizeof(s_fat_oem_name));
  demo_put16(&out[k_bpb_off_bps], (uint16_t)k_demo_block_size);
  out[k_bpb_off_spc] = 1U;
  demo_put16(&out[k_bpb_off_rsvd], (uint16_t)k_fat_reserved_sectors);
  out[k_bpb_off_nfats] = (UCHAR)k_fat_num_fats;
  demo_put16(&out[k_bpb_off_rootent], (uint16_t)k_fat_root_entries);
  demo_put16(&out[k_bpb_off_totsec16], (uint16_t)k_fat_total_sectors);
  out[k_bpb_off_media] = (UCHAR)k_boot_media;
  demo_put16(&out[k_bpb_off_fatsz16], (uint16_t)k_fat_fat_sectors);
  demo_put16(&out[k_bpb_off_spt], (uint16_t)k_boot_sec_per_trk);
  demo_put16(&out[k_bpb_off_heads], (uint16_t)k_boot_num_heads);
  out[k_bpb_off_drvnum]  = (UCHAR)k_boot_drive_num;
  out[k_bpb_off_bootsig] = (UCHAR)k_boot_ext_sig;
  demo_put32(&out[k_bpb_off_volid], (uint32_t)k_boot_volume_id);
  (void)memcpy(&out[k_bpb_off_label], s_fat_volume_label, sizeof(s_fat_volume_label));
  (void)memcpy(&out[k_bpb_off_fstype], s_fat_fs_type, sizeof(s_fat_fs_type));
  out[k_boot_sig_lo_off] = (UCHAR)k_boot_sig_lo;
  out[k_boot_sig_hi_off] = (UCHAR)k_boot_sig_hi;
}

static void demo_fat_fill_fat(uint32_t fat_sector, UCHAR* out)
{
  const uint32_t first_entry = fat_sector * (uint32_t)k_fat_entries_per_sec;
  for (uint32_t j = 0U; j < (uint32_t)k_fat_entries_per_sec; j++) {
    const uint32_t entry = first_entry + j;
    uint16_t       value = 0U;
    if (entry == 0U) {
      value = (uint16_t)k_fat_entry0;
    } else if (entry == 1U) {
      value = (uint16_t)k_fat_eoc;
    } else if (entry < (uint32_t)k_fat_last_mram_clus) {
      value = (uint16_t)(entry + 1U);
    } else if (entry == (uint32_t)k_fat_last_mram_clus) {
      value = (uint16_t)k_fat_eoc;
    } else {
      value = 0U;
    }
    demo_put16(&out[j * 2U], value);
  }
}

static void demo_fat_fill_root(uint32_t root_sector, UCHAR* out)
{
  if (root_sector != 0U) {
    return;
  }
  /* Entry 0: volume label. */
  (void)memcpy(&out[0], s_fat_volume_label, (size_t)k_dir_name_bytes);
  out[k_dir_off_attr] = (UCHAR)k_dir_attr_volume;
  /* Entry 1: MRAM.BIN, read-only, cluster 2, 1 MiB. */
  UCHAR* entry = &out[k_dir_entry_bytes];
  (void)memcpy(entry, s_fat_file_name, (size_t)k_dir_name_bytes);
  entry[k_dir_off_attr] = (UCHAR)k_dir_attr_read_only;
  demo_put16(&entry[k_dir_off_cluster_lo], (uint16_t)k_fat_first_cluster);
  demo_put32(&entry[k_dir_off_size], (uint32_t)k_mram_bytes);
}
 
void demo_fat_fill_sector(uint32_t lba, UCHAR* out)
{
  (void)memset(out, 0, (size_t)k_demo_block_size);
  if (lba == 0U) {
    demo_fat_fill_boot(out);
    return;
  }
  if (lba < (uint32_t)k_fat_root_lba) {
    demo_fat_fill_fat(lba - (uint32_t)k_fat_fat_lba, out);
    return;
  }
  if (lba < (uint32_t)k_fat_data_lba) {
    demo_fat_fill_root(lba - (uint32_t)k_fat_root_lba, out);
    return;
  }
  const uint32_t cluster = (lba - (uint32_t)k_fat_data_lba) + (uint32_t)k_fat_first_cluster;
  if (cluster <= (uint32_t)k_fat_last_mram_clus) {
    const uint32_t offset = (cluster - (uint32_t)k_fat_first_cluster) * (uint32_t)k_demo_block_size;
    const UCHAR*   mram   = (const UCHAR*)(uintptr_t)((uint32_t)k_mram_base_addr + offset);
    (void)memcpy(out, mram, (size_t)k_demo_block_size);
  }
}
 
#endif /* !RA8_OFF_TARGET */