djsundog/circuitpython
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

add initial storage extension support

Browse Source
This commit is contained in:
microDev 2022-10-04 17:25:48 +05:30
parent 1fd09cb6da
commit 7d8ff20dac
No known key found for this signature in database
GPG Key ID: 2C0867BE60967730
1 changed files with 43 additions and 16 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

59
ports/espressif/supervisor/internal_flash.c
View File

@ -42,7 +42,7 @@
#include "supervisor/flash.h"
#include "supervisor/usb.h"
STATIC const esp_partition_t *_partition;
STATIC const esp_partition_t *_partition[2];
// TODO: Split the caching out of supervisor/shared/external_flash so we can use it.
#define SECTOR_SIZE 4096
@ -50,9 +50,12 @@ STATIC uint8_t _cache[SECTOR_SIZE];
STATIC uint32_t _cache_lba = 0xffffffff;
void supervisor_flash_init(void) {
_partition = esp_partition_find_first(ESP_PARTITION_TYPE_DATA,
_partition[0] = esp_partition_find_first(ESP_PARTITION_TYPE_DATA,
ESP_PARTITION_SUBTYPE_DATA_FAT,
NULL);
_partition[1] = esp_partition_find_first(ESP_PARTITION_TYPE_APP,
ESP_PARTITION_SUBTYPE_APP_OTA_1,
NULL);
}
uint32_t supervisor_flash_get_block_size(void) {
@ -60,7 +63,7 @@ uint32_t supervisor_flash_get_block_size(void) {
}
uint32_t supervisor_flash_get_block_count(void) {
return _partition->size / FILESYSTEM_BLOCK_SIZE;
return (_partition[0]->size + _partition[1]->size) / FILESYSTEM_BLOCK_SIZE;
}
void port_internal_flash_flush(void) {
@ -68,10 +71,23 @@ void port_internal_flash_flush(void) {
}
mp_uint_t supervisor_flash_read_blocks(uint8_t *dest, uint32_t block, uint32_t num_blocks) {
esp_partition_read(_partition,
block * FILESYSTEM_BLOCK_SIZE,
dest,
num_blocks * FILESYSTEM_BLOCK_SIZE);
uint32_t offset = block * FILESYSTEM_BLOCK_SIZE;
uint32_t read_total = num_blocks * FILESYSTEM_BLOCK_SIZE;
if (offset > _partition[0]->size) {
// only read from partition 1
esp_partition_read(_partition[1], (offset - _partition[0]->size), dest, read_total);
} else if ((offset + read_total) > _partition[0]->size) {
// first read from partition 0, then partition 1
uint32_t read_0 = _partition[0]->size - offset;
uint32_t read_1 = read_total - read_0;
esp_partition_read(_partition[0], offset, dest, read_0);
esp_partition_read(_partition[1], 0, (dest + read_0), read_1);
} else {
// only read from partition 0
esp_partition_read(_partition[0], offset, dest, read_total);
}
return 0;
}
@ -84,12 +100,10 @@ mp_uint_t supervisor_flash_write_blocks(const uint8_t *src, uint32_t lba, uint32
uint8_t block_offset = block_address % blocks_per_sector;
if (_cache_lba != block_address) {
esp_partition_read(_partition,
sector_offset,
_cache,
SECTOR_SIZE);
supervisor_flash_read_blocks(_cache, sector_offset / FILESYSTEM_BLOCK_SIZE, blocks_per_sector);
_cache_lba = sector_offset;
}
for (uint8_t b = block_offset; b < blocks_per_sector; b++) {
// Stop copying after the last block.
if (block >= num_blocks) {
@ -100,11 +114,24 @@ mp_uint_t supervisor_flash_write_blocks(const uint8_t *src, uint32_t lba, uint32
FILESYSTEM_BLOCK_SIZE);
block++;
}
esp_partition_erase_range(_partition, sector_offset, SECTOR_SIZE);
esp_partition_write(_partition,
sector_offset,
_cache,
SECTOR_SIZE);
if (sector_offset > _partition[0]->size) {
// only write to partition 1
esp_partition_erase_range(_partition[1], sector_offset - _partition[0]->size, SECTOR_SIZE);
esp_partition_write(_partition[1], sector_offset - _partition[0]->size, _cache, SECTOR_SIZE);
} else if ((sector_offset + SECTOR_SIZE) > _partition[0]->size) {
// first write to partition 0, then partition 1
uint32_t write_0 = _partition[0]->size - sector_offset;
uint32_t write_1 = SECTOR_SIZE - write_0;
esp_partition_erase_range(_partition[0], sector_offset, write_0);
esp_partition_write(_partition[0], sector_offset, _cache, write_0);
esp_partition_erase_range(_partition[1], 0, write_1);
esp_partition_write(_partition[1], 0, _cache + write_0, write_1);
} else {
// only write to partition 0
esp_partition_erase_range(_partition[0], sector_offset, SECTOR_SIZE);
esp_partition_write(_partition[0], sector_offset, _cache, SECTOR_SIZE);
}
}
return 0; // success