// SPDX-License-Identifier: GPL-2.0+ OR BSD-3-Clause
/*
* Copyright (C) 2020, STMicroelectronics - All Rights Reserved
*/
#include <command.h>
#include <console.h>
#include <dfu.h>
#include <image.h>
#include <malloc.h>
#include <misc.h>
#include <mmc.h>
#include <part.h>
#include <tee.h>
#include <asm/arch/stm32mp1_smc.h>
#include <asm/global_data.h>
#include <dm/device_compat.h>
#include <dm/uclass.h>
#include <jffs2/load_kernel.h>
#include <linux/list.h>
#include <linux/list_sort.h>
#include <linux/mtd/mtd.h>
#include <linux/printk.h>
#include <linux/sizes.h>
#include "stm32prog.h"
/* Primary GPT header size for 128 entries : 17kB = 34 LBA of 512B */
#define GPT_HEADER_SZ 34
#define OPT_SELECT BIT(0)
#define OPT_EMPTY BIT(1)
#define OPT_DELETE BIT(2)
#define IS_SELECT(part) ((part)->option & OPT_SELECT)
#define IS_EMPTY(part) ((part)->option & OPT_EMPTY)
#define IS_DELETE(part) ((part)->option & OPT_DELETE)
#define ALT_BUF_LEN SZ_1K
#define ROOTFS_MMC0_UUID \
EFI_GUID(0xE91C4E10, 0x16E6, 0x4C0E, \
0xBD, 0x0E, 0x77, 0xBE, 0xCF, 0x4A, 0x35, 0x82)
#define ROOTFS_MMC1_UUID \
EFI_GUID(0x491F6117, 0x415D, 0x4F53, \
0x88, 0xC9, 0x6E, 0x0D, 0xE5, 0x4D, 0xEA, 0xC6)
#define ROOTFS_MMC2_UUID \
EFI_GUID(0xFD58F1C7, 0xBE0D, 0x4338, \
0x88, 0xE9, 0xAD, 0x8F, 0x05, 0x0A, 0xEB, 0x18)
/* RAW partition (binary / bootloader) used Linux - reserved UUID */
#define LINUX_RESERVED_UUID "8DA63339-0007-60C0-C436-083AC8230908"
/*
* unique partition guid (uuid) for partition named "rootfs"
* on each MMC instance = SD Card or eMMC
* allow fixed kernel bootcmd: "rootf=PARTUID=e91c4e10-..."
*/
static const efi_guid_t uuid_mmc[3] = {
ROOTFS_MMC0_UUID,
ROOTFS_MMC1_UUID,
ROOTFS_MMC2_UUID
};
/*
* GUID value defined in the FWU specification for identification
* of the FWU metadata partition.
*/
#define FWU_MDATA_UUID "8a7a84a0-8387-40f6-ab41-a8b9a5a60d23"
/* FIP type partition UUID used by TF-A*/
#define FIP_TYPE_UUID "19D5DF83-11B0-457B-BE2C-7559C13142A5"
/* unique partition guid (uuid) for FIP partitions A/B */
#define FIP_A_UUID \
EFI_GUID(0x4FD84C93, 0x54EF, 0x463F, \
0xA7, 0xEF, 0xAE, 0x25, 0xFF, 0x88, 0x70, 0x87)
#define FIP_B_UUID \
EFI_GUID(0x09C54952, 0xD5BF, 0x45AF, \
0xAC, 0xEE, 0x33, 0x53, 0x03, 0x76, 0x6F, 0xB3)
static const char * const fip_part_name[] = {
"fip-a",
"fip-b"
};
static const efi_guid_t fip_part_uuid[] = {
FIP_A_UUID,
FIP_B_UUID
};
/* order of column in flash layout file */
enum stm32prog_col_t {
COL_OPTION,
COL_ID,
COL_NAME,
COL_TYPE,
COL_IP,
COL_OFFSET,
COL_NB_STM32
};
#define FIP_TOC_HEADER_NAME 0xAA640001
struct fip_toc_header {
u32 name;
u32 serial_number;
u64 flags;
};
#define TA_NVMEM_UUID { 0x1a8342cc, 0x81a5, 0x4512, \
{ 0x99, 0xfe, 0x9e, 0x2b, 0x3e, 0x37, 0xd6, 0x26 } }
/*
* Read NVMEM memory for STM32CubeProgrammer
*
* [in] value[0].a: Type (0 for OTP access)
* [out] memref[1].buffer Output buffer to return all read values
* [out] memref[1].size Size of buffer to be read
*
* Return codes:
* TEE_SUCCESS - Invoke command success
* TEE_ERROR_BAD_PARAMETERS - Incorrect input param
*/
#define TA_NVMEM_READ 0x0
/*
* Write NVMEM memory for STM32CubeProgrammer
*
* [in] value[0].a Type (0 for OTP access)
* [in] memref[1].buffer Input buffer with the values to write
* [in] memref[1].size Size of buffer to be written
*
* Return codes:
* TEE_SUCCESS - Invoke command success
* TEE_ERROR_BAD_PARAMETERS - Incorrect input param
*/
#define TA_NVMEM_WRITE 0x1
/* value of TA_NVMEM type = value[in] a */
#define NVMEM_OTP 0
DECLARE_GLOBAL_DATA_PTR;
/* OPTEE TA NVMEM open helper */
static int optee_ta_open(struct stm32prog_data *data)
{
const struct tee_optee_ta_uuid uuid = TA_NVMEM_UUID;
struct tee_open_session_arg arg;
struct udevice *tee = NULL;
int rc;
if (data->tee)
return 0;
tee = tee_find_device(NULL, NULL, NULL, NULL);
if (!tee)
return -ENODEV;
memset(&arg, 0, sizeof(arg));
tee_optee_ta_uuid_to_octets(arg.uuid, &uuid);
rc = tee_open_session(tee, &arg, 0, NULL);
if (rc < 0)
return -ENODEV;
data->tee = tee;
data->tee_session = arg.session;
return 0;
}
/* OPTEE TA NVMEM invoke helper */
static int optee_ta_invoke(struct stm32prog_data *data, int cmd, int type,
void *buff, ulong size)
{
struct tee_invoke_arg arg;
struct tee_param param[2];
struct tee_shm *buff_shm;
int rc;
rc = tee_shm_register(data->tee, buff, size, 0, &buff_shm);
if (rc)
return rc;
memset(&arg, 0, sizeof(arg));
arg.func = cmd;
arg.session = data->tee_session;
memset(param, 0, sizeof(param));
param[0].attr = TEE_PARAM_ATTR_TYPE_VALUE_INPUT;
param[0].u.value.a = type;
if (cmd == TA_NVMEM_WRITE)
param[1].attr = TEE_PARAM_ATTR_TYPE_MEMREF_INPUT;
else
param[1].attr = TEE_PARAM_ATTR_TYPE_MEMREF_OUTPUT;
param[1].u.memref.shm = buff_shm;
param[1].u.memref.size = size;
rc = tee_invoke_func(data->tee, &arg, 2, param);
if (rc < 0 || arg.ret != 0) {
dev_err(data->tee,
"TA_NVMEM invoke failed TEE err: %x, err:%x\n",
arg.ret, rc);
if (!rc)
rc = -EIO;
}
tee_shm_free(buff_shm);
return rc;
}
char *stm32prog_get_error(struct stm32prog_data *data)
{
static const char error_msg[] = "Unspecified";
if (strlen(data->error) == 0)
strcpy(data->error, error_msg);
return data->error;
}
static bool stm32prog_is_fip_header(struct fip_toc_header *header)
{
return (header->name == FIP_TOC_HEADER_NAME) && header->serial_number;
}
static bool stm32prog_is_stm32_header_v1(struct stm32_header_v1 *header)
{
unsigned int i;
if (header->magic_number !=
(('S' << 0) | ('T' << 8) | ('M' << 16) | (0x32 << 24))) {
log_debug("%s:invalid magic number : 0x%x\n",
__func__, header->magic_number);
return false;
}
if (header->header_version != 0x00010000) {
log_debug("%s:invalid header version : 0x%x\n",
__func__, header->header_version);
return false;
}
if (header->reserved1 || header->reserved2) {
log_debug("%s:invalid reserved field\n", __func__);
return false;
}
for (i = 0; i < sizeof(header->padding); i++) {
if (header->padding[i] != 0) {
log_debug("%s:invalid padding field\n", __func__);
return false;
}
}
return true;
}
static bool stm32prog_is_stm32_header_v2(struct stm32_header_v2 *header)
{
unsigned int i;
if (header->magic_number !=
(('S' << 0) | ('T' << 8) | ('M' << 16) | (0x32 << 24))) {
log_debug("%s:invalid magic number : 0x%x\n",
__func__, header->magic_number);
return false;
}
if (header->header_version != 0x00020000) {
log_debug("%s:invalid header version : 0x%x\n",
__func__, header->header_version);
return false;
}
if (header->reserved1 || header->reserved2)
return false;
for (i = 0; i < sizeof(header->padding); i++) {
if (header->padding[i] != 0) {
log_debug("%s:invalid padding field\n", __func__);
return false;
}
}
return true;
}
void stm32prog_header_check(uintptr_t raw_header, struct image_header_s *header)
{
struct stm32_header_v1 *v1_header = (struct stm32_header_v1 *)raw_header;
struct stm32_header_v2 *v2_header = (struct stm32_header_v2 *)raw_header;
if (!raw_header || !header) {
log_debug("%s:no header data\n", __func__);
return;
}
if (stm32prog_is_fip_header((struct fip_toc_header *)raw_header)) {
header->type = HEADER_FIP;
header->length = 0;
return;
}
if (stm32prog_is_stm32_header_v1(v1_header)) {
header->type = HEADER_STM32IMAGE;
header->image_checksum = le32_to_cpu(v1_header->image_checksum);
header->image_length = le32_to_cpu(v1_header->image_length);
header->length = sizeof(struct stm32_header_v1);
return;
}
if (stm32prog_is_stm32_header_v2(v2_header)) {
header->type = HEADER_STM32IMAGE_V2;
header->image_checksum = le32_to_cpu(v2_header->image_checksum);
header->image_length = le32_to_cpu(v2_header->image_length);
header->length = sizeof(struct stm32_header_v1) +
v2_header->extension_headers_length;
return;
}
header->type = HEADER_NONE;
header->image_checksum = 0x0;
header->image_length = 0x0;
}
static u32 stm32prog_header_checksum(uintptr_t addr, struct image_header_s *header)
{
u32 i, checksum;
u8 *payload;
/* compute checksum on payload */
payload = (u8 *)addr;
checksum = 0;
for (i = header->image_length; i > 0; i--)
checksum += *(payload++);
return checksum;
}
/* FLASHLAYOUT PARSING *****************************************/
static int parse_option(struct stm32prog_data *data,
int i, char *p, struct stm32prog_part_t *part)
{
int result = 0;
char *c = p;
part->option = 0;
if (!strcmp(p, "-"))
return 0;
while (*c) {
switch (*c) {
case 'P':
part->option |= OPT_SELECT;
break;
case 'E':
part->option |= OPT_EMPTY;
break;
case 'D':
part->option |= OPT_DELETE;
break;
default:
result = -EINVAL;
stm32prog_err("Layout line %d: invalid option '%c' in %s)",
i, *c, p);
return -EINVAL;
}
c++;
}
if (!(part->option & OPT_SELECT)) {
stm32prog_err("Layout line %d: missing 'P' in option %s", i, p);
return -EINVAL;
}
return result;
}
static int parse_id(struct stm32prog_data *data,
int i, char *p, struct stm32prog_part_t *part)
{
int result = 0;
unsigned long value;
result = strict_strtoul(p, 0, &value);
part->id = value;
if (result || value > PHASE_LAST_USER) {
stm32prog_err("Layout line %d: invalid phase value = %s", i, p);
result = -EINVAL;
}
return result;
}
static int parse_name(struct stm32prog_data *data,
int i, char *p, struct stm32prog_part_t *part)
{
int result = 0;
if (strlen(p) < sizeof(part->name)) {
strcpy(part->name, p);
} else {
stm32prog_err("Layout line %d: partition name too long [%zd]: %s",
i, strlen(p), p);
result = -EINVAL;
}
return result;
}
static int parse_type(struct stm32prog_data *data,
int i, char *p, struct stm32prog_part_t *part)
{
int result = 0;
int len = 0;
part->bin_nb = 0;
if (!strncmp(p, "Binary", 6)) {
part->part_type = PART_BINARY;
/* search for Binary(X) case */
len = strlen(p);
part->bin_nb = 1;
if (len > 6) {
if (len < 8 ||
(p[6] != '(') ||
(p[len - 1] != ')'))
result = -EINVAL;
else
part->bin_nb =
dectoul(&p[7], NULL);
}
} else if (!strcmp(p, "FIP")) {
part->part_type = PART_FIP;
} else if (!strcmp(p, "FWU_MDATA")) {
part->part_type = PART_FWU_MDATA;
} else if (!strcmp(p, "ENV")) {
part->part_type = PART_ENV;
} else if (!strcmp(p, "System")) {
part->part_type = PART_SYSTEM;
} else if (!strcmp(p, "ESP")) {
part->part_type = PART_ESP;
} else if (!strcmp(p, "FileSystem")) {
part->part_type = PART_FILESYSTEM;
} else if (!strcmp(p, "RawImage")) {
part->part_type = RAW_IMAGE;
} else {
result = -EINVAL;
}
if (result)
stm32prog_err("Layout line %d: type parsing error : '%s'",
i, p);
return result;
}
static int parse_ip(struct stm32prog_data *data,
int i, char *p, struct stm32prog_part_t *part)
{
int result = 0;
unsigned int len = 0;
part->dev_id = 0;
if (!strcmp(p, "none")) {
part->target = STM32PROG_NONE;
} else if (!strncmp(p, "mmc", 3)) {
part->target = STM32PROG_MMC;
len = 3;
} else if (!strncmp(p, "nor", 3)) {
part->target = STM32PROG_NOR;
len = 3;
} else if (!strncmp(p, "nand", 4)) {
part->target = STM32PROG_NAND;
len = 4;
} else if (!strncmp(p, "spi-nand", 8)) {
part->target = STM32PROG_SPI_NAND;
len = 8;
} else if (!strncmp(p, "ram", 3)) {
part->target = STM32PROG_RAM;
len = 0;
} else {
result = -EINVAL;
}
if (len) {
/* only one digit allowed for device id */
if (strlen(p) != len + 1) {
result = -EINVAL;
} else {
part->dev_id = p[len] - '0';
if (part->dev_id > 9)
result = -EINVAL;
}
}
if (result)
stm32prog_err("Layout line %d: ip parsing error: '%s'", i, p);
return result;
}
static int parse_offset(struct stm32prog_data *data,
int i, char *p, struct stm32prog_part_t *part)
{
int result = 0;
char *tail;
part->part_id = 0;
part->addr = 0;
part->size = 0;
/* eMMC boot parttion */
if (!strncmp(p, "boot", 4)) {
if (strlen(p) != 5) {
result = -EINVAL;
} else {
if (p[4] == '1')
part->part_id = -1;
else if (p[4] == '2')
part->part_id = -2;
else
result = -EINVAL;
}
if (result)
stm32prog_err("Layout line %d: invalid part '%s'",
i, p);
} else {
part->addr = simple_strtoull(p, &tail, 10);
if (tail == p || *tail != '\0') {
stm32prog_err("Layout line %d: invalid offset '%s'",
i, p);
result = -EINVAL;
}
}
return result;
}
static
int (* const parse[COL_NB_STM32])(struct stm32prog_data *data, int i, char *p,
struct stm32prog_part_t *part) = {
[COL_OPTION] = parse_option,
[COL_ID] = parse_id,
[COL_NAME] = parse_name,
[COL_TYPE] = parse_type,
[COL_IP] = parse_ip,
[COL_OFFSET] = parse_offset,
};
static int parse_flash_layout(struct stm32prog_data *data,
uintptr_t addr,
ulong size)
{
int column = 0, part_nb = 0, ret;
bool end_of_line, eof;
char *p, *start, *last, *col;
struct stm32prog_part_t *part;
struct image_header_s header;
int part_list_size;
int i;
data->part_nb = 0;
/* check if STM32image is detected */
stm32prog_header_check(addr, &header);
if (header.type == HEADER_STM32IMAGE) {
u32 checksum;
addr = addr + header.length;
size = header.image_length;
checksum = stm32prog_header_checksum(addr, &header);
if (checksum != header.image_checksum) {
stm32prog_err("Layout: invalid checksum : 0x%x expected 0x%x",
checksum, header.image_checksum);
return -EIO;
}
}
if (!size)
return -EINVAL;
start = (char *)addr;
last = start + size;
*last = 0x0; /* force null terminated string */
log_debug("flash layout =\n%s\n", start);
/* calculate expected number of partitions */
part_list_size = 1;
p = start;
while (*p && (p < last)) {
if (*p++ == '\n') {
part_list_size++;
if (p < last && *p == '#')
part_list_size--;
}
}
if (part_list_size > PHASE_LAST_USER) {
stm32prog_err("Layout: too many partition (%d)",
part_list_size);
return -1;
}
part = calloc(sizeof(struct stm32prog_part_t), part_list_size);
if (!part) {
stm32prog_err("Layout: alloc failed");
return -ENOMEM;
}
data->part_array = part;
/* main parsing loop */
i = 1;
eof = false;
p = start;
col = start; /* 1st column */
end_of_line = false;
while (!eof) {
switch (*p) {
/* CR is ignored and replaced by NULL character */
case '\r':
*p = '\0';
p++;
continue;
case '\0':
end_of_line = true;
eof = true;
break;
case '\n':
end_of_line = true;
break;
case '\t':
break;
case '#':
/* comment line is skipped */
if (column == 0 && p == col) {
while ((p < last) && *p)
if (*p++ == '\n')
break;
col = p;
i++;
if (p >= last || !*p) {
eof = true;
end_of_line = true;
}
continue;
}
/* fall through */
/* by default continue with the next character */
default:
p++;
continue;
}
/* replace by \0: allow string parsing for each column */
*p = '\0';
p++;
if (p >= last) {
eof = true;
end_of_line = true;
}
/* skip empty line and multiple TAB in tsv file */
if (strlen(col) == 0) {
col = p;
/* skip empty line */
if (column == 0 && end_of_line) {
end_of_line = false;
i++;
}
continue;
}
if (column < COL_NB_STM32) {
ret = parse[column](data, i, col, part);
if (ret)
return ret;
}
/* save the beginning of the next column */
column++;
col = p;
if (!end_of_line)
continue;
/* end of the line detected */
end_of_line = false;
if (column < COL_NB_STM32) {
stm32prog_err("Layout line %d: no enought column", i);
return -EINVAL;
}
column = 0;
part_nb++;
part++;
i++;
if (part_nb >= part_list_size) {
part = NULL;
if (!eof) {
stm32prog_err("Layout: no enought memory for %d part",
part_nb);
return -EINVAL;
}
}
}
data->part_nb = part_nb;
if (data->part_nb == 0) {
stm32prog_err("Layout: no partition found");
return -ENODEV;
}
return 0;
}
static int __init part_cmp(void *priv, struct list_head *a, struct list_head *b)
{
struct stm32prog_part_t *parta, *partb;
parta = container_of(a, struct stm32prog_part_t, list);
partb = container_of(b, struct stm32prog_part_t, list);
if (parta->part_id != partb->part_id)
return parta->part_id - partb->part_id;
else
return parta->addr > partb->addr ? 1 : -1;
}
static void get_mtd_by_target(char *string, enum stm32prog_target target,
int dev_id)
{
const char *dev_str;
switch (target) {
case STM32PROG_NOR:
dev_str = "nor";
break;
case STM32PROG_NAND:
dev_str = "nand";
break;
case STM32PROG_SPI_NAND:
dev_str = "spi-nand";
break;
default:
dev_str = "invalid";
break;
}
sprintf(string, "%s%d", dev_str, dev_id);
}
static int init_device(struct stm32prog_data *data,
struct stm32prog_dev_t *dev)
{
struct mmc *mmc = NULL;
struct blk_desc *block_dev = NULL;
struct mtd_info *mtd = NULL;
struct mtd_info *partition;
char mtd_id[16];
int part_id;
int ret;
u64 first_addr = 0, last_addr = 0;
struct stm32prog_part_t *part, *next_part;
u64 part_addr, part_size;
bool part_found;
const char *part_name;
u8 i;
switch (dev->target) {
case STM32PROG_MMC:
if (!IS_ENABLED(CONFIG_MMC)) {
stm32prog_err("unknown device type = %d", dev->target);
return -ENODEV;
}
mmc = find_mmc_device(dev->dev_id);
if (!mmc || mmc_init(mmc)) {
stm32prog_err("mmc device %d not found", dev->dev_id);
return -ENODEV;
}
block_dev = mmc_get_blk_desc(mmc);
if (!block_dev) {
stm32prog_err("mmc device %d not probed", dev->dev_id);
return -ENODEV;
}
dev->erase_size = mmc->erase_grp_size * block_dev->blksz;
dev->mmc = mmc;
/* reserve a full erase group for each GTP headers */
if (mmc->erase_grp_size > GPT_HEADER_SZ) {
first_addr = dev->erase_size;
last_addr = (u64)(block_dev->lba -
mmc->erase_grp_size) *
block_dev->blksz;
} else {
first_addr = (u64)GPT_HEADER_SZ * block_dev->blksz;
last_addr = (u64)(block_dev->lba - GPT_HEADER_SZ - 1) *
block_dev->blksz;
}
log_debug("MMC %d: lba=%ld blksz=%ld\n", dev->dev_id,
block_dev->lba, block_dev->blksz);
log_debug(" available address = 0x%llx..0x%llx\n",
first_addr, last_addr);
log_debug(" full_update = %d\n", dev->full_update);
break;
case STM32PROG_NOR:
case STM32PROG_NAND:
case STM32PROG_SPI_NAND:
if (!IS_ENABLED(CONFIG_MTD)) {
stm32prog_err("unknown device type = %d", dev->target);
return -ENODEV;
}
/* register partitions with MTDIDS/MTDPARTS or OF fallback */
mtd_probe_devices();
get_mtd_by_target(mtd_id, dev->target, dev->dev_id);
log_debug("%s\n", mtd_id);
mtd = get_mtd_device_nm(mtd_id);
if (IS_ERR(mtd)) {
stm32prog_err("MTD device %s not found", mtd_id);
return -ENODEV;
}
first_addr = 0;
last_addr = mtd->size;
dev->erase_size = mtd->erasesize;
log_debug("MTD device %s: size=%lld erasesize=%d\n",
mtd_id, mtd->size, mtd->erasesize);
log_debug(" available address = 0x%llx..0x%llx\n",
first_addr, last_addr);
dev->mtd = mtd;
break;
case STM32PROG_RAM:
first_addr = gd->bd->bi_dram[0].start;
last_addr = first_addr + gd->bd->bi_dram[0].size;
dev->erase_size = 1;
break;
default:
stm32prog_err("unknown device type = %d", dev->target);
return -ENODEV;
}
log_debug(" erase size = 0x%x\n", dev->erase_size);
log_debug(" full_update = %d\n", dev->full_update);
/* order partition list in offset order */
list_sort(NULL, &dev->part_list, &part_cmp);
part_id = 1;
log_debug("id : Opt Phase Name target.n dev.n addr size part_off part_size\n");
list_for_each_entry(part, &dev->part_list, list) {
if (part->bin_nb > 1) {
if ((dev->target != STM32PROG_NAND &&
dev->target != STM32PROG_SPI_NAND) ||
part->id >= PHASE_FIRST_USER ||
strncmp(part->name, "fsbl", 4)) {
stm32prog_err("%s (0x%x): multiple binary %d not supported",
part->name, part->id,
part->bin_nb);
return -EINVAL;
}
}
if (part->part_type == RAW_IMAGE) {
part->part_id = 0x0;
part->addr = 0x0;
if (block_dev)
part->size = block_dev->lba * block_dev->blksz;
else
part->size = last_addr;
log_debug("-- : %1d %02x %14s %02d.%d %02d.%02d %08llx %08llx\n",
part->option, part->id, part->name,
part->part_type, part->bin_nb, part->target,
part->dev_id, part->addr, part->size);
continue;
}
if (part->part_id < 0) { /* boot hw partition for eMMC */
if (mmc) {
part->size = mmc->capacity_boot;
} else {
stm32prog_err("%s (0x%x): hw partition not expected : %d",
part->name, part->id,
part->part_id);
return -ENODEV;
}
} else {
part->part_id = part_id++;
/* last partition : size to the end of the device */
if (part->list.next != &dev->part_list) {
next_part =
container_of(part->list.next,
struct stm32prog_part_t,
list);
if (part->addr < next_part->addr) {
part->size = next_part->addr -
part->addr;
} else {
stm32prog_err("%s (0x%x): same address : 0x%llx == %s (0x%x): 0x%llx",
part->name, part->id,
part->addr,
next_part->name,
next_part->id,
next_part->addr);
return -EINVAL;
}
} else {
if (part->addr <= last_addr) {
part->size = last_addr - part->addr;
} else {
stm32prog_err("%s (0x%x): invalid address 0x%llx (max=0x%llx)",
part->name, part->id,
part->addr, last_addr);
return -EINVAL;
}
}
if (part->addr < first_addr) {
stm32prog_err("%s (0x%x): invalid address 0x%llx (min=0x%llx)",
part->name, part->id,
part->addr, first_addr);
return -EINVAL;
}
}
if ((part->addr & ((u64)part->dev->erase_size - 1)) != 0) {
stm32prog_err("%s (0x%x): not aligned address : 0x%llx on erase size 0x%x",
part->name, part->id, part->addr,
part->dev->erase_size);
return -EINVAL;
}
log_debug("%02d : %1d %02x %14s %02d.%d %02d.%02d %08llx %08llx",
part->part_id, part->option, part->id, part->name,
part->part_type, part->bin_nb, part->target,
part->dev_id, part->addr, part->size);
part_addr = 0;
part_size = 0;
part_found = false;
/* check coherency with existing partition */
if (block_dev) {
/*
* block devices with GPT: check user partition size
* only for partial update, the GPT partions are be
* created for full update
*/
if (dev->full_update || part->part_id < 0) {
log_debug("\n");
continue;
}
struct disk_partition partinfo;
ret = part_get_info(block_dev, part->part_id,
&partinfo);
if (ret) {
stm32prog_err("%s (0x%x):Couldn't find part %d on device mmc %d",
part->name, part->id,
part_id, part->dev_id);
return -ENODEV;
}
part_addr = (u64)partinfo.start * partinfo.blksz;
part_size = (u64)partinfo.size * partinfo.blksz;
part_name = (char *)partinfo.name;
part_found = true;
}
if (IS_ENABLED(CONFIG_MTD) && mtd) {
i = 0;
list_for_each_entry(partition, &mtd->partitions, node) {
if ((part->part_id - 1) == i) {
part_found = true;
break;
}
i++;
}
if (part_found) {
part_addr = partition->offset;
part_size = partition->size;
part_name = partition->name;
} else {
stm32prog_err("%s (0x%x):Couldn't find part %d on device mtd %s",
part->name, part->id, part->part_id, mtd_id);
return -ENODEV;
}
}
/* no partition for this device */
if (!part_found) {
log_debug("\n");
continue;
}
log_debug(" %08llx %08llx\n", part_addr, part_size);
if (part->addr != part_addr) {
stm32prog_err("%s (0x%x): Bad address for partition %d (%s) = 0x%llx <> 0x%llx expected",
part->name, part->id, part->part_id,
part_name, part->addr, part_addr);
return -ENODEV;
}
if (part->size != part_size) {
stm32prog_err("%s (0x%x): Bad size for partition %d (%s) at 0x%llx = 0x%llx <> 0x%llx expected",
part->name, part->id, part->part_id,
part_name, part->addr, part->size,
part_size);
return -ENODEV;
}
}
return 0;
}
static int treat_partition_list(struct stm32prog_data *data)
{
int i, j;
struct stm32prog_part_t *part;
for (j = 0; j < STM32PROG_MAX_DEV; j++) {
data->dev[j].target = STM32PROG_NONE;
INIT_LIST_HEAD(&data->dev[j].part_list);
}
data->fsbl_nor_detected = false;
for (i = 0; i < data->part_nb; i++) {
part = &data->part_array[i];
part->alt_id = -1;
/* skip partition with IP="none" */
if (part->target == STM32PROG_NONE) {
if (IS_SELECT(part)) {
stm32prog_err("Layout: selected none phase = 0x%x for part %s",
part->id, part->name);
return -EINVAL;
}
continue;
}
if (part->id == PHASE_FLASHLAYOUT ||
part->id > PHASE_LAST_USER) {
stm32prog_err("Layout: invalid phase = 0x%x for part %s",
part->id, part->name);
return -EINVAL;
}
for (j = i + 1; j < data->part_nb; j++) {
if (part->id == data->part_array[j].id) {
stm32prog_err("Layout: duplicated phase 0x%x for part %s and %s",
part->id, part->name, data->part_array[j].name);
return -EINVAL;
}
}
for (j = 0; j < STM32PROG_MAX_DEV; j++) {
if (data->dev[j].target == STM32PROG_NONE) {
/* new device found */
data->dev[j].target = part->target;
data->dev[j].dev_id = part->dev_id;
data->dev[j].full_update = true;
data->dev_nb++;
break;
} else if ((part->target == data->dev[j].target) &&
(part->dev_id == data->dev[j].dev_id)) {
break;
}
}
if (j == STM32PROG_MAX_DEV) {
stm32prog_err("Layout: too many device");
return -EINVAL;
}
switch (part->target) {
case STM32PROG_NOR:
if (!data->fsbl_nor_detected &&
!strncmp(part->name, "fsbl", 4))
data->fsbl_nor_detected = true;
/* fallthrough */
default:
break;
}
part->dev = &data->dev[j];
if (!IS_SELECT(part))
part->dev->full_update = false;
list_add_tail(&part->list, &data->dev[j].part_list);
}
return 0;
}
static int create_gpt_partitions(struct stm32prog_data *data)
{
int offset = 0;
const int buflen = SZ_8K;
char *buf;
char uuid[UUID_STR_LEN + 1];
unsigned char *uuid_bin;
unsigned int mmc_id;
int i, j;
bool rootfs_found;
struct stm32prog_part_t *part;
const char *type_str;
buf = malloc(buflen);
if (!buf)
return -ENOMEM;
/* initialize the selected device */
for (i = 0; i < data->dev_nb; i++) {
/* create gpt partition support only for full update on MMC */
if (data->dev[i].target != STM32PROG_MMC ||
!data->dev[i].full_update)
continue;
printf("partitions on mmc%d: ", data->dev[i].dev_id);
offset = 0;
rootfs_found = false;
memset(buf, 0, buflen);
list_for_each_entry(part, &data->dev[i].part_list, list) {
/* skip eMMC boot partitions */
if (part->part_id < 0)
continue;
/* skip Raw Image */
if (part->part_type == RAW_IMAGE)
continue;
if (offset + 100 > buflen) {
log_debug("\n%s: buffer too small, %s skippped",
__func__, part->name);
continue;
}
if (!offset)
offset += sprintf(buf, "gpt write mmc %d \"",
data->dev[i].dev_id);
offset += snprintf(buf + offset, buflen - offset,
"name=%s,start=0x%llx,size=0x%llx",
part->name,
part->addr,
part->size);
switch (part->part_type) {
case PART_BINARY:
type_str = LINUX_RESERVED_UUID;
break;
case PART_ENV:
type_str = "u-boot-env";
break;
case PART_FIP:
type_str = FIP_TYPE_UUID;
break;
case PART_FWU_MDATA:
type_str = FWU_MDATA_UUID;
break;
case PART_ESP:
/* EFI System Partition */
type_str = "system";
break;
default: /* PART_FILESYSTEM or PART_SYSTEM for distro */
type_str = "linux";
break;
}
offset += snprintf(buf + offset,
buflen - offset,
",type=%s", type_str);
if (part->part_type == PART_SYSTEM)
offset += snprintf(buf + offset,
buflen - offset,
",bootable");
/* partition UUID */
uuid_bin = NULL;
if (!rootfs_found && !strcmp(part->name, "rootfs")) {
mmc_id = part->dev_id;
rootfs_found = true;
if (mmc_id < ARRAY_SIZE(uuid_mmc))
uuid_bin = (unsigned char *)uuid_mmc[mmc_id].b;
}
if (part->part_type == PART_FIP) {
for (j = 0; j < ARRAY_SIZE(fip_part_name); j++)
if (!strcmp(part->name, fip_part_name[j])) {
uuid_bin = (unsigned char *)fip_part_uuid[j].b;
break;
}
}
if (uuid_bin) {
uuid_bin_to_str(uuid_bin, uuid, UUID_STR_FORMAT_GUID);
offset += snprintf(buf + offset,
buflen - offset,
",uuid=%s", uuid);
}
offset += snprintf(buf + offset, buflen - offset, ";");
}
if (offset) {
offset += snprintf(buf + offset, buflen - offset, "\"");
log_debug("\ncmd: %s\n", buf);
if (run_command(buf, 0)) {
stm32prog_err("GPT partitionning fail: %s",
buf);
free(buf);
return -1;
}
}
if (data->dev[i].mmc)
part_init(mmc_get_blk_desc(data->dev[i].mmc));
#ifdef DEBUG
sprintf(buf, "gpt verify mmc %d", data->dev[i].dev_id);
log_debug("\ncmd: %s", buf);
if (run_command(buf, 0))
printf("fail !\n");
else
printf("OK\n");
sprintf(buf, "part list mmc %d", data->dev[i].dev_id);
run_command(buf, 0);
#endif
puts("done\n");
}
#ifdef DEBUG
run_command("mtd list", 0);
#endif
free(buf);
return 0;
}
static int stm32prog_alt_add(struct stm32prog_data *data,
struct dfu_entity *dfu,
struct stm32prog_part_t *part)
{
int ret = 0;
int offset = 0;
char devstr[10];
char dfustr[10];
char buf[ALT_BUF_LEN];
u32 size;
char multiplier, type;
/* max 3 digit for sector size */
if (part->size > SZ_1M) {
size = (u32)(part->size / SZ_1M);
multiplier = 'M';
} else if (part->size > SZ_1K) {
size = (u32)(part->size / SZ_1K);
multiplier = 'K';
} else {
size = (u32)part->size;
multiplier = 'B';
}
if (IS_SELECT(part) && !IS_EMPTY(part))
type = 'e'; /*Readable and Writeable*/
else
type = 'a';/*Readable*/
memset(buf, 0, sizeof(buf));
offset = snprintf(buf, ALT_BUF_LEN - offset,
"@%s/0x%02x/1*%d%c%c ",
part->name, part->id,
size, multiplier, type);
if (part->target == STM32PROG_RAM) {
offset += snprintf(buf + offset, ALT_BUF_LEN - offset,
"ram 0x%llx 0x%llx",
part->addr, part->size);
} else if (part->part_type == RAW_IMAGE) {
u64 dfu_size;
if (part->dev->target == STM32PROG_MMC)
dfu_size = part->size / part->dev->mmc->read_bl_len;
else
dfu_size = part->size;
offset += snprintf(buf + offset, ALT_BUF_LEN - offset,
"raw 0x0 0x%llx", dfu_size);
} else if (part->part_id < 0) {
u64 nb_blk = part->size / part->dev->mmc->read_bl_len;
offset += snprintf(buf + offset, ALT_BUF_LEN - offset,
"raw 0x%llx 0x%llx",
part->addr, nb_blk);
offset += snprintf(buf + offset, ALT_BUF_LEN - offset,
" mmcpart %d", -(part->part_id));
} else {
if (part->part_type == PART_SYSTEM &&
(part->target == STM32PROG_NAND ||
part->target == STM32PROG_NOR ||
part->target == STM32PROG_SPI_NAND))
offset += snprintf(buf + offset,
ALT_BUF_LEN - offset,
"partubi");
else
offset += snprintf(buf + offset,
ALT_BUF_LEN - offset,
"part");
/* dev_id requested by DFU MMC */
if (part->target == STM32PROG_MMC)
offset += snprintf(buf + offset, ALT_BUF_LEN - offset,
" %d", part->dev_id);
offset += snprintf(buf + offset, ALT_BUF_LEN - offset,
" %d", part->part_id);
}
ret = -ENODEV;
switch (part->target) {
case STM32PROG_MMC:
if (IS_ENABLED(CONFIG_MMC)) {
ret = 0;
sprintf(dfustr, "mmc");
sprintf(devstr, "%d", part->dev_id);
}
break;
case STM32PROG_NAND:
case STM32PROG_NOR:
case STM32PROG_SPI_NAND:
if (IS_ENABLED(CONFIG_MTD)) {
ret = 0;
sprintf(dfustr, "mtd");
get_mtd_by_target(devstr, part->target, part->dev_id);
}
break;
case STM32PROG_RAM:
ret = 0;
sprintf(dfustr, "ram");
sprintf(devstr, "0");
break;
default:
break;
}
if (ret) {
stm32prog_err("invalid target: %d", part->target);
return ret;
}
log_debug("dfu_alt_add(%s,%s,%s)\n", dfustr, devstr, buf);
ret = dfu_alt_add(dfu, dfustr, devstr, buf);
log_debug("dfu_alt_add(%s,%s,%s) result %d\n",
dfustr, devstr, buf, ret);
return ret;
}
static int stm32prog_alt_add_virt(struct dfu_entity *dfu,
char *name, int phase, int size)
{
int ret = 0;
char devstr[4];
char buf[ALT_BUF_LEN];
sprintf(devstr, "%d", phase);
sprintf(buf, "@%s/0x%02x/1*%dBe", name, phase, size);
ret = dfu_alt_add(dfu, "virt", devstr, buf);
log_debug("dfu_alt_add(virt,%s,%s) result %d\n", devstr, buf, ret);
return ret;
}
static int dfu_init_entities(struct stm32prog_data *data)
{
int ret = 0;
int phase, i, alt_id;
struct stm32prog_part_t *part;
struct dfu_entity *dfu;
int alt_nb;
u32 otp_size = 0;
alt_nb = 1; /* number of virtual = CMD*/
if (IS_ENABLED(CONFIG_CMD_STM32PROG_OTP)) {
/* OTP_SIZE_SMC = 0 if SMC is not supported */
otp_size = OTP_SIZE_SMC;
/* check if PTA BSEC is supported */
ret = optee_ta_open(data);
log_debug("optee_ta_open(PTA_NVMEM) result %d\n", ret);
if (!ret && data->tee)
otp_size = OTP_SIZE_TA;
if (otp_size)
alt_nb++; /* OTP*/
}
if (CONFIG_IS_ENABLED(DM_PMIC))
alt_nb++; /* PMIC NVMEM*/
if (data->part_nb == 0)
alt_nb++; /* +1 for FlashLayout */
else
for (i = 0; i < data->part_nb; i++) {
if (data->part_array[i].target != STM32PROG_NONE)
alt_nb++;
}
if (dfu_alt_init(alt_nb, &dfu))
return -ENODEV;
puts("DFU alt info setting: ");
if (data->part_nb) {
alt_id = 0;
ret = 0;
for (phase = 1;
(phase <= PHASE_LAST_USER) &&
(alt_id < alt_nb) && !ret;
phase++) {
/* ordering alt setting by phase id */
part = NULL;
for (i = 0; i < data->part_nb; i++) {
if (phase == data->part_array[i].id) {
part = &data->part_array[i];
break;
}
}
if (!part)
continue;
if (part->target == STM32PROG_NONE)
continue;
part->alt_id = alt_id;
alt_id++;
ret = stm32prog_alt_add(data, dfu, part);
}
} else {
char buf[ALT_BUF_LEN];
sprintf(buf, "@FlashLayout/0x%02x/1*256Ke ram %x 40000",
PHASE_FLASHLAYOUT, CONFIG_SYS_LOAD_ADDR);
ret = dfu_alt_add(dfu, "ram", NULL, buf);
log_debug("dfu_alt_add(ram, NULL,%s) result %d\n", buf, ret);
}
if (!ret)
ret = stm32prog_alt_add_virt(dfu, "virtual", PHASE_CMD, CMD_SIZE);
if (!ret && IS_ENABLED(CONFIG_CMD_STM32PROG_OTP) && otp_size)
ret = stm32prog_alt_add_virt(dfu, "OTP", PHASE_OTP, otp_size);
if (!ret && CONFIG_IS_ENABLED(DM_PMIC))
ret = stm32prog_alt_add_virt(dfu, "PMIC", PHASE_PMIC, PMIC_SIZE);
if (ret)
stm32prog_err("dfu init failed: %d", ret);
puts("done\n");
#ifdef DEBUG
dfu_show_entities();
#endif
return ret;
}
int stm32prog_otp_write(struct stm32prog_data *data, u32 offset, u8 *buffer,
long *size)
{
u32 otp_size = data->tee ? OTP_SIZE_TA : OTP_SIZE_SMC;
log_debug("%s: %x %lx\n", __func__, offset, *size);
if (!IS_ENABLED(CONFIG_CMD_STM32PROG_OTP)) {
stm32prog_err("OTP update not supported");
return -EOPNOTSUPP;
}
if (!data->otp_part) {
data->otp_part = memalign(CONFIG_SYS_CACHELINE_SIZE, otp_size);
if (!data->otp_part) {
stm32prog_err("OTP write issue %d", -ENOMEM);
return -ENOMEM;
}
}
if (!offset)
memset(data->otp_part, 0, otp_size);
if (offset + *size > otp_size)
*size = otp_size - offset;
memcpy((void *)((uintptr_t)data->otp_part + offset), buffer, *size);
return 0;
}
int stm32prog_otp_read(struct stm32prog_data *data, u32 offset, u8 *buffer,
long *size)
{
u32 otp_size = data->tee ? OTP_SIZE_TA : OTP_SIZE_SMC;
int result = 0;
if (!IS_ENABLED(CONFIG_CMD_STM32PROG_OTP)) {
stm32prog_err("OTP update not supported");
return -EOPNOTSUPP;
}
log_debug("%s: %x %lx\n", __func__, offset, *size);
/* alway read for first packet */
if (!offset) {
if (!data->otp_part)
data->otp_part =
memalign(CONFIG_SYS_CACHELINE_SIZE, otp_size);
if (!data->otp_part) {
result = -ENOMEM;
goto end_otp_read;
}
/* init struct with 0 */
memset(data->otp_part, 0, otp_size);
/* call the service */
result = -EOPNOTSUPP;
if (data->tee && CONFIG_IS_ENABLED(OPTEE))
result = optee_ta_invoke(data, TA_NVMEM_READ, NVMEM_OTP,
data->otp_part, OTP_SIZE_TA);
else if (IS_ENABLED(CONFIG_ARM_SMCCC))
result = stm32_smc_exec(STM32_SMC_BSEC, STM32_SMC_READ_ALL,
(unsigned long)data->otp_part, 0);
if (result)
goto end_otp_read;
}
if (!data->otp_part) {
result = -ENOMEM;
goto end_otp_read;
}
if (offset + *size > otp_size)
*size = otp_size - offset;
memcpy(buffer, (void *)((uintptr_t)data->otp_part + offset), *size);
end_otp_read:
if (result)
stm32prog_err("OTP read issue %d", result);
log_debug("%s: result %i\n", __func__, result);
return result;
}
int stm32prog_otp_start(struct stm32prog_data *data)
{
int result = 0;
struct arm_smccc_res res;
if (!IS_ENABLED(CONFIG_CMD_STM32PROG_OTP)) {
stm32prog_err("OTP update not supported");
return -EOPNOTSUPP;
}
if (!data->otp_part) {
stm32prog_err("start OTP without data");
return -1;
}
result = -EOPNOTSUPP;
if (data->tee && CONFIG_IS_ENABLED(OPTEE)) {
result = optee_ta_invoke(data, TA_NVMEM_WRITE, NVMEM_OTP,
data->otp_part, OTP_SIZE_TA);
} else if (IS_ENABLED(CONFIG_ARM_SMCCC)) {
arm_smccc_smc(STM32_SMC_BSEC, STM32_SMC_WRITE_ALL,
(uintptr_t)data->otp_part, 0, 0, 0, 0, 0, &res);
if (!res.a0) {
switch (res.a1) {
case 0:
result = 0;
break;
case 1:
stm32prog_err("Provisioning");
result = 0;
break;
default:
log_err("%s: OTP incorrect value (err = %ld)\n",
__func__, res.a1);
result = -EINVAL;
break;
}
} else {
log_err("%s: Failed to exec svc=%x op=%x in secure mode (err = %ld)\n",
__func__, STM32_SMC_BSEC, STM32_SMC_WRITE_ALL, res.a0);
result = -EINVAL;
}
}
free(data->otp_part);
data->otp_part = NULL;
if (result)
stm32prog_err("OTP write issue %d", result);
log_debug("%s: result %i\n", __func__, result);
return result;
}
int stm32prog_pmic_write(struct stm32prog_data *data, u32 offset, u8 *buffer,
long *size)
{
log_debug("%s: %x %lx\n", __func__, offset, *size);
if (!offset)
memset(data->pmic_part, 0, PMIC_SIZE);
if (offset + *size > PMIC_SIZE)
*size = PMIC_SIZE - offset;
memcpy(&data->pmic_part[offset], buffer, *size);
return 0;
}
int stm32prog_pmic_read(struct stm32prog_data *data, u32 offset, u8 *buffer,
long *size)
{
int result = 0, ret;
struct udevice *dev;
if (!IS_ENABLED(CONFIG_PMIC_STPMIC1)) {
stm32prog_err("PMIC update not supported");
return -EOPNOTSUPP;
}
log_debug("%s: %x %lx\n", __func__, offset, *size);
ret = uclass_get_device_by_driver(UCLASS_MISC,
DM_DRIVER_GET(stpmic1_nvm),
&dev);
if (ret)
return ret;
/* alway request PMIC for first packet */
if (!offset) {
/* init struct with 0 */
memset(data->pmic_part, 0, PMIC_SIZE);
ret = uclass_get_device_by_driver(UCLASS_MISC,
DM_DRIVER_GET(stpmic1_nvm),
&dev);
if (ret)
return ret;
ret = misc_read(dev, 0xF8, data->pmic_part, PMIC_SIZE);
if (ret < 0) {
result = ret;
goto end_pmic_read;
}
if (ret != PMIC_SIZE) {
result = -EACCES;
goto end_pmic_read;
}
}
if (offset + *size > PMIC_SIZE)
*size = PMIC_SIZE - offset;
memcpy(buffer, &data->pmic_part[offset], *size);
end_pmic_read:
log_debug("%s: result %i\n", __func__, result);
return result;
}
int stm32prog_pmic_start(struct stm32prog_data *data)
{
int ret;
struct udevice *dev;
if (!IS_ENABLED(CONFIG_PMIC_STPMIC1)) {
stm32prog_err("PMIC update not supported");
return -EOPNOTSUPP;
}
ret = uclass_get_device_by_driver(UCLASS_MISC,
DM_DRIVER_GET(stpmic1_nvm),
&dev);
if (ret)
return ret;
return misc_write(dev, 0xF8, data->pmic_part, PMIC_SIZE);
}
/* copy FSBL on NAND to improve reliability on NAND */
static int stm32prog_copy_fsbl(struct stm32prog_part_t *part)
{
int ret, i;
void *fsbl;
struct image_header_s header;
struct stm32_header_v2 raw_header; /* V2 size > v1 size */
struct dfu_entity *dfu;
long size, offset;
if (part->target != STM32PROG_NAND &&
part->target != STM32PROG_SPI_NAND)
return -EINVAL;
dfu = dfu_get_entity(part->alt_id);
/* read header */
dfu_transaction_cleanup(dfu);
size = sizeof(raw_header);
ret = dfu->read_medium(dfu, 0, (void *)&raw_header, &size);
if (ret)
return ret;
stm32prog_header_check((ulong)&raw_header, &header);
if (header.type != HEADER_STM32IMAGE &&
header.type != HEADER_STM32IMAGE_V2)
return -ENOENT;
/* read header + payload */
size = header.image_length + header.length;
size = round_up(size, part->dev->mtd->erasesize);
fsbl = calloc(1, size);
if (!fsbl)
return -ENOMEM;
ret = dfu->read_medium(dfu, 0, fsbl, &size);
log_debug("%s read size=%lx ret=%d\n", __func__, size, ret);
if (ret)
goto error;
dfu_transaction_cleanup(dfu);
offset = 0;
for (i = part->bin_nb - 1; i > 0; i--) {
offset += size;
/* write to the next erase block */
ret = dfu->write_medium(dfu, offset, fsbl, &size);
log_debug("%s copy at ofset=%lx size=%lx ret=%d",
__func__, offset, size, ret);
if (ret)
goto error;
}
error:
free(fsbl);
return ret;
}
static void stm32prog_end_phase(struct stm32prog_data *data, u64 offset)
{
if (data->phase == PHASE_FLASHLAYOUT) {
#if defined(CONFIG_LEGACY_IMAGE_FORMAT)
if (genimg_get_format((void *)CONFIG_SYS_LOAD_ADDR) == IMAGE_FORMAT_LEGACY) {
data->script = CONFIG_SYS_LOAD_ADDR;
data->phase = PHASE_END;
log_notice("U-Boot script received\n");
return;
}
#endif
log_notice("\nFlashLayout received, size = %lld\n", offset);
if (parse_flash_layout(data, CONFIG_SYS_LOAD_ADDR, offset))
stm32prog_err("Layout: invalid FlashLayout");
return;
}
if (!data->cur_part)
return;
if (data->cur_part->target == STM32PROG_RAM) {
if (data->cur_part->part_type == PART_SYSTEM)
data->uimage = data->cur_part->addr;
if (data->cur_part->part_type == PART_FILESYSTEM)
data->dtb = data->cur_part->addr;
if (data->cur_part->part_type == PART_BINARY) {
data->initrd = data->cur_part->addr;
data->initrd_size = offset;
}
}
if (CONFIG_IS_ENABLED(MMC) &&
data->cur_part->part_id < 0) {
char cmdbuf[60];
sprintf(cmdbuf, "mmc bootbus %d 0 0 0; mmc partconf %d 1 %d 0",
data->cur_part->dev_id, data->cur_part->dev_id,
-(data->cur_part->part_id));
if (run_command(cmdbuf, 0)) {
stm32prog_err("commands '%s' failed", cmdbuf);
return;
}
}
if (IS_ENABLED(CONFIG_MTD) &&
data->cur_part->bin_nb > 1) {
if (stm32prog_copy_fsbl(data->cur_part)) {
stm32prog_err("%s (0x%x): copy of fsbl failed",
data->cur_part->name, data->cur_part->id);
return;
}
}
}
void stm32prog_do_reset(struct stm32prog_data *data)
{
if (data->phase == PHASE_RESET) {
data->phase = PHASE_DO_RESET;
puts("Reset requested\n");
}
}
void stm32prog_next_phase(struct stm32prog_data *data)
{
int phase, i;
struct stm32prog_part_t *part;
bool found;
phase = data->phase;
switch (phase) {
case PHASE_RESET:
case PHASE_END:
case PHASE_DO_RESET:
return;
}
/* found next selected partition */
data->dfu_seq = 0;
data->cur_part = NULL;
data->phase = PHASE_END;
found = false;
do {
phase++;
if (phase > PHASE_LAST_USER)
break;
for (i = 0; i < data->part_nb; i++) {
part = &data->part_array[i];
if (part->id == phase) {
if (IS_SELECT(part) && !IS_EMPTY(part)) {
data->cur_part = part;
data->phase = phase;
found = true;
}
break;
}
}
} while (!found);
if (data->phase == PHASE_END)
puts("Phase=END\n");
}
static int part_delete(struct stm32prog_data *data,
struct stm32prog_part_t *part)
{
int ret = 0;
unsigned long blks, blks_offset, blks_size;
struct blk_desc *block_dev = NULL;
char cmdbuf[40];
char devstr[10];
printf("Erasing %s ", part->name);
switch (part->target) {
case STM32PROG_MMC:
if (!IS_ENABLED(CONFIG_MMC)) {
ret = -1;
stm32prog_err("%s (0x%x): erase invalid",
part->name, part->id);
break;
}
printf("on mmc %d: ", part->dev->dev_id);
block_dev = mmc_get_blk_desc(part->dev->mmc);
blks_offset = lldiv(part->addr, part->dev->mmc->read_bl_len);
blks_size = lldiv(part->size, part->dev->mmc->read_bl_len);
/* -1 or -2 : delete boot partition of MMC
* need to switch to associated hwpart 1 or 2
*/
if (part->part_id < 0)
if (blk_select_hwpart_devnum(UCLASS_MMC,
part->dev->dev_id,
-part->part_id))
return -1;
blks = blk_derase(block_dev, blks_offset, blks_size);
/* return to user partition */
if (part->part_id < 0)
blk_select_hwpart_devnum(UCLASS_MMC,
part->dev->dev_id, 0);
if (blks != blks_size) {
ret = -1;
stm32prog_err("%s (0x%x): MMC erase failed",
part->name, part->id);
}
break;
case STM32PROG_NOR:
case STM32PROG_NAND:
case STM32PROG_SPI_NAND:
if (!IS_ENABLED(CONFIG_MTD)) {
ret = -1;
stm32prog_err("%s (0x%x): erase invalid",
part->name, part->id);
break;
}
get_mtd_by_target(devstr, part->target, part->dev->dev_id);
printf("on %s: ", devstr);
sprintf(cmdbuf, "mtd erase %s 0x%llx 0x%llx",
devstr, part->addr, part->size);
if (run_command(cmdbuf, 0)) {
ret = -1;
stm32prog_err("%s (0x%x): MTD erase commands failed (%s)",
part->name, part->id, cmdbuf);
}
break;
case STM32PROG_RAM:
printf("on ram: ");
memset((void *)(uintptr_t)part->addr, 0, (size_t)part->size);
break;
default:
ret = -1;
stm32prog_err("%s (0x%x): erase invalid", part->name, part->id);
break;
}
if (!ret)
printf("done\n");
return ret;
}
static void stm32prog_devices_init(struct stm32prog_data *data)
{
int i;
int ret;
struct stm32prog_part_t *part;
ret = treat_partition_list(data);
if (ret)
goto error;
/* empty flashlayout */
if (!data->dev_nb)
return;
/* initialize the selected device */
for (i = 0; i < data->dev_nb; i++) {
ret = init_device(data, &data->dev[i]);
if (ret)
goto error;
}
/* delete RAW partition before create partition */
for (i = 0; i < data->part_nb; i++) {
part = &data->part_array[i];
if (part->part_type != RAW_IMAGE)
continue;
if (!IS_SELECT(part) || !IS_DELETE(part))
continue;
ret = part_delete(data, part);
if (ret)
goto error;
}
if (IS_ENABLED(CONFIG_MMC)) {
ret = create_gpt_partitions(data);
if (ret)
goto error;
}
/* delete partition GPT or MTD */
for (i = 0; i < data->part_nb; i++) {
part = &data->part_array[i];
if (part->part_type == RAW_IMAGE)
continue;
if (!IS_SELECT(part) || !IS_DELETE(part))
continue;
ret = part_delete(data, part);
if (ret)
goto error;
}
return;
error:
data->part_nb = 0;
}
int stm32prog_dfu_init(struct stm32prog_data *data)
{
/* init device if no error */
if (data->part_nb)
stm32prog_devices_init(data);
if (data->part_nb)
stm32prog_next_phase(data);
/* prepare DFU for device read/write */
dfu_free_entities();
return dfu_init_entities(data);
}
int stm32prog_init(struct stm32prog_data *data, uintptr_t addr, ulong size)
{
memset(data, 0x0, sizeof(*data));
data->read_phase = PHASE_RESET;
data->phase = PHASE_FLASHLAYOUT;
return parse_flash_layout(data, addr, size);
}
void stm32prog_clean(struct stm32prog_data *data)
{
/* clean */
dfu_free_entities();
free(data->part_array);
free(data->otp_part);
free(data->buffer);
if (CONFIG_IS_ENABLED(OPTEE) && data->tee) {
tee_close_session(data->tee, data->tee_session);
data->tee = NULL;
data->tee_session = 0x0;
}
}
/* DFU callback: used after serial and direct DFU USB access */
void dfu_flush_callback(struct dfu_entity *dfu)
{
if (!stm32prog_data)
return;
if (dfu->dev_type == DFU_DEV_VIRT) {
if (dfu->data.virt.dev_num == PHASE_OTP)
stm32prog_otp_start(stm32prog_data);
else if (dfu->data.virt.dev_num == PHASE_PMIC)
stm32prog_pmic_start(stm32prog_data);
return;
}
if (dfu->dev_type == DFU_DEV_RAM) {
if (dfu->alt == 0 &&
stm32prog_data->phase == PHASE_FLASHLAYOUT) {
stm32prog_end_phase(stm32prog_data, dfu->offset);
/* waiting DFU DETACH for reenumeration */
}
}
if (!stm32prog_data->cur_part)
return;
if (dfu->alt == stm32prog_data->cur_part->alt_id) {
stm32prog_end_phase(stm32prog_data, dfu->offset);
stm32prog_next_phase(stm32prog_data);
}
}
void dfu_initiated_callback(struct dfu_entity *dfu)
{
if (!stm32prog_data)
return;
if (!stm32prog_data->cur_part)
return;
/* force the saved offset for the current partition */
if (dfu->alt == stm32prog_data->cur_part->alt_id) {
dfu->offset = stm32prog_data->offset;
stm32prog_data->dfu_seq = 0;
log_debug("dfu offset = 0x%llx\n", dfu->offset);
}
}
void dfu_error_callback(struct dfu_entity *dfu, const char *msg)
{
struct stm32prog_data *data = stm32prog_data;
if (!stm32prog_data)
return;
if (!stm32prog_data->cur_part)
return;
if (dfu->alt == stm32prog_data->cur_part->alt_id)
stm32prog_err(msg);
}