Upstream
/
esphome
mirror of https://github.com/esphome/esphome.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
esphome/esphome/components/shelly_dimmer/stm32flash.cpp

1066 lines
32 KiB
C++
Raw Blame History

/*
stm32flash - Open Source ST STM32 flash program for Arduino
Copyright 2010 Geoffrey McRae <geoff@spacevs.com>
Copyright 2012-2014 Tormod Volden <debian.tormod@gmail.com>
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#include "esphome/core/defines.h"
#ifdef USE_SHD_FIRMWARE_DATA
#include <cstdint>
#include "stm32flash.h"
#include "debug.h"
#include "dev_table.h"
#include "esphome/core/log.h"
#include <algorithm>
#include <memory>
namespace {
constexpr uint8_t STM32_ACK = 0x79;
constexpr uint8_t STM32_NACK = 0x1F;
constexpr uint8_t STM32_BUSY = 0x76;
constexpr uint8_t STM32_CMD_INIT = 0x7F;
constexpr uint8_t STM32_CMD_GET = 0x00; /* get the version and command supported */
constexpr uint8_t STM32_CMD_GVR = 0x01; /* get version and read protection status */
constexpr uint8_t STM32_CMD_GID = 0x02; /* get ID */
constexpr uint8_t STM32_CMD_RM = 0x11; /* read memory */
constexpr uint8_t STM32_CMD_GO = 0x21; /* go */
constexpr uint8_t STM32_CMD_WM = 0x31; /* write memory */
constexpr uint8_t STM32_CMD_WM_NS = 0x32; /* no-stretch write memory */
constexpr uint8_t STM32_CMD_ER = 0x43; /* erase */
constexpr uint8_t STM32_CMD_EE = 0x44; /* extended erase */
constexpr uint8_t STM32_CMD_EE_NS = 0x45; /* extended erase no-stretch */
constexpr uint8_t STM32_CMD_WP = 0x63; /* write protect */
constexpr uint8_t STM32_CMD_WP_NS = 0x64; /* write protect no-stretch */
constexpr uint8_t STM32_CMD_UW = 0x73; /* write unprotect */
constexpr uint8_t STM32_CMD_UW_NS = 0x74; /* write unprotect no-stretch */
constexpr uint8_t STM32_CMD_RP = 0x82; /* readout protect */
constexpr uint8_t STM32_CMD_RP_NS = 0x83; /* readout protect no-stretch */
constexpr uint8_t STM32_CMD_UR = 0x92; /* readout unprotect */
constexpr uint8_t STM32_CMD_UR_NS = 0x93; /* readout unprotect no-stretch */
constexpr uint8_t STM32_CMD_CRC = 0xA1; /* compute CRC */
constexpr uint8_t STM32_CMD_ERR = 0xFF; /* not a valid command */
constexpr uint32_t STM32_RESYNC_TIMEOUT = 35 * 1000; /* milliseconds */
constexpr uint32_t STM32_MASSERASE_TIMEOUT = 35 * 1000; /* milliseconds */
constexpr uint32_t STM32_PAGEERASE_TIMEOUT = 5 * 1000; /* milliseconds */
constexpr uint32_t STM32_BLKWRITE_TIMEOUT = 1 * 1000; /* milliseconds */
constexpr uint32_t STM32_WUNPROT_TIMEOUT = 1 * 1000; /* milliseconds */
constexpr uint32_t STM32_WPROT_TIMEOUT = 1 * 1000; /* milliseconds */
constexpr uint32_t STM32_RPROT_TIMEOUT = 1 * 1000; /* milliseconds */
constexpr uint32_t DEFAULT_TIMEOUT = 5 * 1000; /* milliseconds */
constexpr uint8_t STM32_CMD_GET_LENGTH = 17; /* bytes in the reply */
/* Reset code for ARMv7-M (Cortex-M3) and ARMv6-M (Cortex-M0)
* see ARMv7-M or ARMv6-M Architecture Reference Manual (table B3-8)
* or "The definitive guide to the ARM Cortex-M3", section 14.4.
*/
constexpr uint8_t STM_RESET_CODE[] = {
0x01, 0x49, // ldr r1, [pc, #4] ; (<AIRCR_OFFSET>)
0x02, 0x4A, // ldr r2, [pc, #8] ; (<AIRCR_RESET_VALUE>)
0x0A, 0x60, // str r2, [r1, #0]
0xfe, 0xe7, // endless: b endless
0x0c, 0xed, 0x00, 0xe0, // .word 0xe000ed0c <AIRCR_OFFSET> = NVIC AIRCR register address
0x04, 0x00, 0xfa, 0x05 // .word 0x05fa0004 <AIRCR_RESET_VALUE> = VECTKEY | SYSRESETREQ
};
constexpr uint32_t STM_RESET_CODE_SIZE = sizeof(STM_RESET_CODE);
/* RM0360, Empty check
* On STM32F070x6 and STM32F030xC devices only, internal empty check flag is
* implemented to allow easy programming of the virgin devices by the boot loader. This flag is
* used when BOOT0 pin is defining Main Flash memory as the target boot space. When the
* flag is set, the device is considered as empty and System memory (boot loader) is selected
* instead of the Main Flash as a boot space to allow user to program the Flash memory.
* This flag is updated only during Option bytes loading: it is set when the content of the
* address 0x08000 0000 is read as 0xFFFF FFFF, otherwise it is cleared. It means a power
* on or setting of OBL_LAUNCH bit in FLASH_CR register is needed to clear this flag after
* programming of a virgin device to execute user code after System reset.
*/
constexpr uint8_t STM_OBL_LAUNCH_CODE[] = {
0x01, 0x49, // ldr r1, [pc, #4] ; (<FLASH_CR>)
0x02, 0x4A, // ldr r2, [pc, #8] ; (<OBL_LAUNCH>)
0x0A, 0x60, // str r2, [r1, #0]
0xfe, 0xe7, // endless: b endless
0x10, 0x20, 0x02, 0x40, // address: FLASH_CR = 40022010
0x00, 0x20, 0x00, 0x00 // value: OBL_LAUNCH = 00002000
};
constexpr uint32_t STM_OBL_LAUNCH_CODE_SIZE = sizeof(STM_OBL_LAUNCH_CODE);
constexpr char TAG[] = "stm32flash";
} // Anonymous namespace
namespace esphome {
namespace shelly_dimmer {
namespace {
int flash_addr_to_page_ceil(const stm32_unique_ptr &stm, uint32_t addr) {
if (!(addr >= stm->dev->fl_start && addr <= stm->dev->fl_end))
return 0;
int page = 0;
addr -= stm->dev->fl_start;
const auto *psize = stm->dev->fl_ps;
while (addr >= psize[0]) {
addr -= psize[0];
page++;
if (psize[1])
psize++;
}
return addr ? page + 1 : page;
}
stm32_err_t stm32_get_ack_timeout(const stm32_unique_ptr &stm, uint32_t timeout) {
auto *stream = stm->stream;
uint8_t rxbyte;
if (!(stm->flags & STREAM_OPT_RETRY))
timeout = 0;
if (timeout == 0)
timeout = DEFAULT_TIMEOUT;
const uint32_t start_time = millis();
do {
yield();
if (!stream->available()) {
if (millis() < start_time + timeout)
continue;
ESP_LOGD(TAG, "Failed to read ACK timeout=%i", timeout);
return STM32_ERR_UNKNOWN;
}
stream->read_byte(&rxbyte);
if (rxbyte == STM32_ACK)
return STM32_ERR_OK;
if (rxbyte == STM32_NACK)
return STM32_ERR_NACK;
if (rxbyte != STM32_BUSY) {
ESP_LOGD(TAG, "Got byte 0x%02x instead of ACK", rxbyte);
return STM32_ERR_UNKNOWN;
}
} while (true);
}
stm32_err_t stm32_get_ack(const stm32_unique_ptr &stm) { return stm32_get_ack_timeout(stm, 0); }
stm32_err_t stm32_send_command_timeout(const stm32_unique_ptr &stm, const uint8_t cmd, const uint32_t timeout) {
auto *const stream = stm->stream;
static constexpr auto BUFFER_SIZE = 2;
const uint8_t buf[] = {
cmd,
static_cast<uint8_t>(cmd ^ 0xFF),
};
static_assert(sizeof(buf) == BUFFER_SIZE, "Buf expected to be 2 bytes");
stream->write_array(buf, BUFFER_SIZE);
stream->flush();
stm32_err_t s_err = stm32_get_ack_timeout(stm, timeout);
if (s_err == STM32_ERR_OK)
return STM32_ERR_OK;
if (s_err == STM32_ERR_NACK) {
ESP_LOGD(TAG, "Got NACK from device on command 0x%02x", cmd);
} else {
ESP_LOGD(TAG, "Unexpected reply from device on command 0x%02x", cmd);
}
return STM32_ERR_UNKNOWN;
}
stm32_err_t stm32_send_command(const stm32_unique_ptr &stm, const uint8_t cmd) {
return stm32_send_command_timeout(stm, cmd, 0);
}
/* if we have lost sync, send a wrong command and expect a NACK */
stm32_err_t stm32_resync(const stm32_unique_ptr &stm) {
auto *const stream = stm->stream;
uint32_t t0 = millis();
auto t1 = t0;
static constexpr auto BUFFER_SIZE = 2;
const uint8_t buf[] = {
STM32_CMD_ERR,
static_cast<uint8_t>(STM32_CMD_ERR ^ 0xFF),
};
static_assert(sizeof(buf) == BUFFER_SIZE, "Buf expected to be 2 bytes");
uint8_t ack;
while (t1 < t0 + STM32_RESYNC_TIMEOUT) {
stream->write_array(buf, BUFFER_SIZE);
stream->flush();
if (!stream->read_array(&ack, 1)) {
t1 = millis();
continue;
}
if (ack == STM32_NACK)
return STM32_ERR_OK;
t1 = millis();
}
return STM32_ERR_UNKNOWN;
}
/*
* some command receive reply frame with variable length, and length is
* embedded in reply frame itself.
* We can guess the length, but if we guess wrong the protocol gets out
* of sync.
* Use resync for frame oriented interfaces (e.g. I2C) and byte-by-byte
* read for byte oriented interfaces (e.g. UART).
*
* to run safely, data buffer should be allocated for 256+1 bytes
*
* len is value of the first byte in the frame.
*/
stm32_err_t stm32_guess_len_cmd(const stm32_unique_ptr &stm, const uint8_t cmd, uint8_t *const data, unsigned int len) {
auto *const stream = stm->stream;
if (stm32_send_command(stm, cmd) != STM32_ERR_OK)
return STM32_ERR_UNKNOWN;
if (stm->flags & STREAM_OPT_BYTE) {
/* interface is UART-like */
if (!stream->read_array(data, 1))
return STM32_ERR_UNKNOWN;
len = data[0];
if (!stream->read_array(data + 1, len + 1))
return STM32_ERR_UNKNOWN;
return STM32_ERR_OK;
}
const auto ret = stream->read_array(data, len + 2);
if (ret && len == data[0])
return STM32_ERR_OK;
if (!ret) {
/* restart with only one byte */
if (stm32_resync(stm) != STM32_ERR_OK)
return STM32_ERR_UNKNOWN;
if (stm32_send_command(stm, cmd) != STM32_ERR_OK)
return STM32_ERR_UNKNOWN;
if (!stream->read_array(data, 1))
return STM32_ERR_UNKNOWN;
}
ESP_LOGD(TAG, "Re sync (len = %d)", data[0]);
if (stm32_resync(stm) != STM32_ERR_OK)
return STM32_ERR_UNKNOWN;
len = data[0];
if (stm32_send_command(stm, cmd) != STM32_ERR_OK)
return STM32_ERR_UNKNOWN;
if (!stream->read_array(data, len + 2))
return STM32_ERR_UNKNOWN;
return STM32_ERR_OK;
}
/*
* Some interface, e.g. UART, requires a specific init sequence to let STM32
* autodetect the interface speed.
* The sequence is only required one time after reset.
* This function sends the init sequence and, in case of timeout, recovers
* the interface.
*/
stm32_err_t stm32_send_init_seq(const stm32_unique_ptr &stm) {
auto *const stream = stm->stream;
stream->write_array(&STM32_CMD_INIT, 1);
stream->flush();
uint8_t byte;
bool ret = stream->read_array(&byte, 1);
if (ret && byte == STM32_ACK)
return STM32_ERR_OK;
if (ret && byte == STM32_NACK) {
/* We could get error later, but let's continue, for now. */
ESP_LOGD(TAG, "Warning: the interface was not closed properly.");
return STM32_ERR_OK;
}
if (!ret) {
ESP_LOGD(TAG, "Failed to init device.");
return STM32_ERR_UNKNOWN;
}
/*
* Check if previous STM32_CMD_INIT was taken as first byte
* of a command. Send a new byte, we should get back a NACK.
*/
stream->write_array(&STM32_CMD_INIT, 1);
stream->flush();
ret = stream->read_array(&byte, 1);
if (ret && byte == STM32_NACK)
return STM32_ERR_OK;
ESP_LOGD(TAG, "Failed to init device.");
return STM32_ERR_UNKNOWN;
}
stm32_err_t stm32_mass_erase(const stm32_unique_ptr &stm) {
auto *const stream = stm->stream;
if (stm32_send_command(stm, stm->cmd->er) != STM32_ERR_OK) {
ESP_LOGD(TAG, "Can't initiate chip mass erase!");
return STM32_ERR_UNKNOWN;
}
/* regular erase (0x43) */
if (stm->cmd->er == STM32_CMD_ER) {
const auto s_err = stm32_send_command_timeout(stm, 0xFF, STM32_MASSERASE_TIMEOUT);
if (s_err != STM32_ERR_OK) {
return STM32_ERR_UNKNOWN;
}
return STM32_ERR_OK;
}
/* extended erase */
static constexpr auto BUFFER_SIZE = 3;
const uint8_t buf[] = {
0xFF, /* 0xFFFF the magic number for mass erase */
0xFF, 0x00, /* checksum */
};
static_assert(sizeof(buf) == BUFFER_SIZE, "Expected the buffer to be 3 bytes");
stream->write_array(buf, 3);
stream->flush();
const auto s_err = stm32_get_ack_timeout(stm, STM32_MASSERASE_TIMEOUT);
if (s_err != STM32_ERR_OK) {
ESP_LOGD(TAG, "Mass erase failed. Try specifying the number of pages to be erased.");
return STM32_ERR_UNKNOWN;
}
return STM32_ERR_OK;
}
template<typename T> std::unique_ptr<T[], void (*)(T *memory)> malloc_array_raii(size_t size) {
// Could be constexpr in c++17
static const auto DELETOR = [](T *memory) {
free(memory); // NOLINT
};
return std::unique_ptr<T[], decltype(DELETOR)>{static_cast<T *>(malloc(size)), // NOLINT
DELETOR};
}
stm32_err_t stm32_pages_erase(const stm32_unique_ptr &stm, const uint32_t spage, const uint32_t pages) {
auto *const stream = stm->stream;
uint8_t cs = 0;
int i = 0;
/* The erase command reported by the bootloader is either 0x43, 0x44 or 0x45 */
/* 0x44 is Extended Erase, a 2 byte based protocol and needs to be handled differently. */
/* 0x45 is clock no-stretching version of Extended Erase for I2C port. */
if (stm32_send_command(stm, stm->cmd->er) != STM32_ERR_OK) {
ESP_LOGD(TAG, "Can't initiate chip mass erase!");
return STM32_ERR_UNKNOWN;
}
/* regular erase (0x43) */
if (stm->cmd->er == STM32_CMD_ER) {
// Free memory with RAII
auto buf = malloc_array_raii<uint8_t>(1 + pages + 1);
if (!buf)
return STM32_ERR_UNKNOWN;
buf[i++] = pages - 1;
cs ^= (pages - 1);
for (auto pg_num = spage; pg_num < (pages + spage); pg_num++) {
buf[i++] = pg_num;
cs ^= pg_num;
}
buf[i++] = cs;
stream->write_array(&buf[0], i);
stream->flush();
const auto s_err = stm32_get_ack_timeout(stm, pages * STM32_PAGEERASE_TIMEOUT);
if (s_err != STM32_ERR_OK) {
return STM32_ERR_UNKNOWN;
}
return STM32_ERR_OK;
}
/* extended erase */
// Free memory with RAII
auto buf = malloc_array_raii<uint8_t>(2 + 2 * pages + 1);
if (!buf)
return STM32_ERR_UNKNOWN;
/* Number of pages to be erased - 1, two bytes, MSB first */
uint8_t pg_byte = (pages - 1) >> 8;
buf[i++] = pg_byte;
cs ^= pg_byte;
pg_byte = (pages - 1) & 0xFF;
buf[i++] = pg_byte;
cs ^= pg_byte;
for (auto pg_num = spage; pg_num < spage + pages; pg_num++) {
pg_byte = pg_num >> 8;
cs ^= pg_byte;
buf[i++] = pg_byte;
pg_byte = pg_num & 0xFF;
cs ^= pg_byte;
buf[i++] = pg_byte;
}
buf[i++] = cs;
stream->write_array(&buf[0], i);
stream->flush();
const auto s_err = stm32_get_ack_timeout(stm, pages * STM32_PAGEERASE_TIMEOUT);
if (s_err != STM32_ERR_OK) {
ESP_LOGD(TAG, "Page-by-page erase failed. Check the maximum pages your device supports.");
return STM32_ERR_UNKNOWN;
}
return STM32_ERR_OK;
}
template<typename T> stm32_err_t stm32_check_ack_timeout(const stm32_err_t s_err, const T &&log) {
switch (s_err) {
case STM32_ERR_OK:
return STM32_ERR_OK;
case STM32_ERR_NACK:
log();
// TODO: c++17 [[fallthrough]]
/* fallthrough */
default:
return STM32_ERR_UNKNOWN;
}
}
/* detect CPU endian */
bool cpu_le() {
static constexpr int N = 1;
// returns true if little endian
return *reinterpret_cast<const char *>(&N) == 1;
}
uint32_t le_u32(const uint32_t v) {
if (!cpu_le())
return ((v & 0xFF000000) >> 24) | ((v & 0x00FF0000) >> 8) | ((v & 0x0000FF00) << 8) | ((v & 0x000000FF) << 24);
return v;
}
template<size_t N> void populate_buffer_with_address(uint8_t (&buffer)[N], uint32_t address) {
buffer[0] = static_cast<uint8_t>(address >> 24);
buffer[1] = static_cast<uint8_t>((address >> 16) & 0xFF);
buffer[2] = static_cast<uint8_t>((address >> 8) & 0xFF);
buffer[3] = static_cast<uint8_t>(address & 0xFF);
buffer[4] = static_cast<uint8_t>(buffer[0] ^ buffer[1] ^ buffer[2] ^ buffer[3]);
}
template<typename T> stm32_unique_ptr make_stm32_with_deletor(T ptr) {
static const auto CLOSE = [](stm32_t *stm32) {
if (stm32) {
free(stm32->cmd); // NOLINT
}
free(stm32); // NOLINT
};
// Cleanup with RAII
return std::unique_ptr<stm32_t, decltype(CLOSE)>{ptr, CLOSE};
}
} // Anonymous namespace
} // namespace shelly_dimmer
} // namespace esphome
namespace esphome {
namespace shelly_dimmer {
/* find newer command by higher code */
#define newer(prev, a) (((prev) == STM32_CMD_ERR) ? (a) : (((prev) > (a)) ? (prev) : (a)))
stm32_unique_ptr stm32_init(uart::UARTDevice *stream, const uint8_t flags, const char init) {
uint8_t buf[257];
auto stm = make_stm32_with_deletor(static_cast<stm32_t *>(calloc(sizeof(stm32_t), 1))); // NOLINT
if (!stm) {
return make_stm32_with_deletor(nullptr);
}
stm->stream = stream;
stm->flags = flags;
stm->cmd = static_cast<stm32_cmd_t *>(malloc(sizeof(stm32_cmd_t))); // NOLINT
if (!stm->cmd) {
return make_stm32_with_deletor(nullptr);
}
memset(stm->cmd, STM32_CMD_ERR, sizeof(stm32_cmd_t));
if ((stm->flags & STREAM_OPT_CMD_INIT) && init) {
if (stm32_send_init_seq(stm) != STM32_ERR_OK)
return make_stm32_with_deletor(nullptr);
}
/* get the version and read protection status */
if (stm32_send_command(stm, STM32_CMD_GVR) != STM32_ERR_OK) {
return make_stm32_with_deletor(nullptr);
}
/* From AN, only UART bootloader returns 3 bytes */
{
const auto len = (stm->flags & STREAM_OPT_GVR_ETX) ? 3 : 1;
if (!stream->read_array(buf, len))
return make_stm32_with_deletor(nullptr);
stm->version = buf[0];
stm->option1 = (stm->flags & STREAM_OPT_GVR_ETX) ? buf[1] : 0;
stm->option2 = (stm->flags & STREAM_OPT_GVR_ETX) ? buf[2] : 0;
if (stm32_get_ack(stm) != STM32_ERR_OK) {
return make_stm32_with_deletor(nullptr);
}
}
{
const auto len = ([&]() {
/* get the bootloader information */
if (stm->cmd_get_reply) {
for (auto i = 0; stm->cmd_get_reply[i].length; ++i) {
if (stm->version == stm->cmd_get_reply[i].version) {
return stm->cmd_get_reply[i].length;
}
}
}
return STM32_CMD_GET_LENGTH;
})();
if (stm32_guess_len_cmd(stm, STM32_CMD_GET, buf, len) != STM32_ERR_OK)
return make_stm32_with_deletor(nullptr);
}
const auto stop = buf[0] + 1;
stm->bl_version = buf[1];
int new_cmds = 0;
for (auto i = 1; i < stop; ++i) {
const auto val = buf[i + 1];
switch (val) {
case STM32_CMD_GET:
stm->cmd->get = val;
break;
case STM32_CMD_GVR:
stm->cmd->gvr = val;
break;
case STM32_CMD_GID:
stm->cmd->gid = val;
break;
case STM32_CMD_RM:
stm->cmd->rm = val;
break;
case STM32_CMD_GO:
stm->cmd->go = val;
break;
case STM32_CMD_WM:
case STM32_CMD_WM_NS:
stm->cmd->wm = newer(stm->cmd->wm, val);
break;
case STM32_CMD_ER:
case STM32_CMD_EE:
case STM32_CMD_EE_NS:
stm->cmd->er = newer(stm->cmd->er, val);
break;
case STM32_CMD_WP:
case STM32_CMD_WP_NS:
stm->cmd->wp = newer(stm->cmd->wp, val);
break;
case STM32_CMD_UW:
case STM32_CMD_UW_NS:
stm->cmd->uw = newer(stm->cmd->uw, val);
break;
case STM32_CMD_RP:
case STM32_CMD_RP_NS:
stm->cmd->rp = newer(stm->cmd->rp, val);
break;
case STM32_CMD_UR:
case STM32_CMD_UR_NS:
stm->cmd->ur = newer(stm->cmd->ur, val);
break;
case STM32_CMD_CRC:
stm->cmd->crc = newer(stm->cmd->crc, val);
break;
default:
if (new_cmds++ == 0) {
ESP_LOGD(TAG, "GET returns unknown commands (0x%2x", val);
} else {
ESP_LOGD(TAG, ", 0x%2x", val);
}
}
}
if (new_cmds)
ESP_LOGD(TAG, ")");
if (stm32_get_ack(stm) != STM32_ERR_OK) {
return make_stm32_with_deletor(nullptr);
}
if (stm->cmd->get == STM32_CMD_ERR || stm->cmd->gvr == STM32_CMD_ERR || stm->cmd->gid == STM32_CMD_ERR) {
ESP_LOGD(TAG, "Error: bootloader did not returned correct information from GET command");
return make_stm32_with_deletor(nullptr);
}
/* get the device ID */
if (stm32_guess_len_cmd(stm, stm->cmd->gid, buf, 1) != STM32_ERR_OK) {
return make_stm32_with_deletor(nullptr);
}
const auto returned = buf[0] + 1;
if (returned < 2) {
ESP_LOGD(TAG, "Only %d bytes sent in the PID, unknown/unsupported device", returned);
return make_stm32_with_deletor(nullptr);
}
stm->pid = (buf[1] << 8) | buf[2];
if (returned > 2) {
ESP_LOGD(TAG, "This bootloader returns %d extra bytes in PID:", returned);
for (auto i = 2; i <= returned; i++)
ESP_LOGD(TAG, " %02x", buf[i]);
}
if (stm32_get_ack(stm) != STM32_ERR_OK) {
return make_stm32_with_deletor(nullptr);
}
stm->dev = DEVICES;
while (stm->dev->id != 0x00 && stm->dev->id != stm->pid)
++stm->dev;
if (!stm->dev->id) {
ESP_LOGD(TAG, "Unknown/unsupported device (Device ID: 0x%03x)", stm->pid);
return make_stm32_with_deletor(nullptr);
}
return stm;
}
stm32_err_t stm32_read_memory(const stm32_unique_ptr &stm, const uint32_t address, uint8_t *data,
const unsigned int len) {
auto *const stream = stm->stream;
if (!len)
return STM32_ERR_OK;
if (len > 256) {
ESP_LOGD(TAG, "Error: READ length limit at 256 bytes");
return STM32_ERR_UNKNOWN;
}
if (stm->cmd->rm == STM32_CMD_ERR) {
ESP_LOGD(TAG, "Error: READ command not implemented in bootloader.");
return STM32_ERR_NO_CMD;
}
if (stm32_send_command(stm, stm->cmd->rm) != STM32_ERR_OK)
return STM32_ERR_UNKNOWN;
static constexpr auto BUFFER_SIZE = 5;
uint8_t buf[BUFFER_SIZE];
populate_buffer_with_address(buf, address);
stream->write_array(buf, BUFFER_SIZE);
stream->flush();
if (stm32_get_ack(stm) != STM32_ERR_OK)
return STM32_ERR_UNKNOWN;
if (stm32_send_command(stm, len - 1) != STM32_ERR_OK)
return STM32_ERR_UNKNOWN;
if (!stream->read_array(data, len))
return STM32_ERR_UNKNOWN;
return STM32_ERR_OK;
}
stm32_err_t stm32_write_memory(const stm32_unique_ptr &stm, uint32_t address, const uint8_t *data,
const unsigned int len) {
auto *const stream = stm->stream;
if (!len)
return STM32_ERR_OK;
if (len > 256) {
ESP_LOGD(TAG, "Error: READ length limit at 256 bytes");
return STM32_ERR_UNKNOWN;
}
/* must be 32bit aligned */
if (address & 0x3) {
ESP_LOGD(TAG, "Error: WRITE address must be 4 byte aligned");
return STM32_ERR_UNKNOWN;
}
if (stm->cmd->wm == STM32_CMD_ERR) {
ESP_LOGD(TAG, "Error: WRITE command not implemented in bootloader.");
return STM32_ERR_NO_CMD;
}
/* send the address and checksum */
if (stm32_send_command(stm, stm->cmd->wm) != STM32_ERR_OK)
return STM32_ERR_UNKNOWN;
static constexpr auto BUFFER_SIZE = 5;
uint8_t buf1[BUFFER_SIZE];
populate_buffer_with_address(buf1, address);
stream->write_array(buf1, BUFFER_SIZE);
stream->flush();
if (stm32_get_ack(stm) != STM32_ERR_OK)
return STM32_ERR_UNKNOWN;
const unsigned int aligned_len = (len + 3) & ~3;
uint8_t cs = aligned_len - 1;
uint8_t buf[256 + 2];
buf[0] = aligned_len - 1;
for (auto i = 0; i < len; i++) {
cs ^= data[i];
buf[i + 1] = data[i];
}
/* padding data */
for (auto i = len; i < aligned_len; i++) {
cs ^= 0xFF;
buf[i + 1] = 0xFF;
}
buf[aligned_len + 1] = cs;
stream->write_array(buf, aligned_len + 2);
stream->flush();
const auto s_err = stm32_get_ack_timeout(stm, STM32_BLKWRITE_TIMEOUT);
if (s_err != STM32_ERR_OK) {
return STM32_ERR_UNKNOWN;
}
return STM32_ERR_OK;
}
stm32_err_t stm32_wunprot_memory(const stm32_unique_ptr &stm) {
if (stm->cmd->uw == STM32_CMD_ERR) {
ESP_LOGD(TAG, "Error: WRITE UNPROTECT command not implemented in bootloader.");
return STM32_ERR_NO_CMD;
}
if (stm32_send_command(stm, stm->cmd->uw) != STM32_ERR_OK)
return STM32_ERR_UNKNOWN;
return stm32_check_ack_timeout(stm32_get_ack_timeout(stm, STM32_WUNPROT_TIMEOUT),
[]() { ESP_LOGD(TAG, "Error: Failed to WRITE UNPROTECT"); });
}
stm32_err_t stm32_wprot_memory(const stm32_unique_ptr &stm) {
if (stm->cmd->wp == STM32_CMD_ERR) {
ESP_LOGD(TAG, "Error: WRITE PROTECT command not implemented in bootloader.");
return STM32_ERR_NO_CMD;
}
if (stm32_send_command(stm, stm->cmd->wp) != STM32_ERR_OK)
return STM32_ERR_UNKNOWN;
return stm32_check_ack_timeout(stm32_get_ack_timeout(stm, STM32_WPROT_TIMEOUT),
[]() { ESP_LOGD(TAG, "Error: Failed to WRITE PROTECT"); });
}
stm32_err_t stm32_runprot_memory(const stm32_unique_ptr &stm) {
if (stm->cmd->ur == STM32_CMD_ERR) {
ESP_LOGD(TAG, "Error: READOUT UNPROTECT command not implemented in bootloader.");
return STM32_ERR_NO_CMD;
}
if (stm32_send_command(stm, stm->cmd->ur) != STM32_ERR_OK)
return STM32_ERR_UNKNOWN;
return stm32_check_ack_timeout(stm32_get_ack_timeout(stm, STM32_MASSERASE_TIMEOUT),
[]() { ESP_LOGD(TAG, "Error: Failed to READOUT UNPROTECT"); });
}
stm32_err_t stm32_readprot_memory(const stm32_unique_ptr &stm) {
if (stm->cmd->rp == STM32_CMD_ERR) {
ESP_LOGD(TAG, "Error: READOUT PROTECT command not implemented in bootloader.");
return STM32_ERR_NO_CMD;
}
if (stm32_send_command(stm, stm->cmd->rp) != STM32_ERR_OK)
return STM32_ERR_UNKNOWN;
return stm32_check_ack_timeout(stm32_get_ack_timeout(stm, STM32_RPROT_TIMEOUT),
[]() { ESP_LOGD(TAG, "Error: Failed to READOUT PROTECT"); });
}
stm32_err_t stm32_erase_memory(const stm32_unique_ptr &stm, uint32_t spage, uint32_t pages) {
if (!pages || spage > STM32_MAX_PAGES || ((pages != STM32_MASS_ERASE) && ((spage + pages) > STM32_MAX_PAGES)))
return STM32_ERR_OK;
if (stm->cmd->er == STM32_CMD_ERR) {
ESP_LOGD(TAG, "Error: ERASE command not implemented in bootloader.");
return STM32_ERR_NO_CMD;
}
if (pages == STM32_MASS_ERASE) {
/*
* Not all chips support mass erase.
* Mass erase can be obtained executing a "readout protect"
* followed by "readout un-protect". This method is not
* suggested because can hang the target if a debug SWD/JTAG
* is connected. When the target enters in "readout
* protection" mode it will consider the debug connection as
* a tentative of intrusion and will hang.
* Erasing the flash page-by-page is the safer way to go.
*/
if (!(stm->dev->flags & F_NO_ME))
return stm32_mass_erase(stm);
pages = flash_addr_to_page_ceil(stm, stm->dev->fl_end);
}
/*
* Some device, like STM32L152, cannot erase more than 512 pages in
* one command. Split the call.
*/
static constexpr uint32_t MAX_PAGE_SIZE = 512;
while (pages) {
const auto n = std::min(pages, MAX_PAGE_SIZE);
const auto s_err = stm32_pages_erase(stm, spage, n);
if (s_err != STM32_ERR_OK)
return s_err;
spage += n;
pages -= n;
}
return STM32_ERR_OK;
}
static stm32_err_t stm32_run_raw_code(const stm32_unique_ptr &stm, uint32_t target_address, const uint8_t *code,
uint32_t code_size) {
static constexpr uint32_t BUFFER_SIZE = 256;
const auto stack_le = le_u32(0x20002000);
const auto code_address_le = le_u32(target_address + 8 + 1); // thumb mode address (!)
uint32_t length = code_size + 8;
/* Must be 32-bit aligned */
if (target_address & 0x3) {
ESP_LOGD(TAG, "Error: code address must be 4 byte aligned");
return STM32_ERR_UNKNOWN;
}
// Could be constexpr in c++17
static const auto DELETOR = [](uint8_t *memory) {
free(memory); // NOLINT
};
// Free memory with RAII
std::unique_ptr<uint8_t, decltype(DELETOR)> mem{static_cast<uint8_t *>(malloc(length)), // NOLINT
DELETOR};
if (!mem)
return STM32_ERR_UNKNOWN;
memcpy(mem.get(), &stack_le, sizeof(stack_le));
memcpy(mem.get() + 4, &code_address_le, sizeof(code_address_le));
memcpy(mem.get() + 8, code, code_size);
auto *pos = mem.get();
auto address = target_address;
while (length > 0) {
const auto w = std::min(length, BUFFER_SIZE);
if (stm32_write_memory(stm, address, pos, w) != STM32_ERR_OK) {
return STM32_ERR_UNKNOWN;
}
address += w;
pos += w;
length -= w;
}
return stm32_go(stm, target_address);
}
stm32_err_t stm32_go(const stm32_unique_ptr &stm, const uint32_t address) {
auto *const stream = stm->stream;
if (stm->cmd->go == STM32_CMD_ERR) {
ESP_LOGD(TAG, "Error: GO command not implemented in bootloader.");
return STM32_ERR_NO_CMD;
}
if (stm32_send_command(stm, stm->cmd->go) != STM32_ERR_OK)
return STM32_ERR_UNKNOWN;
static constexpr auto BUFFER_SIZE = 5;
uint8_t buf[BUFFER_SIZE];
populate_buffer_with_address(buf, address);
stream->write_array(buf, BUFFER_SIZE);
stream->flush();
if (stm32_get_ack(stm) != STM32_ERR_OK)
return STM32_ERR_UNKNOWN;
return STM32_ERR_OK;
}
stm32_err_t stm32_reset_device(const stm32_unique_ptr &stm) {
const auto target_address = stm->dev->ram_start;
if (stm->dev->flags & F_OBLL) {
/* set the OBL_LAUNCH bit to reset device (see RM0360, 2.5) */
return stm32_run_raw_code(stm, target_address, STM_OBL_LAUNCH_CODE, STM_OBL_LAUNCH_CODE_SIZE);
} else {
return stm32_run_raw_code(stm, target_address, STM_RESET_CODE, STM_RESET_CODE_SIZE);
}
}
stm32_err_t stm32_crc_memory(const stm32_unique_ptr &stm, const uint32_t address, const uint32_t length,
uint32_t *const crc) {
static constexpr auto BUFFER_SIZE = 5;
auto *const stream = stm->stream;
if (address & 0x3 || length & 0x3) {
ESP_LOGD(TAG, "Start and end addresses must be 4 byte aligned");
return STM32_ERR_UNKNOWN;
}
if (stm->cmd->crc == STM32_CMD_ERR) {
ESP_LOGD(TAG, "Error: CRC command not implemented in bootloader.");
return STM32_ERR_NO_CMD;
}
if (stm32_send_command(stm, stm->cmd->crc) != STM32_ERR_OK)
return STM32_ERR_UNKNOWN;
{
static constexpr auto BUFFER_SIZE = 5;
uint8_t buf[BUFFER_SIZE];
populate_buffer_with_address(buf, address);
stream->write_array(buf, BUFFER_SIZE);
stream->flush();
}
if (stm32_get_ack(stm) != STM32_ERR_OK)
return STM32_ERR_UNKNOWN;
{
static constexpr auto BUFFER_SIZE = 5;
uint8_t buf[BUFFER_SIZE];
populate_buffer_with_address(buf, address);
stream->write_array(buf, BUFFER_SIZE);
stream->flush();
}
if (stm32_get_ack(stm) != STM32_ERR_OK)
return STM32_ERR_UNKNOWN;
if (stm32_get_ack(stm) != STM32_ERR_OK)
return STM32_ERR_UNKNOWN;
{
uint8_t buf[BUFFER_SIZE];
if (!stream->read_array(buf, BUFFER_SIZE))
return STM32_ERR_UNKNOWN;
if (buf[4] != (buf[0] ^ buf[1] ^ buf[2] ^ buf[3]))
return STM32_ERR_UNKNOWN;
*crc = (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
}
return STM32_ERR_OK;
}
/*
* CRC computed by STM32 is similar to the standard crc32_be()
* implemented, for example, in Linux kernel in ./lib/crc32.c
* But STM32 computes it on units of 32 bits word and swaps the
* bytes of the word before the computation.
* Due to byte swap, I cannot use any CRC available in existing
* libraries, so here is a simple not optimized implementation.
*/
uint32_t stm32_sw_crc(uint32_t crc, uint8_t *buf, unsigned int len) {
static constexpr uint32_t CRCPOLY_BE = 0x04c11db7;
static constexpr uint32_t CRC_MSBMASK = 0x80000000;
if (len & 0x3) {
ESP_LOGD(TAG, "Buffer length must be multiple of 4 bytes");
return 0;
}
while (len) {
uint32_t data = *buf++;
data |= *buf++ << 8;
data |= *buf++ << 16;
data |= *buf++ << 24;
len -= 4;
crc ^= data;
for (size_t i = 0; i < 32; ++i) {
if (crc & CRC_MSBMASK) {
crc = (crc << 1) ^ CRCPOLY_BE;
} else {
crc = (crc << 1);
}
}
}
return crc;
}
stm32_err_t stm32_crc_wrapper(const stm32_unique_ptr &stm, uint32_t address, uint32_t length, uint32_t *crc) {
static constexpr uint32_t CRC_INIT_VALUE = 0xFFFFFFFF;
static constexpr uint32_t BUFFER_SIZE = 256;
uint8_t buf[BUFFER_SIZE];
if (address & 0x3 || length & 0x3) {
ESP_LOGD(TAG, "Start and end addresses must be 4 byte aligned");
return STM32_ERR_UNKNOWN;
}
if (stm->cmd->crc != STM32_CMD_ERR)
return stm32_crc_memory(stm, address, length, crc);
const auto start = address;
const auto total_len = length;
uint32_t current_crc = CRC_INIT_VALUE;
while (length) {
const auto len = std::min(BUFFER_SIZE, length);
if (stm32_read_memory(stm, address, buf, len) != STM32_ERR_OK) {
ESP_LOGD(TAG, "Failed to read memory at address 0x%08x, target write-protected?", address);
return STM32_ERR_UNKNOWN;
}
current_crc = stm32_sw_crc(current_crc, buf, len);
length -= len;
address += len;
ESP_LOGD(TAG, "\rCRC address 0x%08x (%.2f%%) ", address, (100.0f / (float) total_len) * (float) (address - start));
}
ESP_LOGD(TAG, "Done.");
*crc = current_crc;
return STM32_ERR_OK;
}
} // namespace shelly_dimmer
} // namespace esphome
#endif // USE_SHD_FIRMWARE_DATA
Reference in New Issue View Git Blame Copy Permalink