james/SumProject
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

rtt更新

Browse Source
This commit is contained in:
dgjames
2025-01-18 13:25:25 +08:00
parent c6a7554b51
commit d6009a0773
726 changed files with 103376 additions and 6270 deletions
Download Patch File Download Diff File Expand all files Collapse all files

463
rt-thread/components/drivers/usb/cherryusb/demo/bootuf2/bootuf2.c Normal file
View File

@@ -0,0 +1,463 @@
/*
* 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_BOOTUF2_INDEX_URL "\");\n"
"</script>"
"</body>"
"</html>\n"
};
const char file_JOIN[] = {
"<!doctype html>\n"
"<html>"
"<body>"
"<script>\n"
"location.replace(\"" CONFIG_BOOTUF2_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 },
};
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 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 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;
}
static int bootuf2_flash_flush(struct bootuf2_data *ctx)
{
int err;
if (ctx->cached_bytes == 0) {
return 0;
}
err = bootuf2_flash_write(ctx->cached_address, ctx->cache, ctx->cached_bytes);
if (err) {
USB_LOG_ERR("UF2 slot flash write error %d at offset %08lx len %d\r\n",
err, ctx->cached_address, ctx->cached_bytes);
return -1;
}
ctx->cached_bytes = 0;
return 0;
}
int bootuf2_flash_write_internal(struct bootuf2_data *ctx, struct bootuf2_BLOCK *uf2)
{
/*!< 1.cache not empty and address not continue */
/*!< 2.cache full */
if ((ctx->cached_bytes && ((ctx->cached_address + ctx->cached_bytes) != uf2->TargetAddress)) ||
(ctx->cached_bytes == ctx->cache_size)) {
int err = bootuf2_flash_flush(ctx);
if (err)
return err;
}
/*!< write len always is 256, cache_size always is a multiple of 256 */
memcpy(ctx->cache + ctx->cached_bytes, uf2->Data, uf2->PayloadSize);
ctx->cached_address = uf2->TargetAddress - ctx->cached_bytes;
ctx->cached_bytes += uf2->PayloadSize;
return 0;
}
void bootuf2_init(void)
{
struct bootuf2_data *ctx;
ctx = &bootuf2_disk;
fcalculate_cluster(ctx);
ctx->cached_bytes = 0;
ctx->cached_address = 0;
}
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_flash_write_internal(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)
{
if (bootuf2block_state_check(bootuf2_disk.STATE)) {
bootuf2_flash_flush(&bootuf2_disk);
USB_LOG_DBG("UF2 update ok\r\n");
return true;
} else {
return false;
}
}

218
rt-thread/components/drivers/usb/cherryusb/demo/bootuf2/bootuf2.h Normal file
View File

@@ -0,0 +1,218 @@
/*
* 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;
};
#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);
void boot2uf2_flash_init(void);
int bootuf2_flash_write(uint32_t address, const uint8_t *data, size_t size);
#endif /* BOOTUF2_H */

25
rt-thread/components/drivers/usb/cherryusb/demo/bootuf2/bootuf2_config.h Normal file
View File

@@ -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_BOOTUF2_INDEX_URL "https://github.com/cherry-embedded"
#define CONFIG_BOOTUF2_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

BIN
rt-thread/components/drivers/usb/cherryusb/demo/bootuf2/cherryuf2.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 19 KiB

168
rt-thread/components/drivers/usb/cherryusb/demo/bootuf2/msc_bootuf2_template.c Normal file
View File

@@ -0,0 +1,168 @@
/*
* 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,
0x00,
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:
bootuf2_init();
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, uintptr_t reg_base)
{
boot2uf2_flash_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);
}
void boot2uf2_flash_init(void)
{
}
int bootuf2_flash_write(uint32_t address, const uint8_t *data, size_t size)
{
USB_LOG_INFO("address:%08x, size:%d\n", address, size);
return 0;
}