arch/arm/mach-stm32mp/cmd_stm32prog/stm32prog.c

   1 // SPDX-License-Identifier: GPL-2.0+ OR BSD-3-Clause
   2 /*
   3  * Copyright (C) 2020, STMicroelectronics - All Rights Reserved
   4  */
   5
   6 #include <common.h>
   7 #include <console.h>
   8 #include <dfu.h>
   9 #include <malloc.h>
  10 #include <mmc.h>
  11 #include <dm/uclass.h>
  12 #include <linux/list.h>
  13 #include <linux/list_sort.h>
  14 #include <linux/sizes.h>
  15
  16 #include "stm32prog.h"
  17
  18 /* Primary GPT header size for 128 entries : 17kB = 34 LBA of 512B */
  19 #define GPT_HEADER_SZ   34
  20
  21 #define OPT_SELECT      BIT(0)
  22 #define OPT_EMPTY       BIT(1)
  23
  24 #define IS_SELECT(part) ((part)->option & OPT_SELECT)
  25 #define IS_EMPTY(part)  ((part)->option & OPT_EMPTY)
  26
  27 #define ALT_BUF_LEN                     SZ_1K
  28
  29 #define ROOTFS_MMC0_UUID \
  30         EFI_GUID(0xE91C4E10, 0x16E6, 0x4C0E, \
  31                  0xBD, 0x0E, 0x77, 0xBE, 0xCF, 0x4A, 0x35, 0x82)
  32
  33 #define ROOTFS_MMC1_UUID \
  34         EFI_GUID(0x491F6117, 0x415D, 0x4F53, \
  35                  0x88, 0xC9, 0x6E, 0x0D, 0xE5, 0x4D, 0xEA, 0xC6)
  36
  37 #define ROOTFS_MMC2_UUID \
  38         EFI_GUID(0xFD58F1C7, 0xBE0D, 0x4338, \
  39                  0x88, 0xE9, 0xAD, 0x8F, 0x05, 0x0A, 0xEB, 0x18)
  40
  41 /* RAW parttion (binary / bootloader) used Linux - reserved UUID */
  42 #define LINUX_RESERVED_UUID "8DA63339-0007-60C0-C436-083AC8230908"
  43
  44 /*
  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-..."
  48  */
  49 static const efi_guid_t uuid_mmc[3] = {
  50         ROOTFS_MMC0_UUID,
  51         ROOTFS_MMC1_UUID,
  52         ROOTFS_MMC2_UUID
  53 };
  54
  55 DECLARE_GLOBAL_DATA_PTR;
  56
  57 /* order of column in flash layout file */
  58 enum stm32prog_col_t {
  59         COL_OPTION,
  60         COL_ID,
  61         COL_NAME,
  62         COL_TYPE,
  63         COL_IP,
  64         COL_OFFSET,
  65         COL_NB_STM32
  66 };
  67
  68 char *stm32prog_get_error(struct stm32prog_data *data)
  69 {
  70         static const char error_msg[] = "Unspecified";
  71
  72         if (strlen(data->error) == 0)
  73                 strcpy(data->error, error_msg);
  74
  75         return data->error;
  76 }
  77
  78 u8 stm32prog_header_check(struct raw_header_s *raw_header,
  79                           struct image_header_s *header)
  80 {
  81         unsigned int i;
  82
  83         header->present = 0;
  84         header->image_checksum = 0x0;
  85         header->image_length = 0x0;
  86
  87         if (!raw_header || !header) {
  88                 pr_debug("%s:no header data\n", __func__);
  89                 return -1;
  90         }
  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);
  95                 return -2;
  96         }
  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);
 101                 return -3;
 102         }
 103         if (raw_header->reserved1 != 0x0 || raw_header->reserved2) {
 104                 pr_debug("%s:invalid reserved field\n", __func__);
 105                 return -4;
 106         }
 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__);
 110                         return -5;
 111                 }
 112         }
 113         header->present = 1;
 114         header->image_checksum = le32_to_cpu(raw_header->image_checksum);
 115         header->image_length = le32_to_cpu(raw_header->image_length);
 116
 117         return 0;
 118 }
 119
 120 static u32 stm32prog_header_checksum(u32 addr, struct image_header_s *header)
 121 {
 122         u32 i, checksum;
 123         u8 *payload;
 124
 125         /* compute checksum on payload */
 126         payload = (u8 *)addr;
 127         checksum = 0;
 128         for (i = header->image_length; i > 0; i--)
 129                 checksum += *(payload++);
 130
 131         return checksum;
 132 }
 133
 134 /* FLASHLAYOUT PARSING *****************************************/
 135 static int parse_option(struct stm32prog_data *data,
 136                         int i, char *p, struct stm32prog_part_t *part)
 137 {
 138         int result = 0;
 139         char *c = p;
 140
 141         part->option = 0;
 142         if (!strcmp(p, "-"))
 143                 return 0;
 144
 145         while (*c) {
 146                 switch (*c) {
 147                 case 'P':
 148                         part->option |= OPT_SELECT;
 149                         break;
 150                 case 'E':
 151                         part->option |= OPT_EMPTY;
 152                         break;
 153                 default:
 154                         result = -EINVAL;
 155                         stm32prog_err("Layout line %d: invalid option '%c' in %s)",
 156                                       i, *c, p);
 157                         return -EINVAL;
 158                 }
 159                 c++;
 160         }
 161         if (!(part->option & OPT_SELECT)) {
 162                 stm32prog_err("Layout line %d: missing 'P' in option %s", i, p);
 163                 return -EINVAL;
 164         }
 165
 166         return result;
 167 }
 168
 169 static int parse_id(struct stm32prog_data *data,
 170                     int i, char *p, struct stm32prog_part_t *part)
 171 {
 172         int result = 0;
 173         unsigned long value;
 174
 175         result = strict_strtoul(p, 0, &value);
 176         part->id = value;
 177         if (result || value > PHASE_LAST_USER) {
 178                 stm32prog_err("Layout line %d: invalid phase value = %s", i, p);
 179                 result = -EINVAL;
 180         }
 181
 182         return result;
 183 }
 184
 185 static int parse_name(struct stm32prog_data *data,
 186                       int i, char *p, struct stm32prog_part_t *part)
 187 {
 188         int result = 0;
 189
 190         if (strlen(p) < sizeof(part->name)) {
 191                 strcpy(part->name, p);
 192         } else {
 193                 stm32prog_err("Layout line %d: partition name too long [%d]: %s",
 194                               i, strlen(p), p);
 195                 result = -EINVAL;
 196         }
 197
 198         return result;
 199 }
 200
 201 static int parse_type(struct stm32prog_data *data,
 202                       int i, char *p, struct stm32prog_part_t *part)
 203 {
 204         int result = 0;
 205
 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;
 214         } else {
 215                 result = -EINVAL;
 216         }
 217         if (result)
 218                 stm32prog_err("Layout line %d: type parsing error : '%s'",
 219                               i, p);
 220
 221         return result;
 222 }
 223
 224 static int parse_ip(struct stm32prog_data *data,
 225                     int i, char *p, struct stm32prog_part_t *part)
 226 {
 227         int result = 0;
 228         unsigned int len = 0;
 229
 230         part->dev_id = 0;
 231         if (!strcmp(p, "none")) {
 232                 part->target = STM32PROG_NONE;
 233         } else if (!strncmp(p, "mmc", 3)) {
 234                 part->target = STM32PROG_MMC;
 235                 len = 3;
 236         } else {
 237                 result = -EINVAL;
 238         }
 239         if (len) {
 240                 /* only one digit allowed for device id */
 241                 if (strlen(p) != len + 1) {
 242                         result = -EINVAL;
 243                 } else {
 244                         part->dev_id = p[len] - '0';
 245                         if (part->dev_id > 9)
 246                                 result = -EINVAL;
 247                 }
 248         }
 249         if (result)
 250                 stm32prog_err("Layout line %d: ip parsing error: '%s'", i, p);
 251
 252         return result;
 253 }
 254
 255 static int parse_offset(struct stm32prog_data *data,
 256                         int i, char *p, struct stm32prog_part_t *part)
 257 {
 258         int result = 0;
 259         char *tail;
 260
 261         part->part_id = 0;
 262         part->size = 0;
 263         part->addr = simple_strtoull(p, &tail, 0);
 264         if (tail == p || *tail != '\0') {
 265                 stm32prog_err("Layout line %d: invalid offset '%s'",
 266                               i, p);
 267                 result = -EINVAL;
 268         }
 269
 270         return result;
 271 }
 272
 273 static
 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,
 277         [COL_ID] = parse_id,
 278         [COL_NAME] =  parse_name,
 279         [COL_TYPE] = parse_type,
 280         [COL_IP] = parse_ip,
 281         [COL_OFFSET] = parse_offset,
 282 };
 283
 284 static int parse_flash_layout(struct stm32prog_data *data,
 285                               ulong addr,
 286                               ulong size)
 287 {
 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;
 292         int part_list_size;
 293         int i;
 294
 295         data->part_nb = 0;
 296
 297         /* check if STM32image is detected */
 298         if (!stm32prog_header_check((struct raw_header_s *)addr,
 299                                     &data->header)) {
 300                 u32 checksum;
 301
 302                 addr = addr + BL_HEADER_SIZE;
 303                 size = data->header.image_length;
 304
 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);
 309                         return -EIO;
 310                 }
 311         }
 312         if (!size)
 313                 return -EINVAL;
 314
 315         start = (char *)addr;
 316         last = start + size;
 317
 318         *last = 0x0; /* force null terminated string */
 319         pr_debug("flash layout =\n%s\n", start);
 320
 321         /* calculate expected number of partitions */
 322         part_list_size = 1;
 323         p = start;
 324         while (*p && (p < last)) {
 325                 if (*p++ == '\n') {
 326                         part_list_size++;
 327                         if (p < last && *p == '#')
 328                                 part_list_size--;
 329                 }
 330         }
 331         if (part_list_size > PHASE_LAST_USER) {
 332                 stm32prog_err("Layout: too many partition (%d)",
 333                               part_list_size);
 334                 return -1;
 335         }
 336         part = calloc(sizeof(struct stm32prog_part_t), part_list_size);
 337         if (!part) {
 338                 stm32prog_err("Layout: alloc failed");
 339                 return -ENOMEM;
 340         }
 341         data->part_array = part;
 342
 343         /* main parsing loop */
 344         i = 1;
 345         eof = false;
 346         p = start;
 347         col = start; /* 1st column */
 348         end_of_line = false;
 349         while (!eof) {
 350                 switch (*p) {
 351                 /* CR is ignored and replaced by NULL character */
 352                 case '\r':
 353                         *p = '\0';
 354                         p++;
 355                         continue;
 356                 case '\0':
 357                         end_of_line = true;
 358                         eof = true;
 359                         break;
 360                 case '\n':
 361                         end_of_line = true;
 362                         break;
 363                 case '\t':
 364                         break;
 365                 case '#':
 366                         /* comment line is skipped */
 367                         if (column == 0 && p == col) {
 368                                 while ((p < last) && *p)
 369                                         if (*p++ == '\n')
 370                                                 break;
 371                                 col = p;
 372                                 i++;
 373                                 if (p >= last || !*p) {
 374                                         eof = true;
 375                                         end_of_line = true;
 376                                 }
 377                                 continue;
 378                         }
 379                         /* fall through */
 380                 /* by default continue with the next character */
 381                 default:
 382                         p++;
 383                         continue;
 384                 }
 385
 386                 /* replace by \0: allow string parsing for each column */
 387                 *p = '\0';
 388                 p++;
 389                 if (p >= last) {
 390                         eof = true;
 391                         end_of_line = true;
 392                 }
 393
 394                 /* skip empty line and multiple TAB in tsv file */
 395                 if (strlen(col) == 0) {
 396                         col = p;
 397                         /* skip empty line */
 398                         if (column == 0 && end_of_line) {
 399                                 end_of_line = false;
 400                                 i++;
 401                         }
 402                         continue;
 403                 }
 404
 405                 if (column < COL_NB_STM32) {
 406                         ret = parse[column](data, i, col, part);
 407                         if (ret)
 408                                 return ret;
 409                 }
 410
 411                 /* save the beginning of the next column */
 412                 column++;
 413                 col = p;
 414
 415                 if (!end_of_line)
 416                         continue;
 417
 418                 /* end of the line detected */
 419                 end_of_line = false;
 420
 421                 if (column < COL_NB_STM32) {
 422                         stm32prog_err("Layout line %d: no enought column", i);
 423                         return -EINVAL;
 424                 }
 425                 column = 0;
 426                 part_nb++;
 427                 part++;
 428                 i++;
 429                 if (part_nb >= part_list_size) {
 430                         part = NULL;
 431                         if (!eof) {
 432                                 stm32prog_err("Layout: no enought memory for %d part",
 433                                               part_nb);
 434                                 return -EINVAL;
 435                         }
 436                 }
 437         }
 438         data->part_nb = part_nb;
 439         if (data->part_nb == 0) {
 440                 stm32prog_err("Layout: no partition found");
 441                 return -ENODEV;
 442         }
 443
 444         return 0;
 445 }
 446
 447 static int __init part_cmp(void *priv, struct list_head *a, struct list_head *b)
 448 {
 449         struct stm32prog_part_t *parta, *partb;
 450
 451         parta = container_of(a, struct stm32prog_part_t, list);
 452         partb = container_of(b, struct stm32prog_part_t, list);
 453
 454         return parta->addr > partb->addr ? 1 : -1;
 455 }
 456
 457 static int init_device(struct stm32prog_data *data,
 458                        struct stm32prog_dev_t *dev)
 459 {
 460         struct mmc *mmc = NULL;
 461         struct blk_desc *block_dev = NULL;
 462         int part_id;
 463         u64 first_addr = 0, last_addr = 0;
 464         struct stm32prog_part_t *part, *next_part;
 465
 466         switch (dev->target) {
 467 #ifdef CONFIG_MMC
 468         case STM32PROG_MMC:
 469                 mmc = find_mmc_device(dev->dev_id);
 470                 if (mmc_init(mmc)) {
 471                         stm32prog_err("mmc device %d not found", dev->dev_id);
 472                         return -ENODEV;
 473                 }
 474                 block_dev = mmc_get_blk_desc(mmc);
 475                 if (!block_dev) {
 476                         stm32prog_err("mmc device %d not probed", dev->dev_id);
 477                         return -ENODEV;
 478                 }
 479                 dev->erase_size = mmc->erase_grp_size * block_dev->blksz;
 480                 dev->mmc = mmc;
 481
 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) *
 487                                     block_dev->blksz;
 488                 } else {
 489                         first_addr = (u64)GPT_HEADER_SZ * block_dev->blksz;
 490                         last_addr = (u64)(block_dev->lba - GPT_HEADER_SZ - 1) *
 491                                     block_dev->blksz;
 492                 }
 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);
 497                 break;
 498 #endif
 499         default:
 500                 stm32prog_err("unknown device type = %d", dev->target);
 501                 return -ENODEV;
 502         }
 503         pr_debug(" erase size = 0x%x\n", dev->erase_size);
 504
 505         /* order partition list in offset order */
 506         list_sort(NULL, &dev->part_list, &part_cmp);
 507         part_id = 1;
 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) {
 511                         part->part_id = 0x0;
 512                         part->addr = 0x0;
 513                         if (block_dev)
 514                                 part->size = block_dev->lba * block_dev->blksz;
 515                         else
 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);
 521                         continue;
 522                 }
 523
 524                 part->part_id = part_id++;
 525
 526                 /* last partition : size to the end of the device */
 527                 if (part->list.next != &dev->part_list) {
 528                         next_part =
 529                                 container_of(part->list.next,
 530                                              struct stm32prog_part_t,
 531                                              list);
 532                         if (part->addr < next_part->addr) {
 533                                 part->size = next_part->addr -
 534                                              part->addr;
 535                         } else {
 536                                 stm32prog_err("%s (0x%x): same address : 0x%llx == %s (0x%x): 0x%llx",
 537                                               part->name, part->id,
 538                                               part->addr,
 539                                               next_part->name,
 540                                               next_part->id,
 541                                               next_part->addr);
 542                                 return -EINVAL;
 543                         }
 544                 } else {
 545                         if (part->addr <= last_addr) {
 546                                 part->size = last_addr - part->addr;
 547                         } else {
 548                                 stm32prog_err("%s (0x%x): invalid address 0x%llx (max=0x%llx)",
 549                                               part->name, part->id,
 550                                               part->addr, last_addr);
 551                                 return -EINVAL;
 552                         }
 553                 }
 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);
 558                         return -EINVAL;
 559                 }
 560
 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);
 565                         return -EINVAL;
 566                 }
 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);
 571         }
 572         return 0;
 573 }
 574
 575 static int treat_partition_list(struct stm32prog_data *data)
 576 {
 577         int i, j;
 578         struct stm32prog_part_t *part;
 579
 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);
 583         }
 584
 585         for (i = 0; i < data->part_nb; i++) {
 586                 part = &data->part_array[i];
 587                 part->alt_id = -1;
 588
 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",
 593                                               part->id);
 594                                 return -EINVAL;
 595                         }
 596                         continue;
 597                 }
 598
 599                 if (part->id == PHASE_FLASHLAYOUT ||
 600                     part->id > PHASE_LAST_USER) {
 601                         stm32prog_err("Layout: invalid phase = 0x%x",
 602                                       part->id);
 603                         return -EINVAL;
 604                 }
 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",
 608                                               part->id, i, j);
 609                                 return -EINVAL;
 610                         }
 611                 }
 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;
 617                                 data->dev_nb++;
 618                                 break;
 619                         } else if ((part->target == data->dev[j].target) &&
 620                                    (part->dev_id == data->dev[j].dev_id)) {
 621                                 break;
 622                         }
 623                 }
 624                 if (j == STM32PROG_MAX_DEV) {
 625                         stm32prog_err("Layout: too many device");
 626                         return -EINVAL;
 627                 }
 628                 part->dev = &data->dev[j];
 629                 list_add_tail(&part->list, &data->dev[j].part_list);
 630         }
 631
 632         return 0;
 633 }
 634
 635 static int create_partitions(struct stm32prog_data *data)
 636 {
 637 #ifdef CONFIG_MMC
 638         int offset = 0;
 639         const int buflen = SZ_8K;
 640         char *buf;
 641         char uuid[UUID_STR_LEN + 1];
 642         unsigned char *uuid_bin;
 643         unsigned int mmc_id;
 644         int i;
 645         bool rootfs_found;
 646         struct stm32prog_part_t *part;
 647
 648         buf = malloc(buflen);
 649         if (!buf)
 650                 return -ENOMEM;
 651
 652         puts("partitions : ");
 653         /* initialize the selected device */
 654         for (i = 0; i < data->dev_nb; i++) {
 655                 offset = 0;
 656                 rootfs_found = false;
 657                 memset(buf, 0, buflen);
 658
 659                 list_for_each_entry(part, &data->dev[i].part_list, list) {
 660                         /* skip Raw Image */
 661                         if (part->part_type == RAW_IMAGE)
 662                                 continue;
 663
 664                         if (offset + 100 > buflen) {
 665                                 pr_debug("\n%s: buffer too small, %s skippped",
 666                                          __func__, part->name);
 667                                 continue;
 668                         }
 669
 670                         if (!offset)
 671                                 offset += sprintf(buf, "gpt write mmc %d \"",
 672                                                   data->dev[i].dev_id);
 673
 674                         offset += snprintf(buf + offset, buflen - offset,
 675                                            "name=%s,start=0x%llx,size=0x%llx",
 676                                            part->name,
 677                                            part->addr,
 678                                            part->size);
 679
 680                         if (part->part_type == PART_BINARY)
 681                                 offset += snprintf(buf + offset,
 682                                                    buflen - offset,
 683                                                    ",type="
 684                                                    LINUX_RESERVED_UUID);
 685                         else
 686                                 offset += snprintf(buf + offset,
 687                                                    buflen - offset,
 688                                                    ",type=linux");
 689
 690                         if (part->part_type == PART_SYSTEM)
 691                                 offset += snprintf(buf + offset,
 692                                                    buflen - offset,
 693                                                    ",bootable");
 694
 695                         if (!rootfs_found && !strcmp(part->name, "rootfs")) {
 696                                 mmc_id = part->dev_id;
 697                                 rootfs_found = true;
 698                                 if (mmc_id < ARRAY_SIZE(uuid_mmc)) {
 699                                         uuid_bin =
 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,
 704                                                            buflen - offset,
 705                                                            ",uuid=%s", uuid);
 706                                 }
 707                         }
 708
 709                         offset += snprintf(buf + offset, buflen - offset, ";");
 710                 }
 711
 712                 if (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",
 717                                               buf);
 718                                 free(buf);
 719
 720                                 return -1;
 721                         }
 722                 }
 723
 724                 if (data->dev[i].mmc)
 725                         part_init(mmc_get_blk_desc(data->dev[i].mmc));
 726
 727 #ifdef DEBUG
 728                 sprintf(buf, "gpt verify mmc %d", data->dev[i].dev_id);
 729                 pr_debug("\ncmd: %s", buf);
 730                 if (run_command(buf, 0))
 731                         printf("fail !\n");
 732                 else
 733                         printf("OK\n");
 734
 735                 sprintf(buf, "part list mmc %d", data->dev[i].dev_id);
 736                 run_command(buf, 0);
 737 #endif
 738         }
 739         puts("done\n");
 740
 741         free(buf);
 742 #endif
 743
 744         return 0;
 745 }
 746
 747 static int stm32prog_alt_add(struct stm32prog_data *data,
 748                              struct dfu_entity *dfu,
 749                              struct stm32prog_part_t *part)
 750 {
 751         int ret = 0;
 752         int offset = 0;
 753         char devstr[10];
 754         char dfustr[10];
 755         char buf[ALT_BUF_LEN];
 756         u32 size;
 757         char multiplier,  type;
 758
 759         /* max 3 digit for sector size */
 760         if (part->size > SZ_1M) {
 761                 size = (u32)(part->size / SZ_1M);
 762                 multiplier = 'M';
 763         } else if (part->size > SZ_1K) {
 764                 size = (u32)(part->size / SZ_1K);
 765                 multiplier = 'K';
 766         } else {
 767                 size = (u32)part->size;
 768                 multiplier = 'B';
 769         }
 770         if (IS_SELECT(part) && !IS_EMPTY(part))
 771                 type = 'e'; /*Readable and Writeable*/
 772         else
 773                 type = 'a';/*Readable*/
 774
 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);
 780
 781         if (part->part_type == RAW_IMAGE) {
 782                 u64 dfu_size;
 783
 784                 if (part->dev->target == STM32PROG_MMC)
 785                         dfu_size = part->size / part->dev->mmc->read_bl_len;
 786                 else
 787                         dfu_size = part->size;
 788                 offset += snprintf(buf + offset, ALT_BUF_LEN - offset,
 789                                    "raw 0x0 0x%llx", dfu_size);
 790         } else {
 791                 offset += snprintf(buf + offset,
 792                                    ALT_BUF_LEN - offset,
 793                                    "part");
 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);
 800         }
 801         switch (part->target) {
 802 #ifdef CONFIG_MMC
 803         case STM32PROG_MMC:
 804                 sprintf(dfustr, "mmc");
 805                 sprintf(devstr, "%d", part->dev_id);
 806                 break;
 807 #endif
 808         default:
 809                 stm32prog_err("invalid target: %d", part->target);
 810                 return -ENODEV;
 811         }
 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);
 816
 817         return ret;
 818 }
 819
 820 static int stm32prog_alt_add_virt(struct dfu_entity *dfu,
 821                                   char *name, int phase, int size)
 822 {
 823         int ret = 0;
 824         char devstr[4];
 825         char buf[ALT_BUF_LEN];
 826
 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);
 831
 832         return ret;
 833 }
 834
 835 static int dfu_init_entities(struct stm32prog_data *data)
 836 {
 837         int ret = 0;
 838         int phase, i, alt_id;
 839         struct stm32prog_part_t *part;
 840         struct dfu_entity *dfu;
 841         int alt_nb;
 842
 843         alt_nb = 1; /* number of virtual = CMD */
 844         if (data->part_nb == 0)
 845                 alt_nb++;  /* +1 for FlashLayout */
 846         else
 847                 for (i = 0; i < data->part_nb; i++) {
 848                         if (data->part_array[i].target != STM32PROG_NONE)
 849                                 alt_nb++;
 850                 }
 851
 852         if (dfu_alt_init(alt_nb, &dfu))
 853                 return -ENODEV;
 854
 855         puts("DFU alt info setting: ");
 856         if (data->part_nb) {
 857                 alt_id = 0;
 858                 for (phase = 1;
 859                      (phase <= PHASE_LAST_USER) &&
 860                      (alt_id < alt_nb) && !ret;
 861                      phase++) {
 862                         /* ordering alt setting by phase id */
 863                         part = NULL;
 864                         for (i = 0; i < data->part_nb; i++) {
 865                                 if (phase == data->part_array[i].id) {
 866                                         part = &data->part_array[i];
 867                                         break;
 868                                 }
 869                         }
 870                         if (!part)
 871                                 continue;
 872                         if (part->target == STM32PROG_NONE)
 873                                 continue;
 874                         part->alt_id = alt_id;
 875                         alt_id++;
 876
 877                         ret = stm32prog_alt_add(data, dfu, part);
 878                 }
 879         } else {
 880                 char buf[ALT_BUF_LEN];
 881
 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);
 886         }
 887
 888         if (!ret)
 889                 ret = stm32prog_alt_add_virt(dfu, "virtual", PHASE_CMD, 512);
 890
 891         if (ret)
 892                 stm32prog_err("dfu init failed: %d", ret);
 893         puts("done\n");
 894
 895 #ifdef DEBUG
 896         dfu_show_entities();
 897 #endif
 898         return ret;
 899 }
 900
 901 static void stm32prog_end_phase(struct stm32prog_data *data)
 902 {
 903         if (data->phase == PHASE_FLASHLAYOUT) {
 904                 if (parse_flash_layout(data, STM32_DDR_BASE, 0))
 905                         stm32prog_err("Layout: invalid FlashLayout");
 906                 return;
 907         }
 908
 909         if (!data->cur_part)
 910                 return;
 911 }
 912
 913 void stm32prog_do_reset(struct stm32prog_data *data)
 914 {
 915         if (data->phase == PHASE_RESET) {
 916                 data->phase = PHASE_DO_RESET;
 917                 puts("Reset requested\n");
 918         }
 919 }
 920
 921 void stm32prog_next_phase(struct stm32prog_data *data)
 922 {
 923         int phase, i;
 924         struct stm32prog_part_t *part;
 925         bool found;
 926
 927         phase = data->phase;
 928         switch (phase) {
 929         case PHASE_RESET:
 930         case PHASE_END:
 931         case PHASE_DO_RESET:
 932                 return;
 933         }
 934
 935         /* found next selected partition */
 936         data->cur_part = NULL;
 937         data->phase = PHASE_END;
 938         found = false;
 939         do {
 940                 phase++;
 941                 if (phase > PHASE_LAST_USER)
 942                         break;
 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;
 948                                         data->phase = phase;
 949                                         found = true;
 950                                 }
 951                                 break;
 952                         }
 953                 }
 954         } while (!found);
 955
 956         if (data->phase == PHASE_END)
 957                 puts("Phase=END\n");
 958 }
 959
 960 static void stm32prog_devices_init(struct stm32prog_data *data)
 961 {
 962         int i;
 963         int ret;
 964
 965         ret = treat_partition_list(data);
 966         if (ret)
 967                 goto error;
 968
 969         /* initialize the selected device */
 970         for (i = 0; i < data->dev_nb; i++) {
 971                 ret = init_device(data, &data->dev[i]);
 972                 if (ret)
 973                         goto error;
 974         }
 975
 976         ret = create_partitions(data);
 977         if (ret)
 978                 goto error;
 979
 980         return;
 981
 982 error:
 983         data->part_nb = 0;
 984 }
 985
 986 int stm32prog_dfu_init(struct stm32prog_data *data)
 987 {
 988         /* init device if no error */
 989         if (data->part_nb)
 990                 stm32prog_devices_init(data);
 991
 992         if (data->part_nb)
 993                 stm32prog_next_phase(data);
 994
 995         /* prepare DFU for device read/write */
 996         dfu_free_entities();
 997         return dfu_init_entities(data);
 998 }
 999
