summaryrefslogtreecommitdiff
path: root/demo
diff options
context:
space:
mode:
authorsakumisu <[email protected]>2024-07-23 22:37:27 +0800
committersakumisu <[email protected]>2024-07-23 23:08:37 +0800
commitb399ff63ce11c38e09618aab518594780a4e0858 (patch)
tree4bc00e76d432e0b24da746c5f7a18d2d94d7b035 /demo
parent4c4ee7f0031ffbffb9e684d72d03bdda3c824b99 (diff)
feat(demo): add uf2 demo
Diffstat (limited to 'demo')
-rw-r--r--demo/bootuf2/bootuf2.c430
-rw-r--r--demo/bootuf2/bootuf2.h228
-rw-r--r--demo/bootuf2/bootuf2_config.h25
-rw-r--r--demo/bootuf2/cherryuf2.pngbin0 -> 19847 bytes
-rw-r--r--demo/bootuf2/msc_bootuf2_template.c163
-rw-r--r--demo/msc_ram_template.c2
6 files changed, 847 insertions, 1 deletions
diff --git a/demo/bootuf2/bootuf2.c b/demo/bootuf2/bootuf2.c
new file mode 100644
index 00000000..b992c4ba
--- /dev/null
+++ b/demo/bootuf2/bootuf2.c
@@ -0,0 +1,430 @@
+/*
+ * Copyright (c) 2024, sakumisu
+ * Copyright (c) 2024, Egahp
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#include "bootuf2.h"
+#include "usbd_core.h"
+
+char file_INFO[] = {
+ "CherryUSB UF2 BOOT\r\n"
+ "Model: " CONFIG_PRODUCT "\r\n"
+ "Board-ID: " CONFIG_BOARD "\r\n"
+};
+
+const char file_IDEX[] = {
+ "<!doctype html>\n"
+ "<html>"
+ "<body>"
+ "<script>\n"
+ "location.replace(\"" CONFIG_BOOT_UF2_INDEX_URL "\");\n"
+ "</script>"
+ "</body>"
+ "</html>\n"
+};
+
+const char file_JOIN[] = {
+ "<!doctype html>\n"
+ "<html>"
+ "<body>"
+ "<script>\n"
+ "location.replace(\"" CONFIG_BOOT_UF2_JOIN_URL "\");\n"
+ "</script>"
+ "</body>"
+ "</html>\n"
+};
+
+const char file_ID__[12] = BOOTUF2_FAMILYID_ARRAY;
+
+static struct bootuf2_FILE files[] = {
+ [0] = { .Name = file_ID__, .Content = NULL, .FileSize = 0 },
+ [1] = { .Name = "INFO_UF2TXT", .Content = file_INFO, .FileSize = sizeof(file_INFO) - 1 },
+ [2] = { .Name = "INDEX HTM", .Content = file_IDEX, .FileSize = sizeof(file_IDEX) - 1 },
+ [3] = { .Name = "JOIN HTM", .Content = file_JOIN, .FileSize = sizeof(file_JOIN) - 1 },
+};
+
+/*!< define DBRs */
+static const struct bootuf2_DBR bootuf2_DBR = {
+ .JMPInstruction = { 0xEB, 0x3C, 0x90 },
+ .OEM = "UF2 UF2 ",
+ .BPB = {
+ .BytesPerSector = CONFIG_BOOTUF2_SECTOR_SIZE,
+ .SectorsPerCluster = CONFIG_BOOTUF2_SECTOR_PER_CLUSTER,
+ .ReservedSectors = CONFIG_BOOTUF2_SECTOR_RESERVED,
+ .NumberOfFAT = CONFIG_BOOTUF2_NUM_OF_FAT,
+ .RootEntries = CONFIG_BOOTUF2_ROOT_ENTRIES,
+ .Sectors = (BOOTUF2_SECTORS(0) > 0xFFFF) ? 0 : BOOTUF2_SECTORS(0),
+ .MediaDescriptor = 0xF8,
+ .SectorsPerFAT = BOOTUF2_SECTORS_PER_FAT(0),
+ .SectorsPerTrack = 1,
+ .Heads = 1,
+ .HiddenSectors = 0,
+ .SectorsOver32MB = (BOOTUF2_SECTORS(0) > 0xFFFF) ? BOOTUF2_SECTORS(0) : 0,
+ .BIOSDrive = 0x80,
+ .Reserved = 0,
+ .ExtendBootSignature = 0x29,
+ .VolumeSerialNumber = 0x00420042,
+ .VolumeLabel = "CHERRYUF2",
+ .FileSystem = "FAT16 ",
+ },
+};
+
+/*!< define mask */
+static uint8_t __attribute__((aligned(4))) bootuf2_mask[BOOTUF2_BLOCKSMAX / 8 + 1] = { 0 };
+
+/*!< define state */
+static struct bootuf2_STATE bootuf2_STATE = {
+ .NumberOfBlock = 0,
+ .NumberOfWritten = 0,
+ .Mask = bootuf2_mask,
+ .Enable = 1,
+};
+
+/*!< define flash cache */
+static uint8_t __attribute__((aligned(4))) bootuf2_disk_cache[CONFIG_BOOTUF2_CACHE_SIZE];
+
+/*!< define flash buff */
+static uint8_t __attribute__((aligned(4))) bootuf2_disk_fbuff[256];
+
+/*!< define erase flag buff */
+static uint8_t __attribute__((aligned(4))) bootuf2_disk_erase[BOOTUF2_DIVCEIL(CONFIG_BOOTUF2_PAGE_COUNTMAX, 8)];
+
+/*!< define disk */
+static struct bootuf2_data bootuf2_disk = {
+ .DBR = &bootuf2_DBR,
+ .STATE = &bootuf2_STATE,
+ .fbuff = bootuf2_disk_fbuff,
+ .erase = bootuf2_disk_erase,
+ .cache = bootuf2_disk_cache,
+ .cache_size = sizeof(bootuf2_disk_cache),
+};
+
+static void fname_copy(char *dst, char const *src, uint16_t len)
+{
+ for (size_t i = 0; i < len; ++i) {
+ if (*src)
+ *dst++ = *src++;
+ else
+ *dst++ = ' ';
+ }
+}
+
+static void fcalculate_cluster(struct bootuf2_data *ctx)
+{
+ /*!< init files cluster */
+ uint16_t cluster_beg = 2;
+ for (int i = 0; i < ARRAY_SIZE(files); i++) {
+ files[i].ClusterBeg = cluster_beg;
+ files[i].ClusterEnd = -1 + cluster_beg +
+ BOOTUF2_DIVCEIL(files[i].FileSize,
+ ctx->DBR->BPB.BytesPerSector *
+ ctx->DBR->BPB.SectorsPerCluster);
+ cluster_beg = files[i].ClusterEnd + 1;
+ }
+}
+
+static int ffind_by_cluster(uint32_t cluster)
+{
+ if (cluster >= 0xFFF0) {
+ return -1;
+ }
+
+ for (uint32_t i = 0; i < ARRAY_SIZE(files); i++) {
+ if ((files[i].ClusterBeg <= cluster) &&
+ (cluster <= files[i].ClusterEnd)) {
+ return i;
+ }
+ }
+
+ return -1;
+}
+
+static bool uf2block_check_address(struct bootuf2_data *ctx,
+ struct bootuf2_BLOCK *uf2)
+{
+ uint32_t beg;
+ uint32_t end;
+
+ beg = uf2->TargetAddress;
+ end = uf2->TargetAddress + uf2->PayloadSize;
+
+ // if ((end >= beg) && (beg >= ctx->offset) &&
+ // (end <= ctx->offset + ctx->size))
+ // {
+ // return true;
+ // }
+
+ return true;
+}
+
+static bool bootuf2block_check_writable(struct bootuf2_STATE *STATE,
+ struct bootuf2_BLOCK *uf2, uint32_t block_max)
+{
+ if (uf2->NumberOfBlock)
+ {
+ if (uf2->BlockIndex < block_max)
+ {
+ uint8_t mask = 1 << (uf2->BlockIndex % 8);
+ uint32_t pos = uf2->BlockIndex / 8;
+
+ if ((STATE->Mask[pos] & mask) == 0)
+ {
+ return true;
+ }
+ }
+ }
+
+ return false;
+}
+
+static void bootuf2block_state_update(struct bootuf2_STATE *STATE,
+ struct bootuf2_BLOCK *uf2, uint32_t block_max)
+{
+ if (uf2->NumberOfBlock)
+ {
+ if (STATE->NumberOfBlock != uf2->NumberOfBlock)
+ {
+ if ((uf2->NumberOfBlock >= BOOTUF2_BLOCKSMAX) ||
+ STATE->NumberOfBlock)
+ {
+ /*!< uf2 block only can be update once */
+ /*!< this will cause never auto reboot */
+ STATE->NumberOfBlock = 0xffffffff;
+ }
+ else
+ {
+ STATE->NumberOfBlock = uf2->NumberOfBlock;
+ }
+ }
+
+ if (uf2->BlockIndex < block_max)
+ {
+ uint8_t mask = 1 << (uf2->BlockIndex % 8);
+ uint32_t pos = uf2->BlockIndex / 8;
+
+ if ((STATE->Mask[pos] & mask) == 0)
+ {
+ STATE->Mask[pos] |= mask;
+ STATE->NumberOfWritten++;
+ }
+ }
+ }
+
+ USB_LOG_DBG("UF2 block total %d written %d index %d\r\n",
+ uf2->NumberOfBlock, STATE->NumberOfWritten, uf2->BlockIndex);
+}
+
+static bool bootuf2block_state_check(struct bootuf2_STATE *STATE)
+{
+ return (STATE->NumberOfWritten >= STATE->NumberOfBlock) &&
+ STATE->NumberOfBlock;
+}
+
+void bootuf2_init(void)
+{
+ struct bootuf2_data *ctx;
+
+ ctx = &bootuf2_disk;
+
+ fcalculate_cluster(ctx);
+}
+
+int boot2uf2_read_sector(uint32_t start_sector, uint8_t *buff, uint32_t sector_count)
+{
+ struct bootuf2_data *ctx;
+
+ ctx = &bootuf2_disk;
+
+ while (sector_count) {
+ memset(buff, 0, ctx->DBR->BPB.BytesPerSector);
+
+ uint32_t sector_relative = start_sector;
+
+ /*!< DBR sector */
+ if (start_sector == BOOTUF2_SECTOR_DBR_END) {
+ memcpy(buff, ctx->DBR, sizeof(struct bootuf2_DBR));
+ buff[510] = 0x55;
+ buff[511] = 0xaa;
+ }
+ /*!< FAT sector */
+ else if (start_sector < BOOTUF2_SECTOR_FAT_END(ctx->DBR)) {
+ uint16_t *buff16 = (uint16_t *)buff;
+
+ sector_relative -= BOOTUF2_SECTOR_RSVD_END(ctx->DBR);
+
+ /*!< Perform the same operation on all FAT tables */
+ while (sector_relative >= ctx->DBR->BPB.SectorsPerFAT) {
+ sector_relative -= ctx->DBR->BPB.SectorsPerFAT;
+ }
+
+ uint16_t cluster_unused = files[ARRAY_SIZE(files) - 1].ClusterEnd + 1;
+ uint16_t cluster_absolute_first = sector_relative *
+ BOOTUF2_FAT16_PER_SECTOR(ctx->DBR);
+
+ /*!< cluster used link to chain, or unsed */
+ for (uint16_t i = 0, cluster_absolute = cluster_absolute_first;
+ i < BOOTUF2_FAT16_PER_SECTOR(ctx->DBR);
+ i++, cluster_absolute++) {
+ if (cluster_absolute >= cluster_unused)
+ buff16[i] = 0;
+ else
+ buff16[i] = cluster_absolute + 1;
+ }
+
+ /*!< cluster 0 and 1 */
+ if (sector_relative == 0) {
+ buff[0] = ctx->DBR->BPB.MediaDescriptor;
+ buff[1] = 0xff;
+ buff16[1] = 0xffff;
+ }
+
+ /*!< cluster end of file */
+ for (uint32_t i = 0; i < ARRAY_SIZE(files); i++) {
+ uint16_t cluster_file_last = files[i].ClusterEnd;
+
+ if (cluster_file_last >= cluster_absolute_first) {
+ uint16_t idx = cluster_file_last - cluster_absolute_first;
+ if (idx < BOOTUF2_FAT16_PER_SECTOR(ctx->DBR)) {
+ buff16[idx] = 0xffff;
+ }
+ }
+ }
+ }
+ /*!< root entries */
+ else if (start_sector < BOOTUF2_SECTOR_ROOT_END(ctx->DBR)) {
+ sector_relative -= BOOTUF2_SECTOR_FAT_END(ctx->DBR);
+
+ struct bootuf2_ENTRY *ent = (void *)buff;
+ int remain_entries = BOOTUF2_ENTRY_PER_SECTOR(ctx->DBR);
+
+ uint32_t file_index_first;
+
+ /*!< volume label entry */
+ if (sector_relative == 0) {
+ fname_copy(ent->Name, (char const *)ctx->DBR->BPB.VolumeLabel, 11);
+ ent->Attribute = 0x28;
+ ent++;
+ remain_entries--;
+ file_index_first = 0;
+ } else {
+ /*!< -1 to account for volume label in first sector */
+ file_index_first = sector_relative * BOOTUF2_ENTRY_PER_SECTOR(ctx->DBR) - 1;
+ }
+
+ for (uint32_t idx = file_index_first;
+ (remain_entries > 0) && (idx < ARRAY_SIZE(files));
+ idx++, ent++) {
+ const uint32_t cluster_beg = files[idx].ClusterBeg;
+
+ const struct bootuf2_FILE *f = &files[idx];
+
+ if ((0 == f->FileSize) &&
+ (0 != idx)) {
+ continue;
+ }
+
+ fname_copy(ent->Name, f->Name, 11);
+ ent->Attribute = 0x05;
+ ent->CreateTimeTeenth = BOOTUF2_SECONDS_INT % 2 * 100;
+ ent->CreateTime = BOOTUF2_DOS_TIME;
+ ent->CreateDate = BOOTUF2_DOS_DATE;
+ ent->LastAccessDate = BOOTUF2_DOS_DATE;
+ ent->FirstClustH16 = cluster_beg >> 16;
+ ent->UpdateTime = BOOTUF2_DOS_TIME;
+ ent->UpdateDate = BOOTUF2_DOS_DATE;
+ ent->FirstClustL16 = cluster_beg & 0xffff;
+ ent->FileSize = f->FileSize;
+ }
+ }
+ /*!< data */
+ else if (start_sector < BOOTUF2_SECTOR_DATA_END(ctx->DBR)) {
+ sector_relative -= BOOTUF2_SECTOR_ROOT_END(ctx->DBR);
+
+ int fid = ffind_by_cluster(2 + sector_relative / ctx->DBR->BPB.SectorsPerCluster);
+
+ if (fid >= 0) {
+ const struct bootuf2_FILE *f = &files[fid];
+
+ uint32_t sector_relative_file =
+ sector_relative -
+ (files[fid].ClusterBeg - 2) * ctx->DBR->BPB.SectorsPerCluster;
+
+ size_t fcontent_offset = sector_relative_file * ctx->DBR->BPB.BytesPerSector;
+ size_t fcontent_length = f->FileSize;
+
+ if (fcontent_length > fcontent_offset) {
+ const void *src = (void *)((uint8_t *)(f->Content) + fcontent_offset);
+ size_t copy_size = fcontent_length - fcontent_offset;
+
+ if (copy_size > ctx->DBR->BPB.BytesPerSector) {
+ copy_size = ctx->DBR->BPB.BytesPerSector;
+ }
+
+ memcpy(buff, src, copy_size);
+ }
+ }
+ }
+ /*!< unknown sector, ignore */
+
+ start_sector++;
+ sector_count--;
+ buff += ctx->DBR->BPB.BytesPerSector;
+ }
+
+ return 0;
+}
+
+int bootuf2_write_sector(uint32_t start_sector, const uint8_t *buff, uint32_t sector_count)
+{
+ struct bootuf2_data *ctx;
+
+ ctx = &bootuf2_disk;
+
+ while (sector_count) {
+ struct bootuf2_BLOCK *uf2 = (void *)buff;
+
+ if (!((uf2->MagicStart0 == BOOTUF2_MAGIC_START0) &&
+ (uf2->MagicStart1 == BOOTUF2_MAGIC_START1) &&
+ (uf2->MagicEnd == BOOTUF2_MAGIC_END) &&
+ (uf2->Flags & BOOTUF2_FLAG_FAMILID_PRESENT) &&
+ !(uf2->Flags & BOOTUF2_FLAG_NOT_MAIN_FLASH))) {
+ goto next;
+ }
+
+ if (uf2->FamilyID == CONFIG_BOOTUF2_FAMILYID) {
+ if (bootuf2block_check_writable(ctx->STATE, uf2, CONFIG_BOOTUF2_FLASHMAX)) {
+ bootuf2_write_flash(ctx, uf2);
+ bootuf2block_state_update(ctx->STATE, uf2, CONFIG_BOOTUF2_FLASHMAX);
+ } else {
+ USB_LOG_DBG("UF2 block %d already written\r\n",
+ uf2->BlockIndex);
+ }
+ }
+ else {
+ USB_LOG_DBG("UF2 block illegal id %08x\r\n", uf2->FamilyID);
+ }
+
+ next:
+ start_sector++;
+ sector_count--;
+ buff += ctx->DBR->BPB.BytesPerSector;
+ }
+
+ return 0;
+}
+
+uint16_t bootuf2_get_sector_size(void)
+{
+ return bootuf2_disk.DBR->BPB.BytesPerSector;
+}
+
+uint32_t bootuf2_get_sector_count(void)
+{
+ return bootuf2_disk.DBR->BPB.SectorsOver32MB + bootuf2_disk.DBR->BPB.Sectors;
+}
+
+bool bootuf2_is_write_done(void)
+{
+ return bootuf2block_state_check(&bootuf2_disk.STATE);
+} \ No newline at end of file
diff --git a/demo/bootuf2/bootuf2.h b/demo/bootuf2/bootuf2.h
new file mode 100644
index 00000000..b6a6e16b
--- /dev/null
+++ b/demo/bootuf2/bootuf2.h
@@ -0,0 +1,228 @@
+/*
+ * Copyright (c) 2024, sakumisu
+ * Copyright (c) 2024, Egahp
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#ifndef BOOTUF2_H
+#define BOOTUF2_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include <string.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <bootuf2_config.h>
+
+#ifndef __PACKED
+#define __PACKED __attribute__((packed))
+#endif
+
+#ifndef ARRAY_SIZE
+#define ARRAY_SIZE(array) \
+ ((int)((sizeof(array) / sizeof((array)[0]))))
+#endif
+
+struct bootuf2_BLOCK
+{
+ // 32 byte header
+ uint32_t MagicStart0;
+ uint32_t MagicStart1;
+ uint32_t Flags;
+ uint32_t TargetAddress;
+ uint32_t PayloadSize;
+ uint32_t BlockIndex;
+ uint32_t NumberOfBlock;
+ uint32_t FamilyID; // or file_size
+ uint8_t Data[476];
+ uint32_t MagicEnd;
+} __PACKED;
+//BUILD_ASSERT(sizeof(struct bootuf2_BLOCK) == 512, "bootuf2_BLOCK not sector sized");
+
+struct bootuf2_STATE
+{
+ uint32_t NumberOfBlock;
+ uint32_t NumberOfWritten;
+ uint8_t *const Mask;
+ uint8_t Enable;
+};
+
+struct bootuf2_DBR
+{
+ /*!< offset 0 */
+ uint8_t JMPInstruction[3];
+ /*!< offset 3 */
+ uint8_t OEM[8];
+ /*!< offset 11 */
+ struct
+ {
+ uint16_t BytesPerSector;
+ uint8_t SectorsPerCluster;
+ uint16_t ReservedSectors;
+ uint8_t NumberOfFAT;
+ uint16_t RootEntries;
+ uint16_t Sectors;
+ uint8_t MediaDescriptor;
+ uint16_t SectorsPerFAT;
+ uint16_t SectorsPerTrack;
+ uint16_t Heads;
+ uint32_t HiddenSectors;
+ uint32_t SectorsOver32MB;
+ uint8_t BIOSDrive;
+ uint8_t Reserved;
+ uint8_t ExtendBootSignature;
+ uint32_t VolumeSerialNumber;
+ uint8_t VolumeLabel[11];
+ uint8_t FileSystem[8];
+ } __PACKED BPB;
+ /*!< offset 62 */
+ /*!< BootLoader */
+ /*!< offset 511 */
+ /*!< 0x55 0xAA */
+} __PACKED;
+//BUILD_ASSERT(sizeof(struct bootuf2_DBR) == 62, "bootuf2_DBR size must be 62 byte");
+
+struct bootuf2_ENTRY
+{
+ char Name[11];
+ uint8_t Attribute;
+ uint8_t NTReserved;
+ uint8_t CreateTimeTeenth;
+ uint16_t CreateTime;
+ uint16_t CreateDate;
+ uint16_t LastAccessDate;
+ uint16_t FirstClustH16;
+ uint16_t UpdateTime;
+ uint16_t UpdateDate;
+ uint16_t FirstClustL16;
+ uint32_t FileSize;
+} __PACKED;
+//BUILD_ASSERT(sizeof(struct bootuf2_ENTRY) == 32, "bootuf2_ENTRY size must be 32 byte");
+
+struct bootuf2_FILE
+{
+ const char *const Name;
+ const void *const Content;
+ uint32_t FileSize;
+ uint16_t ClusterBeg;
+ uint16_t ClusterEnd;
+};
+
+struct bootuf2_data {
+ const struct bootuf2_DBR *const DBR;
+ struct bootuf2_STATE *const STATE;
+ uint8_t *const fbuff;
+ uint8_t *const erase;
+ size_t page_count;
+ uint8_t *const cache;
+ const size_t cache_size;
+ uint32_t cached_address;
+ size_t cached_bytes;
+};
+
+#define BOOTUF2_DIVCEIL(_v, _d) (((_v) / (_d)) + ((_v) % (_d) ? 1 : 0))
+
+#define BOOTUF2_MAGIC_START0 0x0A324655u
+#define BOOTUF2_MAGIC_START1 0x9E5D5157u
+#define BOOTUF2_MAGIC_SERIAL 0x251B18BDu
+#define BOOTUF2_MAGIC_END 0x0AB16F30u
+
+#define BOOTUF2_FLAG_NOT_MAIN_FLASH 0x00000001u
+#define BOOTUF2_FLAG_FILE_CONTAINER 0x00001000u
+#define BOOTUF2_FLAG_FAMILID_PRESENT 0x00002000u
+#define BOOTUF2_FLAG_MD5_PRESENT 0x00004000u
+
+#define BOOTUF2_CMD_READ 0
+#define BOOTUF2_CMD_SYNC 1
+
+#define BOOTUF2_BLOCKSMAX (((CONFIG_BOOTUF2_FLASHMAX) / 256) + (((CONFIG_BOOTUF2_FLASHMAX) % 256) ? 1 : 0))
+
+#define BOOTUF2_FAMILYID_POSNUM(n) (((CONFIG_BOOTUF2_FAMILYID) / (0x10000000 >> ((n) * 4))) % 0x10)
+#define BOOTUF2_FAMILYID_ARRAY \
+ { \
+ ((BOOTUF2_FAMILYID_POSNUM(0) >= 10) ? BOOTUF2_FAMILYID_POSNUM(0) - 10 + 'A' : BOOTUF2_FAMILYID_POSNUM(0) + '0'), \
+ ((BOOTUF2_FAMILYID_POSNUM(1) >= 10) ? BOOTUF2_FAMILYID_POSNUM(1) - 10 + 'A' : BOOTUF2_FAMILYID_POSNUM(1) + '0'), \
+ ((BOOTUF2_FAMILYID_POSNUM(2) >= 10) ? BOOTUF2_FAMILYID_POSNUM(2) - 10 + 'A' : BOOTUF2_FAMILYID_POSNUM(2) + '0'), \
+ ((BOOTUF2_FAMILYID_POSNUM(3) >= 10) ? BOOTUF2_FAMILYID_POSNUM(3) - 10 + 'A' : BOOTUF2_FAMILYID_POSNUM(3) + '0'), \
+ ((BOOTUF2_FAMILYID_POSNUM(4) >= 10) ? BOOTUF2_FAMILYID_POSNUM(4) - 10 + 'A' : BOOTUF2_FAMILYID_POSNUM(4) + '0'), \
+ ((BOOTUF2_FAMILYID_POSNUM(5) >= 10) ? BOOTUF2_FAMILYID_POSNUM(5) - 10 + 'A' : BOOTUF2_FAMILYID_POSNUM(5) + '0'), \
+ ((BOOTUF2_FAMILYID_POSNUM(6) >= 10) ? BOOTUF2_FAMILYID_POSNUM(6) - 10 + 'A' : BOOTUF2_FAMILYID_POSNUM(6) + '0'), \
+ ((BOOTUF2_FAMILYID_POSNUM(7) >= 10) ? BOOTUF2_FAMILYID_POSNUM(7) - 10 + 'A' : BOOTUF2_FAMILYID_POSNUM(7) + '0'), \
+ ('I'), \
+ ('D'), \
+ (' '), \
+ ('\0'), \
+ };
+
+#define BOOTUF2_FAT16_PER_SECTOR(pDBR) (pDBR->BPB.BytesPerSector / 2)
+#define BOOTUF2_ENTRY_PER_SECTOR(pDBR) (pDBR->BPB.BytesPerSector / sizeof(struct bootuf2_ENTRY))
+#define BOOTUF2_CLUSTERSMAX (0xFFF0 - 2)
+#define BOOTUF2_SECTOR_DBR_END (0)
+#define BOOTUF2_SECTOR_RSVD_END(pDBR) BOOTUF2_SECTOR_DBR_END + (pDBR->BPB.ReservedSectors)
+#define BOOTUF2_SECTOR_FAT_END(pDBR) BOOTUF2_SECTOR_RSVD_END(pDBR) + (pDBR->BPB.SectorsPerFAT * pDBR->BPB.NumberOfFAT)
+#define BOOTUF2_SECTOR_ROOT_END(pDBR) BOOTUF2_SECTOR_FAT_END(pDBR) + (pDBR->BPB.RootEntries / (pDBR->BPB.BytesPerSector / sizeof(struct bootuf2_ENTRY)))
+#define BOOTUF2_SECTOR_DATA_END(pDBR) (pDBR->BPB.Sectors + pDBR->BPB.SectorsOver32MB)
+
+#define BOOTUF2_SECTORS_PER_FAT(n) \
+ BOOTUF2_DIVCEIL(BOOTUF2_CLUSTERSMAX, (CONFIG_BOOTUF2_SECTOR_SIZE / 2))
+#define BOOTUF2_SECTORS_FOR_ENTRIES(n) \
+ (CONFIG_BOOTUF2_ROOT_ENTRIES / (CONFIG_BOOTUF2_SECTOR_SIZE / sizeof(struct bootuf2_ENTRY)))
+#define BOOTUF2_SECTORS(n) \
+ (CONFIG_BOOTUF2_SECTOR_RESERVED + \
+ CONFIG_BOOTUF2_NUM_OF_FAT * BOOTUF2_SECTORS_PER_FAT(n) + \
+ BOOTUF2_SECTORS_FOR_ENTRIES(n) + \
+ BOOTUF2_CLUSTERSMAX * CONFIG_BOOTUF2_SECTOR_PER_CLUSTER)
+
+#define BOOTUF2_YEAR_INT ( \
+ (__DATE__[7u] - '0') * 1000u + \
+ (__DATE__[8u] - '0') * 100u + \
+ (__DATE__[9u] - '0') * 10u + \
+ (__DATE__[10u] - '0') * 1u)
+
+#define BOOTUF2_MONTH_INT ( \
+ (__DATE__[2u] == 'n' && __DATE__[1u] == 'a') ? 1u /*Jan*/ \
+ : (__DATE__[2u] == 'b') ? 2u /*Feb*/ \
+ : (__DATE__[2u] == 'r' && __DATE__[1u] == 'a') ? 3u /*Mar*/ \
+ : (__DATE__[2u] == 'r') ? 4u /*Apr*/ \
+ : (__DATE__[2u] == 'y') ? 5u /*May*/ \
+ : (__DATE__[2u] == 'n') ? 6u /*Jun*/ \
+ : (__DATE__[2u] == 'l') ? 7u /*Jul*/ \
+ : (__DATE__[2u] == 'g') ? 8u /*Aug*/ \
+ : (__DATE__[2u] == 'p') ? 9u /*Sep*/ \
+ : (__DATE__[2u] == 't') ? 10u /*Oct*/ \
+ : (__DATE__[2u] == 'v') ? 11u /*Nov*/ \
+ : 12u /*Dec*/)
+
+#define BOOTUF2_DAY_INT ( \
+ (__DATE__[4u] == ' ' ? 0 : __DATE__[4u] - '0') * 10u + \
+ (__DATE__[5u] - '0'))
+
+#define BOOTUF2_HOUR_INT ( \
+ (__TIME__[0u] == '?' ? 0 : __TIME__[0u] - '0') * 10u + (__TIME__[1u] == '?' ? 0 : __TIME__[1u] - '0'))
+
+#define BOOTUF2_MINUTE_INT ( \
+ (__TIME__[3u] == '?' ? 0 : __TIME__[3u] - '0') * 10u + (__TIME__[4u] == '?' ? 0 : __TIME__[4u] - '0'))
+
+#define BOOTUF2_SECONDS_INT ( \
+ (__TIME__[6u] == '?' ? 0 : __TIME__[6u] - '0') * 10u + (__TIME__[7u] == '?' ? 0 : __TIME__[7u] - '0'))
+
+#define BOOTUF2_DOS_DATE ( \
+ ((BOOTUF2_YEAR_INT - 1980u) << 9u) | \
+ (BOOTUF2_MONTH_INT << 5u) | \
+ (BOOTUF2_DAY_INT << 0u))
+
+#define BOOTUF2_DOS_TIME ( \
+ (BOOTUF2_HOUR_INT << 11u) | \
+ (BOOTUF2_MINUTE_INT << 5u) | \
+ (BOOTUF2_SECONDS_INT << 0u))
+
+void bootuf2_init(void);
+int boot2uf2_read_sector(uint32_t start_sector, uint8_t *buff, uint32_t sector_count);
+int bootuf2_write_sector(uint32_t start_sector, const uint8_t *buff, uint32_t sector_count);
+uint16_t bootuf2_get_sector_size(void);
+uint32_t bootuf2_get_sector_count(void);
+
+bool bootuf2_is_write_done(void);
+int bootuf2_write_flash(struct bootuf2_data *ctx, struct bootuf2_BLOCK *uf2);
+
+#endif /* BOOTUF2_H */
diff --git a/demo/bootuf2/bootuf2_config.h b/demo/bootuf2/bootuf2_config.h
new file mode 100644
index 00000000..5bc86022
--- /dev/null
+++ b/demo/bootuf2/bootuf2_config.h
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2024, sakumisu
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#ifndef BOOTUF2_CONFIG_H
+#define BOOTUF2_CONFIG_H
+
+#define CONFIG_PRODUCT "CherryUSB"
+#define CONFIG_BOARD "CherryUSB BOARD"
+#define CONFIG_BOOT_UF2_INDEX_URL "https://github.com/cherry-embedded"
+#define CONFIG_BOOT_UF2_JOIN_URL "http://qm.qq.com/cgi-bin/qm/qr?_wv=1027&k=GyH2M5XfWTHQzmZis4ClpgvfdObPrvtk&authKey=LmcLhfno%2BiW51wmgVC%2F8WoYwUXqiclzWDHMU1Jy1d6S8cECJ4Q7bfJ%2FTe67RLakI&noverify=0&group_code=642693751"
+
+#define CONFIG_BOOTUF2_CACHE_SIZE 4096
+#define CONFIG_BOOTUF2_SECTOR_SIZE 512
+#define CONFIG_BOOTUF2_SECTOR_PER_CLUSTER 2
+#define CONFIG_BOOTUF2_SECTOR_RESERVED 1
+#define CONFIG_BOOTUF2_NUM_OF_FAT 2
+#define CONFIG_BOOTUF2_ROOT_ENTRIES 64
+
+#define CONFIG_BOOTUF2_FAMILYID 0xFFFFFFFF
+#define CONFIG_BOOTUF2_FLASHMAX 0x800000
+#define CONFIG_BOOTUF2_PAGE_COUNTMAX 1024
+
+#endif \ No newline at end of file
diff --git a/demo/bootuf2/cherryuf2.png b/demo/bootuf2/cherryuf2.png
new file mode 100644
index 00000000..aff7ee4d
--- /dev/null
+++ b/demo/bootuf2/cherryuf2.png
Binary files differ
diff --git a/demo/bootuf2/msc_bootuf2_template.c b/demo/bootuf2/msc_bootuf2_template.c
new file mode 100644
index 00000000..7bba6f98
--- /dev/null
+++ b/demo/bootuf2/msc_bootuf2_template.c
@@ -0,0 +1,163 @@
+/*
+ * Copyright (c) 2024, sakumisu
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#include "usbd_core.h"
+#include "usbd_msc.h"
+#include "bootuf2.h"
+
+#define MSC_IN_EP 0x81
+#define MSC_OUT_EP 0x02
+
+#define USBD_VID 0xFFFF
+#define USBD_PID 0xFFFF
+#define USBD_MAX_POWER 100
+#define USBD_LANGID_STRING 1033
+
+#define USB_CONFIG_SIZE (9 + MSC_DESCRIPTOR_LEN)
+
+#ifdef CONFIG_USB_HS
+#define MSC_MAX_MPS 512
+#else
+#define MSC_MAX_MPS 64
+#endif
+
+const uint8_t msc_bootuf2_descriptor[] = {
+ USB_DEVICE_DESCRIPTOR_INIT(USB_2_0, 0x00, 0x00, 0x00, USBD_VID, USBD_PID, 0x0200, 0x01),
+ USB_CONFIG_DESCRIPTOR_INIT(USB_CONFIG_SIZE, 0x01, 0x01, USB_CONFIG_BUS_POWERED, USBD_MAX_POWER),
+ MSC_DESCRIPTOR_INIT(0x00, MSC_OUT_EP, MSC_IN_EP, MSC_MAX_MPS, 0x02),
+ ///////////////////////////////////////
+ /// string0 descriptor
+ ///////////////////////////////////////
+ USB_LANGID_INIT(USBD_LANGID_STRING),
+ ///////////////////////////////////////
+ /// string1 descriptor
+ ///////////////////////////////////////
+ 0x14, /* bLength */
+ USB_DESCRIPTOR_TYPE_STRING, /* bDescriptorType */
+ 'C', 0x00, /* wcChar0 */
+ 'h', 0x00, /* wcChar1 */
+ 'e', 0x00, /* wcChar2 */
+ 'r', 0x00, /* wcChar3 */
+ 'r', 0x00, /* wcChar4 */
+ 'y', 0x00, /* wcChar5 */
+ 'U', 0x00, /* wcChar6 */
+ 'S', 0x00, /* wcChar7 */
+ 'B', 0x00, /* wcChar8 */
+ ///////////////////////////////////////
+ /// string2 descriptor
+ ///////////////////////////////////////
+ 0x26, /* bLength */
+ USB_DESCRIPTOR_TYPE_STRING, /* bDescriptorType */
+ 'C', 0x00, /* wcChar0 */
+ 'h', 0x00, /* wcChar1 */
+ 'e', 0x00, /* wcChar2 */
+ 'r', 0x00, /* wcChar3 */
+ 'r', 0x00, /* wcChar4 */
+ 'y', 0x00, /* wcChar5 */
+ 'U', 0x00, /* wcChar6 */
+ 'S', 0x00, /* wcChar7 */
+ 'B', 0x00, /* wcChar8 */
+ ' ', 0x00, /* wcChar9 */
+ 'U', 0x00, /* wcChar10 */
+ 'F', 0x00, /* wcChar11 */
+ '2', 0x00, /* wcChar12 */
+ ' ', 0x00, /* wcChar13 */
+ 'D', 0x00, /* wcChar14 */
+ 'E', 0x00, /* wcChar15 */
+ 'M', 0x00, /* wcChar16 */
+ 'O', 0x00, /* wcChar17 */
+ ///////////////////////////////////////
+ /// string3 descriptor
+ ///////////////////////////////////////
+ 0x16, /* bLength */
+ USB_DESCRIPTOR_TYPE_STRING, /* bDescriptorType */
+ '2', 0x00, /* wcChar0 */
+ '0', 0x00, /* wcChar1 */
+ '2', 0x00, /* wcChar2 */
+ '2', 0x00, /* wcChar3 */
+ '1', 0x00, /* wcChar4 */
+ '2', 0x00, /* wcChar5 */
+ '3', 0x00, /* wcChar6 */
+ '4', 0x00, /* wcChar7 */
+ '5', 0x00, /* wcChar8 */
+ '6', 0x00, /* wcChar9 */
+#ifdef CONFIG_USB_HS
+ ///////////////////////////////////////
+ /// device qualifier descriptor
+ ///////////////////////////////////////
+ 0x0a,
+ USB_DESCRIPTOR_TYPE_DEVICE_QUALIFIER,
+ 0x00,
+ 0x02,
+ 0x00,
+ 0x00,
+ 0x00,
+ 0x40,
+ 0x01,
+ 0x00,
+#endif
+ 0x00
+};
+
+static void usbd_event_handler(uint8_t busid, uint8_t event)
+{
+ switch (event) {
+ case USBD_EVENT_RESET:
+ break;
+ case USBD_EVENT_CONNECTED:
+ break;
+ case USBD_EVENT_DISCONNECTED:
+ break;
+ case USBD_EVENT_RESUME:
+ break;
+ case USBD_EVENT_SUSPEND:
+ break;
+ case USBD_EVENT_CONFIGURED:
+ break;
+ case USBD_EVENT_SET_REMOTE_WAKEUP:
+ break;
+ case USBD_EVENT_CLR_REMOTE_WAKEUP:
+ break;
+
+ default:
+ break;
+ }
+}
+
+void usbd_msc_get_cap(uint8_t busid, uint8_t lun, uint32_t *block_num, uint32_t *block_size)
+{
+ *block_num = bootuf2_get_sector_count();
+ *block_size = bootuf2_get_sector_size();
+
+ USB_LOG_INFO("sector count:%d, sector size:%d\n", *block_num, *block_size);
+}
+int usbd_msc_sector_read(uint8_t busid, uint8_t lun, uint32_t sector, uint8_t *buffer, uint32_t length)
+{
+ boot2uf2_read_sector(sector, buffer, length / bootuf2_get_sector_size());
+ return 0;
+}
+
+int usbd_msc_sector_write(uint8_t busid, uint8_t lun, uint32_t sector, uint8_t *buffer, uint32_t length)
+{
+ bootuf2_write_sector(sector, buffer, length / bootuf2_get_sector_size());
+ return 0;
+}
+
+static struct usbd_interface intf0;
+
+void msc_bootuf2_init(uint8_t busid, uint32_t reg_base)
+{
+ bootuf2_init();
+
+ usbd_desc_register(busid, msc_bootuf2_descriptor);
+ usbd_add_interface(busid, usbd_msc_init_intf(busid, &intf0, MSC_OUT_EP, MSC_IN_EP));
+
+ usbd_initialize(busid, reg_base, usbd_event_handler);
+}
+
+int bootuf2_write_flash(struct bootuf2_data *ctx, struct bootuf2_BLOCK *uf2)
+{
+ return 0;
+}
diff --git a/demo/msc_ram_template.c b/demo/msc_ram_template.c
index 933cd884..99802b9f 100644
--- a/demo/msc_ram_template.c
+++ b/demo/msc_ram_template.c
@@ -154,7 +154,7 @@ int usbd_msc_sector_write(uint8_t busid, uint8_t lun, uint32_t sector, uint8_t *
return 0;
}
-struct usbd_interface intf0;
+static struct usbd_interface intf0;
void msc_ram_init(uint8_t busid, uint32_t reg_base)
{
generated by cgit v1.3.1 (git 2.54.0) at 2026-09-03 23:43:49 +0000