ARMmbed
/
mbed-os
mirror of https://github.com/ARMmbed/mbed-os.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Enabled non-binary address mode on the AT45DB family

pull/7774/head
Marcus Chang 2017-07-15 01:25:13 +01:00 committed by Christopher Haster
parent 1dfcc87f38
commit d60b22b131
3 changed files with 189 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

266
AT45DBBlockDevice.cpp
View File

@ -25,9 +25,15 @@
#define AT45DB_ID_MATCH 0x1F20 #define AT45DB_ID_MATCH 0x1F20
#define AT45DB_ID_DENSITY_MASK 0x001F #define AT45DB_ID_DENSITY_MASK 0x001F
#define AT45DB_PAGE_SIZE_256 0x0100 #define AT45DB_PAGE_SIZE_256 0x0100
#define AT45DB_PAGE_SIZE_264 0x0108
#define AT45DB_PAGE_SIZE_512 0x0200 #define AT45DB_PAGE_SIZE_512 0x0200
#define AT45DB_PAGE_SIZE_528 0x0210
#define AT45DB_BLOCK_SIZE_2K 0x0800 #define AT45DB_BLOCK_SIZE_2K 0x0800
#define AT45DB_BLOCK_SIZE_2K1 0x0840
#define AT45DB_BLOCK_SIZE_4K 0x1000 #define AT45DB_BLOCK_SIZE_4K 0x1000
#define AT45DB_BLOCK_SIZE_4K1 0x1080
#define AT45DB_PAGE_BIT_264 9
#define AT45DB_PAGE_BIT_528 10
/* enable debug */ /* enable debug */
#define AT45DB_DEBUG 0 #define AT45DB_DEBUG 0
@ -42,20 +48,22 @@ void _print_status(uint16_t status);
/* non-exhaustive opcode list */ /* non-exhaustive opcode list */
enum opcode { enum opcode {
AT45DB_OP_NOP = 0x00, AT45DB_OP_NOP = 0x00,
AT45DB_OP_STATUS = 0xD7, AT45DB_OP_STATUS = 0xD7,
AT45DB_OP_ID = 0x9F, AT45DB_OP_ID = 0x9F,
AT45DB_OP_READ_LOW_POWER = 0x01, AT45DB_OP_READ_LOW_POWER = 0x01,
AT45DB_OP_READ_LOW_FREQUENCY = 0x03, AT45DB_OP_READ_LOW_FREQUENCY = 0x03,
AT45DB_OP_PROGRAM_DIRECT = 0x02, // Program through Buffer 1 without Built-In Erase AT45DB_OP_PROGRAM_DIRECT = 0x02, // Program through Buffer 1 without Built-In Erase
AT45DB_OP_ERASE_BLOCK = 0x50, AT45DB_OP_PROGRAM_DIRECT_WITH_ERASE = 0x82,
AT45DB_OP_ERASE_BLOCK = 0x50,
}; };
/* non-exhaustive command list */ /* non-exhaustive command list */
enum command { enum command {
AT45DB_COMMAND_WRITE_DISABLE = 0x3D2A7F9A, AT45DB_COMMAND_WRITE_DISABLE = 0x3D2A7F9A,
AT45DB_COMMAND_WRITE_ENABLE = 0x3D2A7FA9, AT45DB_COMMAND_WRITE_ENABLE = 0x3D2A7FA9,
AT45DB_COMMAND_SET_PAGE_SIZE = 0x3D2A80A6, AT45DB_COMMAND_BINARY_PAGE_SIZE = 0x3D2A80A6,
AT45DB_COMMAND_DATAFLASH_PAGE_SIZE = 0x3D2A80A7,
}; };
/* bit masks for interpreting the status register */ /* bit masks for interpreting the status register */
@ -158,24 +166,83 @@ int AT45DBBlockDevice::init()
DEBUG_PRINTF("id: %04X\r\n", id & AT45DB_ID_MATCH); DEBUG_PRINTF("id: %04X\r\n", id & AT45DB_ID_MATCH);
/* get status register to verify the page size mode */
uint16_t status = _get_register(AT45DB_OP_STATUS);
/* manufacture ID match */ /* manufacture ID match */
if ((id & AT45DB_ID_MATCH) == AT45DB_ID_MATCH) { if ((id & AT45DB_ID_MATCH) == AT45DB_ID_MATCH) {
/* calculate density */ /* calculate density */
_device_size = 0x8000 << (id & AT45DB_ID_DENSITY_MASK); _device_size = 0x8000 << (id & AT45DB_ID_DENSITY_MASK);
bool binary_page_size = true;
/* check if device is configured for binary page sizes */
if ((status & AT45DB_BIT_PAGE_SIZE) == AT45DB_BIT_PAGE_SIZE) {
DEBUG_PRINTF("Page size is binary\r\n");
#if MBED_CONF_AT45DB_DATAFLASH_SIZE
/* send reconfiguration command */
_write_command(AT45DB_COMMAND_DATAFLASH_PAGE_SIZE, NULL, 0);
/* wait for device to be ready and update return code */
result = _sync();
/* set binary flag */
binary_page_size = false;
#else
/* set binary flag */
binary_page_size = true;
#endif
} else {
DEBUG_PRINTF("Page size is not binary\r\n");
#if MBED_CONF_AT45DB_BINARY_SIZE
/* send reconfiguration command */
_write_command(AT45DB_COMMAND_BINARY_PAGE_SIZE, NULL, 0);
/* wait for device to be ready and update return code */
result = _sync();
/* set binary flag */
binary_page_size = true;
#else
/* set binary flag */
binary_page_size = false;
#endif
}
/* set page program size and block erase size */ /* set page program size and block erase size */
switch (id & AT45DB_ID_DENSITY_MASK) { switch (id & AT45DB_ID_DENSITY_MASK) {
case AT45DB_ID_DENSITY_2_MBIT: case AT45DB_ID_DENSITY_2_MBIT:
case AT45DB_ID_DENSITY_4_MBIT: case AT45DB_ID_DENSITY_4_MBIT:
case AT45DB_ID_DENSITY_8_MBIT: case AT45DB_ID_DENSITY_8_MBIT:
case AT45DB_ID_DENSITY_64_MBIT: case AT45DB_ID_DENSITY_64_MBIT:
_page_size = AT45DB_PAGE_SIZE_256; if (binary_page_size) {
_block_size = AT45DB_BLOCK_SIZE_2K; _page_size = AT45DB_PAGE_SIZE_256;
_block_size = AT45DB_BLOCK_SIZE_2K;
} else {
_page_size = AT45DB_PAGE_SIZE_264;
_block_size = AT45DB_BLOCK_SIZE_2K1;
/* adjust device size */
_device_size = (_device_size / AT45DB_PAGE_SIZE_256) *
AT45DB_PAGE_SIZE_264;
}
break; break;
case AT45DB_ID_DENSITY_16_MBIT: case AT45DB_ID_DENSITY_16_MBIT:
case AT45DB_ID_DENSITY_32_MBIT: case AT45DB_ID_DENSITY_32_MBIT:
_page_size = AT45DB_PAGE_SIZE_512; if (binary_page_size) {
_block_size = AT45DB_BLOCK_SIZE_4K; _page_size = AT45DB_PAGE_SIZE_512;
_block_size = AT45DB_BLOCK_SIZE_4K;
} else {
_page_size = AT45DB_PAGE_SIZE_528;
_block_size = AT45DB_BLOCK_SIZE_4K1;
/* adjust device size */
_device_size = (_device_size / AT45DB_PAGE_SIZE_512) *
AT45DB_PAGE_SIZE_528;
}
break; break;
default: default:
break; break;
@ -183,32 +250,13 @@ int AT45DBBlockDevice::init()
DEBUG_PRINTF("density: %" PRIu16 "\r\n", id & AT45DB_ID_DENSITY_MASK); DEBUG_PRINTF("density: %" PRIu16 "\r\n", id & AT45DB_ID_DENSITY_MASK);
DEBUG_PRINTF("size: %" PRIu32 "\r\n", _device_size); DEBUG_PRINTF("size: %" PRIu32 "\r\n", _device_size);
DEBUG_PRINTF("page: %" PRIu16 "\r\n", _page_size);
DEBUG_PRINTF("block: %" PRIu16 "\r\n", _block_size);
/* device successfully detected, set OK error code */ /* device successfully detected, set OK error code */
result = BD_ERROR_OK; result = BD_ERROR_OK;
} }
/* get status register to verify the page size mode */
uint16_t status = _get_register(AT45DB_OP_STATUS);
/* If the page size is set to a size that is not a power of two
then reconfigure it to use binary sizes instead.
In the future, the extra space can be used for error correction codes.
*/
if ((status & AT45DB_BIT_PAGE_SIZE) != AT45DB_BIT_PAGE_SIZE) {
DEBUG_PRINTF("Page size is 528 bytes\r\n");
/* send reconfiguration command */
_write_command(AT45DB_COMMAND_SET_PAGE_SIZE, NULL, 0);
/* wait for device to be ready and update return code */
result = _sync();
} else {
DEBUG_PRINTF("Page size is 512 bytes\r\n");
}
/* write protect device when idle */ /* write protect device when idle */
_write_enable(false); _write_enable(false);
@ -224,7 +272,7 @@ int AT45DBBlockDevice::deinit()
int AT45DBBlockDevice::read(void *buffer, bd_addr_t addr, bd_size_t size) int AT45DBBlockDevice::read(void *buffer, bd_addr_t addr, bd_size_t size)
{ {
DEBUG_PRINTF("program: %p %" PRIX64 " %" PRIX64 "\r\n", buffer, addr, size); DEBUG_PRINTF("read: %p %" PRIX64 " %" PRIX64 "\r\n", buffer, addr, size);
int result = BD_ERROR_DEVICE_ERROR; int result = BD_ERROR_DEVICE_ERROR;
@ -239,10 +287,15 @@ int AT45DBBlockDevice::read(void *buffer, bd_addr_t addr, bd_size_t size)
/* send read opcode */ /* send read opcode */
_spi.write(AT45DB_OP_READ_LOW_FREQUENCY); _spi.write(AT45DB_OP_READ_LOW_FREQUENCY);
/* translate address */
uint32_t address = _translate_address(addr);
DEBUG_PRINTF("address: %" PRIX32 "\r\n", address);
/* send read address */ /* send read address */
_spi.write((addr >> 16) & 0xFF); _spi.write((address >> 16) & 0xFF);
_spi.write((addr >> 8) & 0xFF); _spi.write((address >> 8) & 0xFF);
_spi.write(addr & 0xFF); _spi.write(address & 0xFF);
/* clock out one byte at a time and store in external buffer */ /* clock out one byte at a time and store in external buffer */
for (uint32_t index = 0; index < size; index++) { for (uint32_t index = 0; index < size; index++) {
@ -272,8 +325,8 @@ int AT45DBBlockDevice::program(const void *buffer, bd_addr_t addr, bd_size_t siz
/* Each write command can only cover one page at a time. /* Each write command can only cover one page at a time.
Find page and current page offset for handling unaligned writes. Find page and current page offset for handling unaligned writes.
*/ */
uint32_t write_page = addr & ~(_page_size - 1); uint32_t page_number = addr / _page_size;
uint32_t page_offset = addr & (_page_size - 1); uint32_t page_offset = addr % _page_size;
/* disable write protection */ /* disable write protection */
_write_enable(true); _write_enable(true);
@ -285,23 +338,24 @@ int AT45DBBlockDevice::program(const void *buffer, bd_addr_t addr, bd_size_t siz
/* find remaining bytes to be written */ /* find remaining bytes to be written */
uint32_t bytes_remaining = size - bytes_written; uint32_t bytes_remaining = size - bytes_written;
/* cap the value at the page size */ /* cap the value at the page size and offset */
if (bytes_remaining > _page_size) { if (bytes_remaining > (_page_size - page_offset)) {
bytes_remaining = _page_size; bytes_remaining = _page_size - page_offset;
} }
/* Write one page, bytes_written keeps track of the progress, /* Write one page, bytes_written keeps track of the progress,
write_page is the page address, and page_offset is non-zero for page_number is the page address, and page_offset is non-zero for
unaligned writes. unaligned writes.
*/ */
result = _write_page(&external_buffer[bytes_written], result = _write_page(&external_buffer[bytes_written],
write_page + page_offset, page_number,
bytes_remaining - page_offset); page_offset,
bytes_remaining);
/* update loop variables upon success otherwise break loop */ /* update loop variables upon success otherwise break loop */
if (result == BD_ERROR_OK) { if (result == BD_ERROR_OK) {
bytes_written += (_page_size - page_offset); bytes_written += bytes_remaining;
write_page += _page_size; page_number++;
/* After the first successful write, /* After the first successful write,
all subsequent writes will be aligned. all subsequent writes will be aligned.
@ -338,10 +392,13 @@ int AT45DBBlockDevice::erase(bd_addr_t addr, bd_size_t size)
/* set block erase opcode */ /* set block erase opcode */
uint32_t command = AT45DB_OP_ERASE_BLOCK; uint32_t command = AT45DB_OP_ERASE_BLOCK;
/* translate address */
uint32_t address = _translate_address(addr);
/* set block address */ /* set block address */
command = (command << 8) | ((addr >> 16) & 0xFF); command = (command << 8) | ((address >> 16) & 0xFF);
command = (command << 8) | ((addr >> 8) & 0xFF); command = (command << 8) | ((address >> 8) & 0xFF);
command = (command << 8) | (addr & 0xFF); command = (command << 8) | (address & 0xFF);
/* send command to device */ /* send command to device */
_write_command(command, NULL, 0); _write_command(command, NULL, 0);
@ -368,28 +425,28 @@ int AT45DBBlockDevice::erase(bd_addr_t addr, bd_size_t size)
bd_size_t AT45DBBlockDevice::get_read_size() const bd_size_t AT45DBBlockDevice::get_read_size() const
{ {
DEBUG_PRINTF("size: %d\r\n", AT45DB_READ_SIZE); DEBUG_PRINTF("read size: %d\r\n", AT45DB_READ_SIZE);
return AT45DB_READ_SIZE; return AT45DB_READ_SIZE;
} }
bd_size_t AT45DBBlockDevice::get_program_size() const bd_size_t AT45DBBlockDevice::get_program_size() const
{ {
DEBUG_PRINTF("size: %d\r\n", AT45DB_PROG_SIZE); DEBUG_PRINTF("program size: %d\r\n", AT45DB_PROG_SIZE);
return AT45DB_PROG_SIZE; return AT45DB_PROG_SIZE;
} }
bd_size_t AT45DBBlockDevice::get_erase_size() const bd_size_t AT45DBBlockDevice::get_erase_size() const
{ {
DEBUG_PRINTF("size: %" PRIX16 "\r\n", _block_size); DEBUG_PRINTF("erase size: %" PRIX16 "\r\n", _block_size);
return _block_size; return _block_size;
} }
bd_size_t AT45DBBlockDevice::size() const bd_size_t AT45DBBlockDevice::size() const
{ {
DEBUG_PRINTF("size: %" PRIX32 "\r\n", _device_size); DEBUG_PRINTF("device size: %" PRIX32 "\r\n", _device_size);
return _device_size; return _device_size;
} }
@ -539,19 +596,35 @@ int AT45DBBlockDevice::_sync(void)
* @param size Bytes to write. Can at most be the full page. * @param size Bytes to write. Can at most be the full page.
* @return BlockDevice error code. * @return BlockDevice error code.
*/ */
int AT45DBBlockDevice::_write_page(const uint8_t *buffer, uint32_t addr, uint32_t size) int AT45DBBlockDevice::_write_page(const uint8_t *buffer,
uint32_t page,
uint32_t offset,
uint32_t size)
{ {
DEBUG_PRINTF("_write_page: %p %" PRIX32 " %" PRIX32 "\r\n", buffer, addr, size); DEBUG_PRINTF("_write_page: %p %" PRIX32 " %" PRIX32 "\r\n", buffer, page, size);
uint32_t command = AT45DB_OP_NOP;
/* opcode for writing directly to device, in a single command, /* opcode for writing directly to device, in a single command,
assuming the page has been erased before hand. assuming the page has been erased before hand.
*/ */
uint32_t command = AT45DB_OP_PROGRAM_DIRECT; command = AT45DB_OP_PROGRAM_DIRECT;
uint32_t address = 0;
/* convert page number and offset into device address based on address format */
if (_page_size == AT45DB_PAGE_SIZE_264) {
address = (page << AT45DB_PAGE_BIT_264) | offset;
} else if (_page_size == AT45DB_PAGE_SIZE_528) {
address = (page << AT45DB_PAGE_BIT_528) | offset;
} else {
address = (page * _page_size) | offset;
}
/* set write address */ /* set write address */
command = (command << 8) | ((addr >> 16) & 0xFF); command = (command << 8) | ((address >> 16) & 0xFF);
command = (command << 8) | ((addr >> 8) & 0xFF); command = (command << 8) | ((address >> 8) & 0xFF);
command = (command << 8) | (addr & 0xFF); command = (command << 8) | (address & 0xFF);
/* send write command with data */ /* send write command with data */
_write_command(command, buffer, size); _write_command(command, buffer, size);
@ -562,6 +635,30 @@ int AT45DBBlockDevice::_write_page(const uint8_t *buffer, uint32_t addr, uint32_
return result; return result;
} }
/**
* @brief Translate address.
* @details If the device is configured for non-binary page sizes,
* the address is translated from binary to non-binary form.
*
* @param addr Binary address.
* @return Address in format expected by device.
*/
uint32_t AT45DBBlockDevice::_translate_address(bd_addr_t addr)
{
uint32_t address = addr;
/* translate address if page size is non-binary */
if (_page_size == AT45DB_PAGE_SIZE_264) {
address = ((addr / AT45DB_PAGE_SIZE_264) << AT45DB_PAGE_BIT_264) |
(addr % AT45DB_PAGE_SIZE_264);
} else if (_page_size == AT45DB_PAGE_SIZE_528) {
address = ((addr / AT45DB_PAGE_SIZE_528) << AT45DB_PAGE_BIT_528) |
(addr % AT45DB_PAGE_SIZE_528);
}
return address;
}
/** /**
* @brief Internal function for printing out each bit set in status register. * @brief Internal function for printing out each bit set in status register.
* *
@ -573,92 +670,77 @@ void _print_status(uint16_t status)
DEBUG_PRINTF("%04X\r\n", status); DEBUG_PRINTF("%04X\r\n", status);
/* device is ready (after write/erase) */ /* device is ready (after write/erase) */
if (status & AT45DB_BIT_READY) if (status & AT45DB_BIT_READY) {
{
DEBUG_PRINTF("AT45DB_BIT_READY\r\n"); DEBUG_PRINTF("AT45DB_BIT_READY\r\n");
} }
/* Buffer comparison failed */ /* Buffer comparison failed */
if (status & AT45DB_BIT_COMPARE) if (status & AT45DB_BIT_COMPARE) {
{
DEBUG_PRINTF("AT45DB_BIT_COMPARE\r\n"); DEBUG_PRINTF("AT45DB_BIT_COMPARE\r\n");
} }
/* device size is 2 MB */ /* device size is 2 MB */
if (status & AT45DB_STATUS_DENSITY_2_MBIT) if (status & AT45DB_STATUS_DENSITY_2_MBIT) {
{
DEBUG_PRINTF("AT45DB_STATUS_DENSITY_2_MBIT\r\n"); DEBUG_PRINTF("AT45DB_STATUS_DENSITY_2_MBIT\r\n");
} }
/* device size is 4 MB */ /* device size is 4 MB */
if (status & AT45DB_STATUS_DENSITY_4_MBIT) if (status & AT45DB_STATUS_DENSITY_4_MBIT) {
{
DEBUG_PRINTF("AT45DB_STATUS_DENSITY_4_MBIT\r\n"); DEBUG_PRINTF("AT45DB_STATUS_DENSITY_4_MBIT\r\n");
} }
/* device size is 8 MB */ /* device size is 8 MB */
if (status & AT45DB_STATUS_DENSITY_8_MBIT) if (status & AT45DB_STATUS_DENSITY_8_MBIT) {
{
DEBUG_PRINTF("AT45DB_STATUS_DENSITY_8_MBIT\r\n"); DEBUG_PRINTF("AT45DB_STATUS_DENSITY_8_MBIT\r\n");
} }
/* device size is 16 MB */ /* device size is 16 MB */
if (status & AT45DB_STATUS_DENSITY_16_MBIT) if (status & AT45DB_STATUS_DENSITY_16_MBIT) {
{
DEBUG_PRINTF("AT45DB_STATUS_DENSITY_16_MBIT\r\n"); DEBUG_PRINTF("AT45DB_STATUS_DENSITY_16_MBIT\r\n");
} }
/* device size is 32 MB */ /* device size is 32 MB */
if (status & AT45DB_STATUS_DENSITY_32_MBIT) if (status & AT45DB_STATUS_DENSITY_32_MBIT) {
{
DEBUG_PRINTF("AT45DB_STATUS_DENSITY_32_MBIT\r\n"); DEBUG_PRINTF("AT45DB_STATUS_DENSITY_32_MBIT\r\n");
} }
/* device size is 64 MB */ /* device size is 64 MB */
if (status & AT45DB_STATUS_DENSITY_64_MBIT) if (status & AT45DB_STATUS_DENSITY_64_MBIT) {
{
DEBUG_PRINTF("AT45DB_STATUS_DENSITY_64_MBIT\r\n"); DEBUG_PRINTF("AT45DB_STATUS_DENSITY_64_MBIT\r\n");
} }
/* sector protectino enabled */ /* sector protectino enabled */
if (status & AT45DB_BIT_PROTECT) if (status & AT45DB_BIT_PROTECT) {
{
DEBUG_PRINTF("AT45DB_BIT_PROTECT\r\n"); DEBUG_PRINTF("AT45DB_BIT_PROTECT\r\n");
} }
/* page size is a power of 2 */ /* page size is a power of 2 */
if (status & AT45DB_BIT_PAGE_SIZE) if (status & AT45DB_BIT_PAGE_SIZE) {
{
DEBUG_PRINTF("AT45DB_BIT_PAGE_SIZE\r\n"); DEBUG_PRINTF("AT45DB_BIT_PAGE_SIZE\r\n");
} }
/* erase/program error */ /* erase/program error */
if (status & AT45DB_BIT_ERASE_PROGRAM_ERROR) if (status & AT45DB_BIT_ERASE_PROGRAM_ERROR) {
{
DEBUG_PRINTF("AT45DB_BIT_ERASE_PROGRAM_ERROR\r\n"); DEBUG_PRINTF("AT45DB_BIT_ERASE_PROGRAM_ERROR\r\n");
} }
/* sector lockdown still possible */ /* sector lockdown still possible */
if (status & AT45DB_BIT_SECTOR_LOCKDOWN) if (status & AT45DB_BIT_SECTOR_LOCKDOWN) {
{
DEBUG_PRINTF("AT45DB_BIT_SECTOR_LOCKDOWN\r\n"); DEBUG_PRINTF("AT45DB_BIT_SECTOR_LOCKDOWN\r\n");
} }
/* program operation suspended while using buffer 2 */ /* program operation suspended while using buffer 2 */
if (status & AT45DB_BIT_PROGRAM_SUSPEND_2) if (status & AT45DB_BIT_PROGRAM_SUSPEND_2) {
{
DEBUG_PRINTF("AT45DB_BIT_PROGRAM_SUSPEND_2\r\n"); DEBUG_PRINTF("AT45DB_BIT_PROGRAM_SUSPEND_2\r\n");
} }
/* program operation suspended while using buffer 1 */ /* program operation suspended while using buffer 1 */
if (status & AT45DB_BIT_PROGRAM_SUSPEND_1) if (status & AT45DB_BIT_PROGRAM_SUSPEND_1) {
{
DEBUG_PRINTF("AT45DB_BIT_PROGRAM_SUSPEND_1\r\n"); DEBUG_PRINTF("AT45DB_BIT_PROGRAM_SUSPEND_1\r\n");
} }
/* erase has been suspended */ /* erase has been suspended */
if (status & AT45DB_BIT_ERASE_SUSPEND) if (status & AT45DB_BIT_ERASE_SUSPEND) {
{
DEBUG_PRINTF("AT45DB_BIT_ERASE_SUSPEND\r\n"); DEBUG_PRINTF("AT45DB_BIT_ERASE_SUSPEND\r\n");
} }
#endif #endif

3
AT45DBBlockDevice.h
View File

@ -153,7 +153,8 @@ private:
void _write_command(uint32_t command, const uint8_t *buffer, uint32_t size); void _write_command(uint32_t command, const uint8_t *buffer, uint32_t size);
void _write_enable(bool enable); void _write_enable(bool enable);
int _sync(void); int _sync(void);
int _write_page(const uint8_t *buffer, uint32_t addr, uint32_t size); int _write_page(const uint8_t *buffer, uint32_t addr, uint32_t offset, uint32_t size);
uint32_t _translate_address(bd_addr_t addr);
}; };

13
mbed_lib.json Normal file
View File

@ -0,0 +1,13 @@
{
"name": "at45db",
"config": {
"binary-size": {
"help": "Configure device to use binary address space.",
"value": "0"
},
"dataflash-size": {
"help": "Configure device to use DataFlash address space.",
"value": "0"
}
}
}