1000 int stm32prog_init(struct stm32prog_data *data, ulong addr, ulong size)
1001 {
1002         memset(data, 0x0, sizeof(*data));
1003         data->phase = PHASE_FLASHLAYOUT;
1004
1005         return parse_flash_layout(data, addr, size);
1006 }
1007
1008 void stm32prog_clean(struct stm32prog_data *data)
1009 {
1010         /* clean */
1011         dfu_free_entities();
1012         free(data->part_array);
1013         free(data->header_data);
1014 }
1015
1016 /* DFU callback: used after serial and direct DFU USB access */
1017 void dfu_flush_callback(struct dfu_entity *dfu)
1018 {
1019         if (!stm32prog_data)
1020                 return;
1021
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 */
1027                 }
1028         }
1029
1030         if (!stm32prog_data->cur_part)
1031                 return;
1032
1033         if (dfu->alt == stm32prog_data->cur_part->alt_id) {
1034                 stm32prog_end_phase(stm32prog_data);
1035                 stm32prog_next_phase(stm32prog_data);
1036         }
1037 }
1038
1039 void dfu_initiated_callback(struct dfu_entity *dfu)
1040 {
1041         if (!stm32prog_data)
1042                 return;
1043
1044         if (!stm32prog_data->cur_part)
1045                 return;
1046
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);
1051         }
1052 }