1 // SPDX-License-Identifier: GPL-2.0+ OR BSD-3-Clause
3 * Copyright (C) 2020, STMicroelectronics - All Rights Reserved
11 #include <dm/uclass.h>
12 #include <linux/list.h>
13 #include <linux/list_sort.h>
14 #include <linux/sizes.h>
16 #include "stm32prog.h"
18 /* Primary GPT header size for 128 entries : 17kB = 34 LBA of 512B */
19 #define GPT_HEADER_SZ 34
21 #define OPT_SELECT BIT(0)
22 #define OPT_EMPTY BIT(1)
24 #define IS_SELECT(part) ((part)->option & OPT_SELECT)
25 #define IS_EMPTY(part) ((part)->option & OPT_EMPTY)
27 #define ALT_BUF_LEN SZ_1K
29 #define ROOTFS_MMC0_UUID \
30 EFI_GUID(0xE91C4E10, 0x16E6, 0x4C0E, \
31 0xBD, 0x0E, 0x77, 0xBE, 0xCF, 0x4A, 0x35, 0x82)
33 #define ROOTFS_MMC1_UUID \
34 EFI_GUID(0x491F6117, 0x415D, 0x4F53, \
35 0x88, 0xC9, 0x6E, 0x0D, 0xE5, 0x4D, 0xEA, 0xC6)
37 #define ROOTFS_MMC2_UUID \
38 EFI_GUID(0xFD58F1C7, 0xBE0D, 0x4338, \
39 0x88, 0xE9, 0xAD, 0x8F, 0x05, 0x0A, 0xEB, 0x18)
41 /* RAW parttion (binary / bootloader) used Linux - reserved UUID */
42 #define LINUX_RESERVED_UUID "8DA63339-0007-60C0-C436-083AC8230908"
45 * unique partition guid (uuid) for partition named "rootfs"
46 * on each MMC instance = SD Card or eMMC
47 * allow fixed kernel bootcmd: "rootf=PARTUID=e91c4e10-..."
49 static const efi_guid_t uuid_mmc[3] = {
55 DECLARE_GLOBAL_DATA_PTR;
57 /* order of column in flash layout file */
58 enum stm32prog_col_t {
68 char *stm32prog_get_error(struct stm32prog_data *data)
70 static const char error_msg[] = "Unspecified";
72 if (strlen(data->error) == 0)
73 strcpy(data->error, error_msg);
78 u8 stm32prog_header_check(struct raw_header_s *raw_header,
79 struct image_header_s *header)
84 header->image_checksum = 0x0;
85 header->image_length = 0x0;
87 if (!raw_header || !header) {
88 pr_debug("%s:no header data\n", __func__);
91 if (raw_header->magic_number !=
92 (('S' << 0) | ('T' << 8) | ('M' << 16) | (0x32 << 24))) {
93 pr_debug("%s:invalid magic number : 0x%x\n",
94 __func__, raw_header->magic_number);
97 /* only header v1.0 supported */
98 if (raw_header->header_version != 0x00010000) {
99 pr_debug("%s:invalid header version : 0x%x\n",
100 __func__, raw_header->header_version);
103 if (raw_header->reserved1 != 0x0 || raw_header->reserved2) {
104 pr_debug("%s:invalid reserved field\n", __func__);
107 for (i = 0; i < (sizeof(raw_header->padding) / 4); i++) {
108 if (raw_header->padding[i] != 0) {
109 pr_debug("%s:invalid padding field\n", __func__);
114 header->image_checksum = le32_to_cpu(raw_header->image_checksum);
115 header->image_length = le32_to_cpu(raw_header->image_length);
120 static u32 stm32prog_header_checksum(u32 addr, struct image_header_s *header)
125 /* compute checksum on payload */
126 payload = (u8 *)addr;
128 for (i = header->image_length; i > 0; i--)
129 checksum += *(payload++);
134 /* FLASHLAYOUT PARSING *****************************************/
135 static int parse_option(struct stm32prog_data *data,
136 int i, char *p, struct stm32prog_part_t *part)
148 part->option |= OPT_SELECT;
151 part->option |= OPT_EMPTY;
155 stm32prog_err("Layout line %d: invalid option '%c' in %s)",
161 if (!(part->option & OPT_SELECT)) {
162 stm32prog_err("Layout line %d: missing 'P' in option %s", i, p);
169 static int parse_id(struct stm32prog_data *data,
170 int i, char *p, struct stm32prog_part_t *part)
175 result = strict_strtoul(p, 0, &value);
177 if (result || value > PHASE_LAST_USER) {
178 stm32prog_err("Layout line %d: invalid phase value = %s", i, p);
185 static int parse_name(struct stm32prog_data *data,
186 int i, char *p, struct stm32prog_part_t *part)
190 if (strlen(p) < sizeof(part->name)) {
191 strcpy(part->name, p);
193 stm32prog_err("Layout line %d: partition name too long [%d]: %s",
201 static int parse_type(struct stm32prog_data *data,
202 int i, char *p, struct stm32prog_part_t *part)
206 if (!strcmp(p, "Binary")) {
207 part->part_type = PART_BINARY;
208 } else if (!strcmp(p, "System")) {
209 part->part_type = PART_SYSTEM;
210 } else if (!strcmp(p, "FileSystem")) {
211 part->part_type = PART_FILESYSTEM;
212 } else if (!strcmp(p, "RawImage")) {
213 part->part_type = RAW_IMAGE;
218 stm32prog_err("Layout line %d: type parsing error : '%s'",
224 static int parse_ip(struct stm32prog_data *data,
225 int i, char *p, struct stm32prog_part_t *part)
228 unsigned int len = 0;
231 if (!strcmp(p, "none")) {
232 part->target = STM32PROG_NONE;
233 } else if (!strncmp(p, "mmc", 3)) {
234 part->target = STM32PROG_MMC;
240 /* only one digit allowed for device id */
241 if (strlen(p) != len + 1) {
244 part->dev_id = p[len] - '0';
245 if (part->dev_id > 9)
250 stm32prog_err("Layout line %d: ip parsing error: '%s'", i, p);
255 static int parse_offset(struct stm32prog_data *data,
256 int i, char *p, struct stm32prog_part_t *part)
263 part->addr = simple_strtoull(p, &tail, 0);
264 if (tail == p || *tail != '\0') {
265 stm32prog_err("Layout line %d: invalid offset '%s'",
274 int (* const parse[COL_NB_STM32])(struct stm32prog_data *data, int i, char *p,
275 struct stm32prog_part_t *part) = {
276 [COL_OPTION] = parse_option,
278 [COL_NAME] = parse_name,
279 [COL_TYPE] = parse_type,
281 [COL_OFFSET] = parse_offset,
284 static int parse_flash_layout(struct stm32prog_data *data,
288 int column = 0, part_nb = 0, ret;
289 bool end_of_line, eof;
290 char *p, *start, *last, *col;
291 struct stm32prog_part_t *part;
297 /* check if STM32image is detected */
298 if (!stm32prog_header_check((struct raw_header_s *)addr,
302 addr = addr + BL_HEADER_SIZE;
303 size = data->header.image_length;
305 checksum = stm32prog_header_checksum(addr, &data->header);
306 if (checksum != data->header.image_checksum) {
307 stm32prog_err("Layout: invalid checksum : 0x%x expected 0x%x",
308 checksum, data->header.image_checksum);
315 start = (char *)addr;
318 *last = 0x0; /* force null terminated string */
319 pr_debug("flash layout =\n%s\n", start);
321 /* calculate expected number of partitions */
324 while (*p && (p < last)) {
327 if (p < last && *p == '#')
331 if (part_list_size > PHASE_LAST_USER) {
332 stm32prog_err("Layout: too many partition (%d)",
336 part = calloc(sizeof(struct stm32prog_part_t), part_list_size);
338 stm32prog_err("Layout: alloc failed");
341 data->part_array = part;
343 /* main parsing loop */
347 col = start; /* 1st column */
351 /* CR is ignored and replaced by NULL character */
366 /* comment line is skipped */
367 if (column == 0 && p == col) {
368 while ((p < last) && *p)
373 if (p >= last || !*p) {
380 /* by default continue with the next character */
386 /* replace by \0: allow string parsing for each column */
394 /* skip empty line and multiple TAB in tsv file */
395 if (strlen(col) == 0) {
397 /* skip empty line */
398 if (column == 0 && end_of_line) {
405 if (column < COL_NB_STM32) {
406 ret = parse[column](data, i, col, part);
411 /* save the beginning of the next column */
418 /* end of the line detected */
421 if (column < COL_NB_STM32) {
422 stm32prog_err("Layout line %d: no enought column", i);
429 if (part_nb >= part_list_size) {
432 stm32prog_err("Layout: no enought memory for %d part",
438 data->part_nb = part_nb;
439 if (data->part_nb == 0) {
440 stm32prog_err("Layout: no partition found");
447 static int __init part_cmp(void *priv, struct list_head *a, struct list_head *b)
449 struct stm32prog_part_t *parta, *partb;
451 parta = container_of(a, struct stm32prog_part_t, list);
452 partb = container_of(b, struct stm32prog_part_t, list);
454 return parta->addr > partb->addr ? 1 : -1;
457 static int init_device(struct stm32prog_data *data,
458 struct stm32prog_dev_t *dev)
460 struct mmc *mmc = NULL;
461 struct blk_desc *block_dev = NULL;
463 u64 first_addr = 0, last_addr = 0;
464 struct stm32prog_part_t *part, *next_part;
466 switch (dev->target) {
469 mmc = find_mmc_device(dev->dev_id);
471 stm32prog_err("mmc device %d not found", dev->dev_id);
474 block_dev = mmc_get_blk_desc(mmc);
476 stm32prog_err("mmc device %d not probed", dev->dev_id);
479 dev->erase_size = mmc->erase_grp_size * block_dev->blksz;
482 /* reserve a full erase group for each GTP headers */
483 if (mmc->erase_grp_size > GPT_HEADER_SZ) {
484 first_addr = dev->erase_size;
485 last_addr = (u64)(block_dev->lba -
486 mmc->erase_grp_size) *
489 first_addr = (u64)GPT_HEADER_SZ * block_dev->blksz;
490 last_addr = (u64)(block_dev->lba - GPT_HEADER_SZ - 1) *
493 pr_debug("MMC %d: lba=%ld blksz=%ld\n", dev->dev_id,
494 block_dev->lba, block_dev->blksz);
495 pr_debug(" available address = 0x%llx..0x%llx\n",
496 first_addr, last_addr);
500 stm32prog_err("unknown device type = %d", dev->target);
503 pr_debug(" erase size = 0x%x\n", dev->erase_size);
505 /* order partition list in offset order */
506 list_sort(NULL, &dev->part_list, &part_cmp);
508 pr_debug("id : Opt Phase Name target.n dev.n addr size part_off part_size\n");
509 list_for_each_entry(part, &dev->part_list, list) {
510 if (part->part_type == RAW_IMAGE) {
514 part->size = block_dev->lba * block_dev->blksz;
516 part->size = last_addr;
517 pr_debug("-- : %1d %02x %14s %02d %02d.%02d %08llx %08llx\n",
518 part->option, part->id, part->name,
519 part->part_type, part->target,
520 part->dev_id, part->addr, part->size);
524 part->part_id = part_id++;
526 /* last partition : size to the end of the device */
527 if (part->list.next != &dev->part_list) {
529 container_of(part->list.next,
530 struct stm32prog_part_t,
532 if (part->addr < next_part->addr) {
533 part->size = next_part->addr -
536 stm32prog_err("%s (0x%x): same address : 0x%llx == %s (0x%x): 0x%llx",
537 part->name, part->id,
545 if (part->addr <= last_addr) {
546 part->size = last_addr - part->addr;
548 stm32prog_err("%s (0x%x): invalid address 0x%llx (max=0x%llx)",
549 part->name, part->id,
550 part->addr, last_addr);
554 if (part->addr < first_addr) {
555 stm32prog_err("%s (0x%x): invalid address 0x%llx (min=0x%llx)",
556 part->name, part->id,
557 part->addr, first_addr);
561 if ((part->addr & ((u64)part->dev->erase_size - 1)) != 0) {
562 stm32prog_err("%s (0x%x): not aligned address : 0x%llx on erase size 0x%x",
563 part->name, part->id, part->addr,
564 part->dev->erase_size);
567 pr_debug("%02d : %1d %02x %14s %02d %02d.%02d %08llx %08llx",
568 part->part_id, part->option, part->id, part->name,
569 part->part_type, part->target,
570 part->dev_id, part->addr, part->size);
575 static int treat_partition_list(struct stm32prog_data *data)
578 struct stm32prog_part_t *part;
580 for (j = 0; j < STM32PROG_MAX_DEV; j++) {
581 data->dev[j].target = STM32PROG_NONE;
582 INIT_LIST_HEAD(&data->dev[j].part_list);
585 for (i = 0; i < data->part_nb; i++) {
586 part = &data->part_array[i];
589 /* skip partition with IP="none" */
590 if (part->target == STM32PROG_NONE) {
591 if (IS_SELECT(part)) {
592 stm32prog_err("Layout: selected none phase = 0x%x",
599 if (part->id == PHASE_FLASHLAYOUT ||
600 part->id > PHASE_LAST_USER) {
601 stm32prog_err("Layout: invalid phase = 0x%x",
605 for (j = i + 1; j < data->part_nb; j++) {
606 if (part->id == data->part_array[j].id) {
607 stm32prog_err("Layout: duplicated phase 0x%x at line %d and %d",
612 for (j = 0; j < STM32PROG_MAX_DEV; j++) {
613 if (data->dev[j].target == STM32PROG_NONE) {
614 /* new device found */
615 data->dev[j].target = part->target;
616 data->dev[j].dev_id = part->dev_id;
619 } else if ((part->target == data->dev[j].target) &&
620 (part->dev_id == data->dev[j].dev_id)) {
624 if (j == STM32PROG_MAX_DEV) {
625 stm32prog_err("Layout: too many device");
628 part->dev = &data->dev[j];
629 list_add_tail(&part->list, &data->dev[j].part_list);
635 static int create_partitions(struct stm32prog_data *data)
639 const int buflen = SZ_8K;
641 char uuid[UUID_STR_LEN + 1];
642 unsigned char *uuid_bin;
646 struct stm32prog_part_t *part;
648 buf = malloc(buflen);
652 puts("partitions : ");
653 /* initialize the selected device */
654 for (i = 0; i < data->dev_nb; i++) {
656 rootfs_found = false;
657 memset(buf, 0, buflen);
659 list_for_each_entry(part, &data->dev[i].part_list, list) {
661 if (part->part_type == RAW_IMAGE)
664 if (offset + 100 > buflen) {
665 pr_debug("\n%s: buffer too small, %s skippped",
666 __func__, part->name);
671 offset += sprintf(buf, "gpt write mmc %d \"",
672 data->dev[i].dev_id);
674 offset += snprintf(buf + offset, buflen - offset,
675 "name=%s,start=0x%llx,size=0x%llx",
680 if (part->part_type == PART_BINARY)
681 offset += snprintf(buf + offset,
684 LINUX_RESERVED_UUID);
686 offset += snprintf(buf + offset,
690 if (part->part_type == PART_SYSTEM)
691 offset += snprintf(buf + offset,
695 if (!rootfs_found && !strcmp(part->name, "rootfs")) {
696 mmc_id = part->dev_id;
698 if (mmc_id < ARRAY_SIZE(uuid_mmc)) {
700 (unsigned char *)uuid_mmc[mmc_id].b;
701 uuid_bin_to_str(uuid_bin, uuid,
702 UUID_STR_FORMAT_GUID);
703 offset += snprintf(buf + offset,
709 offset += snprintf(buf + offset, buflen - offset, ";");
713 offset += snprintf(buf + offset, buflen - offset, "\"");
714 pr_debug("\ncmd: %s\n", buf);
715 if (run_command(buf, 0)) {
716 stm32prog_err("GPT partitionning fail: %s",
724 if (data->dev[i].mmc)
725 part_init(mmc_get_blk_desc(data->dev[i].mmc));
728 sprintf(buf, "gpt verify mmc %d", data->dev[i].dev_id);
729 pr_debug("\ncmd: %s", buf);
730 if (run_command(buf, 0))
735 sprintf(buf, "part list mmc %d", data->dev[i].dev_id);
747 static int stm32prog_alt_add(struct stm32prog_data *data,
748 struct dfu_entity *dfu,
749 struct stm32prog_part_t *part)
755 char buf[ALT_BUF_LEN];
757 char multiplier, type;
759 /* max 3 digit for sector size */
760 if (part->size > SZ_1M) {
761 size = (u32)(part->size / SZ_1M);
763 } else if (part->size > SZ_1K) {
764 size = (u32)(part->size / SZ_1K);
767 size = (u32)part->size;
770 if (IS_SELECT(part) && !IS_EMPTY(part))
771 type = 'e'; /*Readable and Writeable*/
773 type = 'a';/*Readable*/
775 memset(buf, 0, sizeof(buf));
776 offset = snprintf(buf, ALT_BUF_LEN - offset,
777 "@%s/0x%02x/1*%d%c%c ",
778 part->name, part->id,
779 size, multiplier, type);
781 if (part->part_type == RAW_IMAGE) {
784 if (part->dev->target == STM32PROG_MMC)
785 dfu_size = part->size / part->dev->mmc->read_bl_len;
787 dfu_size = part->size;
788 offset += snprintf(buf + offset, ALT_BUF_LEN - offset,
789 "raw 0x0 0x%llx", dfu_size);
791 offset += snprintf(buf + offset,
792 ALT_BUF_LEN - offset,
794 /* dev_id requested by DFU MMC */
795 if (part->target == STM32PROG_MMC)
796 offset += snprintf(buf + offset, ALT_BUF_LEN - offset,
797 " %d", part->dev_id);
798 offset += snprintf(buf + offset, ALT_BUF_LEN - offset,
799 " %d;", part->part_id);
801 switch (part->target) {
804 sprintf(dfustr, "mmc");
805 sprintf(devstr, "%d", part->dev_id);
809 stm32prog_err("invalid target: %d", part->target);
812 pr_debug("dfu_alt_add(%s,%s,%s)\n", dfustr, devstr, buf);
813 ret = dfu_alt_add(dfu, dfustr, devstr, buf);
814 pr_debug("dfu_alt_add(%s,%s,%s) result %d\n",
815 dfustr, devstr, buf, ret);
820 static int stm32prog_alt_add_virt(struct dfu_entity *dfu,
821 char *name, int phase, int size)
825 char buf[ALT_BUF_LEN];
827 sprintf(devstr, "%d", phase);
828 sprintf(buf, "@%s/0x%02x/1*%dBe", name, phase, size);
829 ret = dfu_alt_add(dfu, "virt", devstr, buf);
830 pr_debug("dfu_alt_add(virt,%s,%s) result %d\n", devstr, buf, ret);
835 static int dfu_init_entities(struct stm32prog_data *data)
838 int phase, i, alt_id;
839 struct stm32prog_part_t *part;
840 struct dfu_entity *dfu;
843 alt_nb = 1; /* number of virtual = CMD */
844 if (data->part_nb == 0)
845 alt_nb++; /* +1 for FlashLayout */
847 for (i = 0; i < data->part_nb; i++) {
848 if (data->part_array[i].target != STM32PROG_NONE)
852 if (dfu_alt_init(alt_nb, &dfu))
855 puts("DFU alt info setting: ");
859 (phase <= PHASE_LAST_USER) &&
860 (alt_id < alt_nb) && !ret;
862 /* ordering alt setting by phase id */
864 for (i = 0; i < data->part_nb; i++) {
865 if (phase == data->part_array[i].id) {
866 part = &data->part_array[i];
872 if (part->target == STM32PROG_NONE)
874 part->alt_id = alt_id;
877 ret = stm32prog_alt_add(data, dfu, part);
880 char buf[ALT_BUF_LEN];
882 sprintf(buf, "@FlashLayout/0x%02x/1*256Ke ram %x 40000",
883 PHASE_FLASHLAYOUT, STM32_DDR_BASE);
884 ret = dfu_alt_add(dfu, "ram", NULL, buf);
885 pr_debug("dfu_alt_add(ram, NULL,%s) result %d\n", buf, ret);
889 ret = stm32prog_alt_add_virt(dfu, "virtual", PHASE_CMD, 512);
892 stm32prog_err("dfu init failed: %d", ret);
901 static void stm32prog_end_phase(struct stm32prog_data *data)
903 if (data->phase == PHASE_FLASHLAYOUT) {
904 if (parse_flash_layout(data, STM32_DDR_BASE, 0))
905 stm32prog_err("Layout: invalid FlashLayout");
913 void stm32prog_do_reset(struct stm32prog_data *data)
915 if (data->phase == PHASE_RESET) {
916 data->phase = PHASE_DO_RESET;
917 puts("Reset requested\n");
921 void stm32prog_next_phase(struct stm32prog_data *data)
924 struct stm32prog_part_t *part;
935 /* found next selected partition */
936 data->cur_part = NULL;
937 data->phase = PHASE_END;
941 if (phase > PHASE_LAST_USER)
943 for (i = 0; i < data->part_nb; i++) {
944 part = &data->part_array[i];
945 if (part->id == phase) {
946 if (IS_SELECT(part) && !IS_EMPTY(part)) {
947 data->cur_part = part;
956 if (data->phase == PHASE_END)
960 static void stm32prog_devices_init(struct stm32prog_data *data)
965 ret = treat_partition_list(data);
969 /* initialize the selected device */
970 for (i = 0; i < data->dev_nb; i++) {
971 ret = init_device(data, &data->dev[i]);
976 ret = create_partitions(data);
986 int stm32prog_dfu_init(struct stm32prog_data *data)
988 /* init device if no error */
990 stm32prog_devices_init(data);
993 stm32prog_next_phase(data);
995 /* prepare DFU for device read/write */
997 return dfu_init_entities(data);
1000 int stm32prog_init(struct stm32prog_data *data, ulong addr, ulong size)
1002 memset(data, 0x0, sizeof(*data));
1003 data->phase = PHASE_FLASHLAYOUT;
1005 return parse_flash_layout(data, addr, size);
1008 void stm32prog_clean(struct stm32prog_data *data)
1011 dfu_free_entities();
1012 free(data->part_array);
1013 free(data->header_data);
1016 /* DFU callback: used after serial and direct DFU USB access */
1017 void dfu_flush_callback(struct dfu_entity *dfu)
1019 if (!stm32prog_data)
1022 if (dfu->dev_type == DFU_DEV_RAM) {
1023 if (dfu->alt == 0 &&
1024 stm32prog_data->phase == PHASE_FLASHLAYOUT) {
1025 stm32prog_end_phase(stm32prog_data);
1026 /* waiting DFU DETACH for reenumeration */
1030 if (!stm32prog_data->cur_part)
1033 if (dfu->alt == stm32prog_data->cur_part->alt_id) {
1034 stm32prog_end_phase(stm32prog_data);
1035 stm32prog_next_phase(stm32prog_data);
1039 void dfu_initiated_callback(struct dfu_entity *dfu)
1041 if (!stm32prog_data)
1044 if (!stm32prog_data->cur_part)
1047 /* force the saved offset for the current partition */
1048 if (dfu->alt == stm32prog_data->cur_part->alt_id) {
1049 dfu->offset = stm32prog_data->offset;
1050 pr_debug("dfu offset = 0x%llx\n", dfu->offset);