diff mbox series

[v2,1/5] mmc_utils: Extract FFU code to mmc_ffu.c for future FFU mode expansion

Message ID 20241003183848.58626-2-beanhuo@iokpp.de (mailing list archive)
State New
Headers show
Series Add multiple FFU modes based on eMMC specification 6.6.18 for flexible firmware updates | expand

Commit Message

Bean Huo Oct. 3, 2024, 6:38 p.m. UTC
From: Bean Huo <beanhuo@micron.com>

Refactor FFU functionality by extracting existing FFU code from `mmc_cmds.c` into a dedicated file,
`mmc_ffu.c`. Updated `do_ffu` in `mmc_utils` to reflect the new structure and interface. This
restructuring provides better code organization and a clearer separation of concerns, making it
easier to maintain and extend FFU functionality.

Follow-up patches will focus on implementing additional FFU modes and enhancements.

Signed-off-by: Bean Huo <beanhuo@micron.com>
---
 Makefile   |   1 +
 mmc.c      |  11 +-
 mmc_cmds.c | 274 --------------------------------------------
 mmc_cmds.h |  52 +++++++++
 mmc_ffu.c  | 324 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 5 files changed, 384 insertions(+), 278 deletions(-)
 create mode 100644 mmc_ffu.c

Comments

Avri Altman Oct. 6, 2024, 8:18 a.m. UTC | #1
> 
> From: Bean Huo <beanhuo@micron.com>
> 
> Refactor FFU functionality by extracting existing FFU code from `mmc_cmds.c`
> into a dedicated file, `mmc_ffu.c`. Updated `do_ffu` in `mmc_utils` to reflect
> the new structure and interface. This restructuring provides better code
> organization and a clearer separation of concerns, making it easier to
> maintain and extend FFU functionality.
> 
> Follow-up patches will focus on implementing additional FFU modes and
> enhancements.
> 
> Signed-off-by: Bean Huo <beanhuo@micron.com>
> ---
>  Makefile   |   1 +
>  mmc.c      |  11 +-
>  mmc_cmds.c | 274 --------------------------------------------
>  mmc_cmds.h |  52 +++++++++
>  mmc_ffu.c  | 324
> +++++++++++++++++++++++++++++++++++++++++++++++++++++
>  5 files changed, 384 insertions(+), 278 deletions(-)  create mode 100644
> mmc_ffu.c
> 
> diff --git a/Makefile b/Makefile
> index 06ae0f7..35aca6c 100644
> --- a/Makefile
> +++ b/Makefile
> @@ -7,6 +7,7 @@ objects = \
>         mmc.o \
>         mmc_cmds.o \
>         lsmmc.o \
> +       mmc_ffu.o \
I don't think a new module is even needed.

>         3rdparty/hmac_sha/hmac_sha2.o \
>         3rdparty/hmac_sha/sha2.o
> 
> diff --git a/mmc.c b/mmc.c
> index 2c5b9b5..52c5a89 100644
> --- a/mmc.c
> +++ b/mmc.c
> @@ -227,11 +227,14 @@ static struct Command commands[] = {
>                   "The device path should specify the scr file directory.",
>           NULL
>         },
> -       { do_ffu, -2,
> -         "ffu", "<image name> <device> [chunk-bytes]\n"
> +       { do_ffu, -4,
> +         "ffu", "-i <image name> -p <device> [ -c <chunk-bytes>] [-m
> <ffu_mode>]\n"
>                 "Run Field Firmware Update with <image name> on <device>.\n"
> -               "[chunk-bytes] is optional and defaults to its max - 512k. "
> -               "should be in decimal bytes and sector aligned.\n",
> +               "[-c <chunk-bytes>] is optional and defaults to its max - 512k. "
> +               "should be in decimal bytes and sector aligned.\n"
> +               "[-m <ffu_mode>] Optional, provides five firmware bundle
> download command modes:\n"
> +               " -m 1: Default mode, utilizing the CMD6+CMD23+CMD25+CMD6
> command sequence. This \n"
> +               " may exit FFU mode during firmware bundle downloading
> + if FW size exceeds the chunk size. \n",
>           NULL
>         },
Did you consider, instead of adding a new argument <ffu_mode>, to add new commands?
e.g. ffu2, ffu3, etc...

>         { do_erase, -4,
> diff --git a/mmc_cmds.c b/mmc_cmds.c
> index 3b1bcf4..22ab7d9 100644
> --- a/mmc_cmds.c
> +++ b/mmc_cmds.c
> @@ -58,41 +58,6 @@
>  #define WPTYPE_PWRON 2
>  #define WPTYPE_PERM 3
> 
> -static inline __u32 per_byte_htole32(__u8 *arr) -{
> -       return arr[0] | arr[1] << 8 | arr[2] << 16 | arr[3] << 24;
> -}
> -
> -static int read_extcsd(int fd, __u8 *ext_csd) -{
> -       int ret = 0;
> -       struct mmc_ioc_cmd idata;
> -       memset(&idata, 0, sizeof(idata));
> -       memset(ext_csd, 0, sizeof(__u8) * 512);
> -       idata.write_flag = 0;
> -       idata.opcode = MMC_SEND_EXT_CSD;
> -       idata.arg = 0;
> -       idata.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;
> -       idata.blksz = 512;
> -       idata.blocks = 1;
> -       mmc_ioc_cmd_set_data(idata, ext_csd);
> -
> -       ret = ioctl(fd, MMC_IOC_CMD, &idata);
> -       if (ret)
> -               perror("ioctl");
> -
> -       return ret;
> -}
> -
> -static void fill_switch_cmd(struct mmc_ioc_cmd *cmd, __u8 index, __u8
> value) -{
> -       cmd->opcode = MMC_SWITCH;
> -       cmd->write_flag = 1;
> -       cmd->arg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) | (index << 16) |
> -                  (value << 8) | EXT_CSD_CMD_SET_NORMAL;
> -       cmd->flags = MMC_RSP_SPI_R1B | MMC_RSP_R1B | MMC_CMD_AC;
> -}
> -
>  static int
>  write_extcsd_value(int fd, __u8 index, __u8 value, unsigned int timeout_ms)
> { @@ -2101,18 +2066,6 @@ struct rpmb_frame {
>         u_int16_t req_resp;
>  };
> 
> -static inline void set_single_cmd(struct mmc_ioc_cmd *ioc, __u32 opcode,
> -                                 int write_flag, unsigned int blocks,
> -                                 __u32 arg)
> -{
> -       ioc->opcode = opcode;
> -       ioc->write_flag = write_flag;
> -       ioc->arg = arg;
> -       ioc->blksz = 512;
> -       ioc->blocks = blocks;
> -       ioc->flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;
> -}
> -
>  /* Performs RPMB operation.
>   *
>   * @fd: RPMB device on which we should perform ioctl command @@ -
> 2810,233 +2763,6 @@ out:
>         return ret;
>  }
> 
> -static void set_ffu_single_cmd(struct mmc_ioc_multi_cmd *multi_cmd,
> -                              __u8 *ext_csd, unsigned int bytes, __u8 *buf,
> -                              off_t offset)
> -{
> -       __u32 arg = per_byte_htole32(&ext_csd[EXT_CSD_FFU_ARG_0]);
> -
> -       /* send block count */
> -       set_single_cmd(&multi_cmd->cmds[1], MMC_SET_BLOCK_COUNT, 0, 0,
> -                      bytes / 512);
> -       multi_cmd->cmds[1].flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 |
> MMC_CMD_AC;
> -
> -       /*
> -        * send image chunk: blksz and blocks essentially do not matter, as
> -        * long as the product is fw_size, but some hosts don't handle larger
> -        * blksz well.
> -        */
> -       set_single_cmd(&multi_cmd->cmds[2], MMC_WRITE_MULTIPLE_BLOCK,
> 1,
> -                      bytes / 512, arg);
> -       mmc_ioc_cmd_set_data(multi_cmd->cmds[2], buf + offset);
> -}
> -
> -int do_ffu(int nargs, char **argv)
> -{
> -       int dev_fd, img_fd;
> -       int retry = 3, ret = -EINVAL;
> -       unsigned int sect_size;
> -       __u8 ext_csd[512];
> -       __u8 *buf = NULL;
> -       off_t fw_size, bytes_left, off;
> -       char *device;
> -       struct mmc_ioc_multi_cmd *multi_cmd = NULL;
> -       unsigned int default_chunk = MMC_IOC_MAX_BYTES;
> -       __u32 sect_done = 0;
> -
> -       assert (nargs == 3 || nargs == 4);
> -
> -       device = argv[2];
> -       dev_fd = open(device, O_RDWR);
> -       if (dev_fd < 0) {
> -               perror("device open failed");
> -               exit(1);
> -       }
> -       img_fd = open(argv[1], O_RDONLY);
> -       if (img_fd < 0) {
> -               perror("image open failed");
> -               close(dev_fd);
> -               exit(1);
> -       }
> -
> -       ret = read_extcsd(dev_fd, ext_csd);
> -       if (ret) {
> -               fprintf(stderr, "Could not read EXT_CSD from %s\n", device);
> -               goto out;
> -       }
> -
> -       if (ext_csd[EXT_CSD_REV] < EXT_CSD_REV_V5_0) {
> -               fprintf(stderr,
> -                       "The FFU feature is only available on devices >= "
> -                       "MMC 5.0, not supported in %s\n", device);
> -               goto out;
> -       }
> -
> -       if (!(ext_csd[EXT_CSD_SUPPORTED_MODES] & EXT_CSD_FFU)) {
> -               fprintf(stderr, "FFU is not supported in %s\n", device);
> -               goto out;
> -       }
> -
> -       if (ext_csd[EXT_CSD_FW_CONFIG] & EXT_CSD_UPDATE_DISABLE) {
> -               fprintf(stderr, "Firmware update was disabled in %s\n", device);
> -               goto out;
> -       }
> -
> -       fw_size = lseek(img_fd, 0, SEEK_END);
> -       if (fw_size == 0) {
> -               fprintf(stderr, "Wrong firmware size");
> -               goto out;
> -       }
> -
> -       /* allocate maximum required */
> -       buf = malloc(fw_size);
> -       multi_cmd = calloc(1, sizeof(struct mmc_ioc_multi_cmd) +
> -                               4 * sizeof(struct mmc_ioc_cmd));
> -       if (!buf || !multi_cmd) {
> -               perror("failed to allocate memory");
> -               goto out;
> -       }
> -
> -       /* ensure fw is multiple of native sector size */
> -       sect_size = (ext_csd[EXT_CSD_DATA_SECTOR_SIZE] == 0) ? 512 : 4096;
> -       if (fw_size % sect_size) {
> -               fprintf(stderr, "Firmware data size (%jd) is not aligned!\n",
> (intmax_t)fw_size);
> -               goto out;
> -       }
> -
> -       if (nargs == 4) {
> -               default_chunk = strtol(argv[3], NULL, 10);
> -               if (default_chunk > MMC_IOC_MAX_BYTES || default_chunk % 512)
> {
> -                       fprintf(stderr, "Invalid chunk size");
> -                       goto out;
> -               }
> -       }
> -
> -       /* prepare multi_cmd for FFU based on cmd to be used */
> -
> -       multi_cmd->num_of_cmds = 4;
> -
> -       /* put device into ffu mode */
> -       fill_switch_cmd(&multi_cmd->cmds[0], EXT_CSD_MODE_CONFIG,
> -                       EXT_CSD_FFU_MODE);
> -
> -       /* return device into normal mode */
> -       fill_switch_cmd(&multi_cmd->cmds[3], EXT_CSD_MODE_CONFIG,
> -                       EXT_CSD_NORMAL_MODE);
> -
> -       /* read firmware */
> -       lseek(img_fd, 0, SEEK_SET);
> -       if (read(img_fd, buf, fw_size) != fw_size) {
> -               perror("Could not read the firmware file: ");
> -               ret = -ENOSPC;
> -               goto out;
> -       }
> -
> -do_retry:
> -       bytes_left = fw_size;
> -       off = 0;
> -       while (bytes_left) {
> -               unsigned int chunk_size = bytes_left < default_chunk ?
> -                                         bytes_left : default_chunk;
> -
> -               /* prepare multi_cmd for FFU based on cmd to be used */
> -               set_ffu_single_cmd(multi_cmd, ext_csd, chunk_size, buf, off);
> -
> -               /* send ioctl with multi-cmd */
> -               ret = ioctl(dev_fd, MMC_IOC_MULTI_CMD, multi_cmd);
> -
> -               if (ret) {
> -                       perror("Multi-cmd ioctl");
> -                       /*
> -                        * In case multi-cmd ioctl failed before exiting from
> -                        * ffu mode
> -                        */
> -                       ioctl(dev_fd, MMC_IOC_CMD, &multi_cmd->cmds[3]);
> -                       goto out;
> -               }
> -
> -               bytes_left -= chunk_size;
> -               off += chunk_size;
> -       }
> -
> -       /*
> -        * By spec - check if mode operation codes are supported in ffu features,
> -        * if not then skip checking number of sectors programmed after install
> -        */
> -       if (!ext_csd[EXT_CSD_FFU_FEATURES]) {
> -               fprintf(stderr, "Please reboot to complete firmware installation on
> %s\n", device);
> -               ret = 0;
> -               goto out;
> -       }
> -
> -       ret = read_extcsd(dev_fd, ext_csd);
> -       if (ret) {
> -               fprintf(stderr, "Could not read EXT_CSD from %s\n", device);
> -               goto out;
> -       }
> -
> -       /* Test if we need to restart the download */
> -       sect_done =
> per_byte_htole32(&ext_csd[EXT_CSD_NUM_OF_FW_SEC_PROG_0]);
> -       /* By spec, host should re-start download from the first sector if
> sect_done is 0 */
> -       if (sect_done == 0) {
> -               if (retry--) {
> -                       fprintf(stderr, "Programming failed. Retrying... (%d)\n", retry);
> -                       goto do_retry;
> -               }
> -               fprintf(stderr, "Programming failed! Aborting...\n");
> -               goto out;
> -       }
> -
> -       if ((sect_done * sect_size) == fw_size) {
> -               fprintf(stderr, "Programmed %jd/%jd bytes\n", (intmax_t)fw_size,
> (intmax_t)fw_size);
> -               fprintf(stderr, "Programming finished with status %d \n", ret);
> -       }
> -       else {
> -               fprintf(stderr, "FW size and number of sectors written mismatch.
> Status return %d\n", ret);
> -               goto out;
> -       }
> -
> -       fprintf(stderr, "Installing firmware on %s...\n", device);
> -       /* Re-enter ffu mode and install the firmware */
> -       multi_cmd->num_of_cmds = 2;
> -
> -       /* set ext_csd to install mode */
> -       fill_switch_cmd(&multi_cmd->cmds[1],
> EXT_CSD_MODE_OPERATION_CODES,
> -                       EXT_CSD_FFU_INSTALL);
> -
> -       /* send ioctl with multi-cmd */
> -       ret = ioctl(dev_fd, MMC_IOC_MULTI_CMD, multi_cmd);
> -
> -       if (ret) {
> -               perror("Multi-cmd ioctl failed setting install mode");
> -               /* In case multi-cmd ioctl failed before exiting from ffu mode */
> -               ioctl(dev_fd, MMC_IOC_CMD, &multi_cmd->cmds[3]);
> -               goto out;
> -       }
> -
> -       ret = read_extcsd(dev_fd, ext_csd);
> -       if (ret) {
> -               fprintf(stderr, "Could not read EXT_CSD from %s\n", device);
> -               goto out;
> -       }
> -
> -       /* return status */
> -       ret = ext_csd[EXT_CSD_FFU_STATUS];
> -       if (ret) {
> -               fprintf(stderr, "%s: error %d during FFU install:\n", device, ret);
> -               goto out;
> -       } else {
> -               fprintf(stderr, "FFU finished successfully\n");
> -       }
> -
> -out:
> -       free(buf);
> -       free(multi_cmd);
> -       close(img_fd);
> -       close(dev_fd);
> -       return ret;
> -}
> -
>  int do_general_cmd_read(int nargs, char **argv)  {
>         int dev_fd;
> diff --git a/mmc_cmds.h b/mmc_cmds.h
> index 5f2bef1..40a137d 100644
> --- a/mmc_cmds.h
> +++ b/mmc_cmds.h
> @@ -16,6 +16,57 @@
>   * Modified to add field firmware update support,
>   * those modifications are Copyright (c) 2016 SanDisk Corp.
>   */
> +#include <sys/ioctl.h>
> +#include <sys/stat.h>
> +#include <string.h>
> +#include "mmc.h"
> +
> +static inline __u32 per_byte_htole32(__u8 *arr) {
> +       return arr[0] | arr[1] << 8 | arr[2] << 16 | arr[3] << 24; }
> +
> +
> +static inline int read_extcsd(int fd, __u8 *ext_csd)
AFAIK, while the Linux kernel coding conventions do not explicitly forbid implementing C code in header files,
they strongly discourage it except in specific cases.
You could just include it in mmc_cmds.h, but again - I don't think a new module is even needed.

> +       int ret = 0;
> +       struct mmc_ioc_cmd idata;
> +       memset(&idata, 0, sizeof(idata));
> +       memset(ext_csd, 0, sizeof(__u8) * 512);
> +       idata.write_flag = 0;
> +       idata.opcode = MMC_SEND_EXT_CSD;
> +       idata.arg = 0;
> +       idata.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;
> +       idata.blksz = 512;
> +       idata.blocks = 1;
> +       mmc_ioc_cmd_set_data(idata, ext_csd);
> +
> +       ret = ioctl(fd, MMC_IOC_CMD, &idata);
> +       if (ret)
> +               perror("ioctl");
> +
> +       return ret;
> +}
> +
> +static inline void fill_switch_cmd(struct mmc_ioc_cmd *cmd, __u8 index,
> __u8 value)
> +{
> +       cmd->opcode = MMC_SWITCH;
> +       cmd->write_flag = 1;
> +       cmd->arg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) | (index << 16) |
> +                  (value << 8) | EXT_CSD_CMD_SET_NORMAL;
> +       cmd->flags = MMC_RSP_SPI_R1B | MMC_RSP_R1B | MMC_CMD_AC;
> +}
> +
> +static inline void set_single_cmd(struct mmc_ioc_cmd *ioc, __u32 opcode,
> int write_flag,
> +                                               unsigned int blocks, __u32 arg)
> +{
> +       ioc->opcode = opcode;
> +       ioc->write_flag = write_flag;
> +       ioc->arg = arg;
> +       ioc->blksz = 512;
> +       ioc->blocks = blocks;
> +       ioc->flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;
> +}
> 
>  /* mmc_cmds.c */
>  int do_read_extcsd(int nargs, char **argv);
> @@ -50,3 +101,4 @@ int do_general_cmd_read(int nargs, char **argv);
>  int do_softreset(int nargs, char **argv);
>  int do_preidle(int nargs, char **argv);
>  int do_alt_boot_op(int nargs, char **argv);
> +int do_ffu(int nargs, char **argv);
> diff --git a/mmc_ffu.c b/mmc_ffu.c
> new file mode 100644
> index 0000000..5f7cb00
> --- /dev/null
> +++ b/mmc_ffu.c
> @@ -0,0 +1,324 @@
> +// SPDX-License-Identifier: GPL-2.0-or-later
> +/*
> + * Modified and add more FFU modes.
> + * And changed and updated by: Bean Huo <beanhuo@micron.com>
> + */
> +
> +#include <stdio.h>
> +#include <stdlib.h>
> +#include <stdint.h>
> +#include <fcntl.h>
> +#include <sys/ioctl.h>
> +#include <sys/types.h>
> +#include <ctype.h>
> +#include <errno.h>
> +#include <stdbool.h>
> +#include <assert.h>
> +#include <unistd.h>
> +
> +#include "mmc.h"
> +#include "mmc_cmds.h"
> +
> +static int do_ffu_download(int *dev_fd, __u8 *ext_csd, __u8 *fw_buf, off_t
> fw_size, unsigned int chunk_size);
> +
> +static void set_ffu_download_cmd(struct mmc_ioc_multi_cmd *multi_cmd,
> __u8 *ext_csd,
> +                               unsigned int bytes, __u8 *buf, off_t offset)
> +{
> +       __u32 arg = per_byte_htole32(&ext_csd[EXT_CSD_FFU_ARG_0]);
> +
> +       /* send block count */
> +       set_single_cmd(&multi_cmd->cmds[1], MMC_SET_BLOCK_COUNT, 0, 0,
> bytes / 512);
> +       multi_cmd->cmds[1].flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 |
> MMC_CMD_AC;
> +
> +       /*
> +        * send image chunk: blksz and blocks essentially do not matter, as
> +        * long as the product is fw_size, but some hosts don't handle larger
> +        * blksz well.
> +        */
> +       set_single_cmd(&multi_cmd->cmds[2], MMC_WRITE_MULTIPLE_BLOCK,
> 1, bytes / 512, arg);
> +       mmc_ioc_cmd_set_data(multi_cmd->cmds[2], buf + offset);
> +}
> +
> +static int get_ffu_sectors_programmed(int *dev_fd, __u8 *ext_csd)
> +{
> +       int ret;
> +
> +       ret = read_extcsd(*dev_fd, ext_csd);
> +       if (ret) {
> +               fprintf(stderr, "Could not read EXT_CSD\n");
> +               return ret;
> +       }
> +
> +       ret = per_byte_htole32((__u8
> *)&ext_csd[EXT_CSD_NUM_OF_FW_SEC_PROG_0]);
> +
> +       return ret;
> +}
> +
> +static bool ffu_is_supported(__u8 *ext_csd, char *device)
> +{
> +       if (ext_csd == NULL) {
> +               fprintf(stderr, "ext_cst is NULL\n");
> +               return false;
> +       }
> +
> +       if (ext_csd[EXT_CSD_REV] < EXT_CSD_REV_V5_0) {
> +               fprintf(stderr, "The FFU feature is only available on devices >= "
> +                       "MMC 5.0, not supported in %s\n", device);
> +               return false;
> +       }
> +
> +       if (!(ext_csd[EXT_CSD_SUPPORTED_MODES] & EXT_CSD_FFU)) {
> +               fprintf(stderr, "FFU is not supported in %s\n", device);
> +               return false;
> +       }
> +
> +       if (ext_csd[EXT_CSD_FW_CONFIG] & EXT_CSD_UPDATE_DISABLE) {
> +               fprintf(stderr, "Firmware update was disabled in %s\n", device);
> +               return false;
> +       }
> +
> +       return true;
> +}
> +
> +static int do_ffu_download(int *dev_fd, __u8 *ext_csd, __u8 *fw_buf, off_t
> fw_size,
> +                                                       unsigned int chunk_size)
> +{
> +       int ret;
> +       __u8 num_of_cmds = 4;
> +       off_t bytes_left, off;
> +       unsigned int bytes_per_loop, sect_done, retry = 3;
> +       struct mmc_ioc_multi_cmd *multi_cmd = NULL;
> +
> +       if (!dev_fd || !fw_buf || !ext_csd) {
> +               fprintf(stderr, "unexpected NULL pointer\n");
> +               return -EINVAL;
> +       }
> +       /* allocate maximum required */
> +       multi_cmd = calloc(1, sizeof(struct mmc_ioc_multi_cmd) +
> num_of_cmds * sizeof(struct mmc_ioc_cmd));
> +       if (!multi_cmd) {
> +               perror("failed to allocate memory");
> +               return -ENOMEM;
> +       }
> +
> +       /* prepare multi_cmd for FFU based on cmd to be used */
> +       /* put device into ffu mode */
> +       fill_switch_cmd(&multi_cmd->cmds[0], EXT_CSD_MODE_CONFIG,
> EXT_CSD_FFU_MODE);
> +
> +       /* return device into normal mode */
> +       fill_switch_cmd(&multi_cmd->cmds[3], EXT_CSD_MODE_CONFIG,
> EXT_CSD_NORMAL_MODE);
> +
> +do_retry:
> +       bytes_left = fw_size;
> +       off = 0;
> +       multi_cmd->num_of_cmds = num_of_cmds;
> +
> +       while (bytes_left) {
> +               bytes_per_loop = bytes_left < chunk_size ? bytes_left : chunk_size;
> +
> +               /* prepare multi_cmd for FFU based on cmd to be used */
> +               set_ffu_download_cmd(multi_cmd, ext_csd, bytes_per_loop,
> fw_buf, off);
> +
> +               /* send ioctl with multi-cmd, download firmware bundle */
> +               ret = ioctl(*dev_fd, MMC_IOC_MULTI_CMD, multi_cmd);
> +
> +               if (ret) {
> +                       perror("Multi-cmd ioctl");
> +                       /*
> +                        * In case multi-cmd ioctl failed before exiting from
> +                        * ffu mode
> +                        */
> +                       ioctl(*dev_fd, MMC_IOC_CMD, &multi_cmd->cmds[3]);
> +                       goto out;
> +               }
> +
> +               sect_done = get_ffu_sectors_programmed(dev_fd, ext_csd);
> +               if (sect_done <= 0) {
> +                       /* By spec, host should re-start download from the first sector
> if sect_done is 0 */
> +                       ioctl(*dev_fd, MMC_IOC_CMD, &multi_cmd->cmds[3]);
> +                       if (retry > 0) {
> +                               retry--;
> +                               fprintf(stderr, "Programming failed. Retrying... (%d)\n",
> retry);
> +                               goto do_retry;
> +                       }
> +                       fprintf(stderr, "Programming failed! Aborting...\n");
> +                       ret = sect_done;
> +                       goto out;
> +               } else {
> +                       fprintf(stderr, "Programmed %d/%jd bytes\r", sect_done * 512,
> (intmax_t)fw_size);
> +               }
> +
> +               bytes_left -= bytes_per_loop;
> +               off += bytes_per_loop;
> +       }
> +
> +       ret = get_ffu_sectors_programmed(dev_fd, ext_csd);
> +out:
> +       free(multi_cmd);
> +       return ret;
> +
> +}
> +
> +int do_ffu(int nargs, char **argv)
> +{
> +       int opt;
> +       int dev_fd, img_fd;
> +       int ret = -EINVAL;
> +       unsigned int sect_size;
> +       __u8 ext_csd[512];
> +       __u8 *fw_buf = NULL;
> +       off_t fw_size;
> +       char *device, *fw_img;
> +       struct mmc_ioc_multi_cmd *multi_cmd = NULL;
> +       unsigned int default_chunk = MMC_IOC_MAX_BYTES;
> +       int sect_done = 0;
> +       __u8 ffu_mode = 1;
> +
> +       assert(nargs >= 4);
> +
> +       while ((opt = getopt(nargs, argv, "i:p:m:c:")) != -1) {
Changing the api for just one command type is problematic.
If we are going to do it,  then it should be done in its own designated series,
And in a way that will not break the legacy api.

Also, given the extent of use of this feature - I don't think that the api of the current mode (default) should be changed.
Meaning people should still be able to run ./mmc ffu <fluf> <dev> as they always did.

> +               switch (opt) {
> +               case 'i':
> +                       fw_img = optarg;
> +                       break;
> +               case 'p':
> +                       device = optarg;
> +                       break;
> +               case 'c':
> +                       default_chunk = atoi(optarg);
> +                       if (default_chunk > MMC_IOC_MAX_BYTES || default_chunk %
> 512) {
> +                               fprintf(stderr, "Invalid chunk size");
> +                               exit(1);
> +                       }
> +                       break;
> +               case 'm':
> +                       ffu_mode = atoi(optarg);
> +                       if (ffu_mode > 1) {
> +                               fprintf(stderr, "Unsupported ffu mode `%d'.\n",
> ffu_mode);
> +                               abort();
> +                       }
> +                       break;
> +               default:
> +                       /* Unknown option or missing argument for options */
> +                       if (isprint(optopt))
> +                               fprintf(stderr, "Unknown option `-%c'.\n", optopt);
> +                       else
> +                               fprintf(stderr, "Unknown option character `\\x%x'.\n",
> optopt);
> +                       abort();
> +               }
> +       }
> +       fprintf(stderr, "eMMC Devie: %s, fw %s, FFU mode %d, chunk size:
> %d\n",
> +                                                       device, fw_img, ffu_mode, default_chunk);
I think that all this part, from here and up to pretty much do_retry,
Can be packed into a ffu_prepare() handler.
Each do_ffu: do_ffu, do_ffu2, do_ffu3 etc. can call it with its applicable arguments.
I think you would end up with much less code this way.

The do_retry part is common to all modes: __do_ffu().

And a 3rd wrapping-up phase, post do_retry.

Thanks,
Avri

> +       dev_fd = open(device, O_RDWR);
> +       if (dev_fd < 0) {
> +               perror("device open failed");
> +               exit(1);
> +       }
> +       img_fd = open(fw_img, O_RDONLY);
> +       if (img_fd < 0) {
> +               perror("image open failed");
> +               close(dev_fd);
> +               exit(1);
> +       }
> +
> +       ret = read_extcsd(dev_fd, ext_csd);
> +       if (ret) {
> +               fprintf(stderr, "Could not read EXT_CSD from %s\n", device);
> +               goto out;
> +       }
> +       if (ffu_is_supported(ext_csd, device) <= 0)
> +               goto out;
> +
> +       fw_size = lseek(img_fd, 0, SEEK_END);
> +       if (fw_size == 0) {
> +               fprintf(stderr, "Wrong firmware size");
> +               goto out;
> +       }
> +       /* ensure fw is multiple of native sector size */
> +       sect_size = (ext_csd[EXT_CSD_DATA_SECTOR_SIZE] == 0) ? 512 : 4096;
> +       if (fw_size % sect_size) {
> +               fprintf(stderr, "Firmware data size (%jd) is not aligned!\n",
> (intmax_t)fw_size);
> +               goto out;
> +       }
> +       /* allocate maximum required */
> +       fw_buf = malloc(fw_size);
> +       if (!fw_buf) {
> +               perror("failed to allocate memory");
> +               goto out;
> +       }
> +       /* read firmware */
> +       lseek(img_fd, 0, SEEK_SET);
> +       if (read(img_fd, fw_buf, fw_size) != fw_size) {
> +               perror("Could not read the firmware file: ");
> +               ret = -ENOSPC;
> +               goto out;
> +       }
> +
> +       sect_done = do_ffu_download((int *)&dev_fd, ext_csd, fw_buf, fw_size,
> default_chunk);
> +
> +       /* Check programmed sectors */
> +       if (sect_done > 0 && (sect_done * 512) == fw_size) {
> +               fprintf(stderr, "Programmed %jd/%jd bytes\n", (intmax_t)fw_size,
> (intmax_t)fw_size);
> +               fprintf(stderr, "Programming finished with status %d \n", ret);
> +       } else {
> +               fprintf(stderr, "Firmware bundle download failed. Operation status
> %d\n", sect_done);
> +               ret = -EIO;
> +               goto out;
> +       }
> +       /*
> +        * By spec - check if mode operation codes are supported in ffu
> features,
> +        * if not then skip checking number of sectors programmed after install
> +        */
> +       if (!ext_csd[EXT_CSD_FFU_FEATURES]) {
> +               fprintf(stderr, "Please reboot to complete firmware installation on
> %s\n", device);
> +               ret = 0;
> +               goto out;
> +       }
> +
> +       fprintf(stderr, "Installing firmware on %s...\n", device);
> +       multi_cmd = calloc(1, sizeof(struct mmc_ioc_multi_cmd) + 2 *
> sizeof(struct mmc_ioc_cmd));
> +       if (!multi_cmd) {
> +               perror("failed to allocate memory");
> +               ret = -ENOMEM;
> +               goto out;
> +       }
> +
> +       /* Re-enter ffu mode and install the firmware */
> +       multi_cmd->num_of_cmds = 2;
> +       /* put device into ffu mode */
> +       fill_switch_cmd(&multi_cmd->cmds[0], EXT_CSD_MODE_CONFIG,
> EXT_CSD_FFU_MODE);
> +       /* Re-enter ffu mode and set ext_csd to install mode */
> +       fill_switch_cmd(&multi_cmd->cmds[1],
> EXT_CSD_MODE_OPERATION_CODES, EXT_CSD_FFU_INSTALL);
> +
> +       /* send ioctl with multi-cmd */
> +       ret = ioctl(dev_fd, MMC_IOC_MULTI_CMD, multi_cmd);
> +
> +       if (ret) {
> +               perror("Multi-cmd ioctl failed setting install mode");
> +               fill_switch_cmd(&multi_cmd->cmds[1], EXT_CSD_MODE_CONFIG,
> EXT_CSD_NORMAL_MODE);
> +               /* In case multi-cmd ioctl failed before exiting from ffu mode */
> +               ioctl(dev_fd, MMC_IOC_CMD, &multi_cmd->cmds[1]);
> +               goto out;
> +       }
> +
> +       ret = read_extcsd(dev_fd, ext_csd);
> +       if (ret) {
> +               fprintf(stderr, "Could not read EXT_CSD from %s\n", device);
> +               goto out;
> +       }
> +
> +       /* return status */
> +       ret = ext_csd[EXT_CSD_FFU_STATUS];
> +       if (ret)
> +               fprintf(stderr, "%s: error %d during FFU install:\n", device, ret);
> +       else
> +               fprintf(stderr, "FFU finished successfully\n");
> +
> +out:
> +       if (fw_buf)
> +               free(fw_buf);
> +       if (multi_cmd)
> +               free(multi_cmd);
> +       close(img_fd);
> +       close(dev_fd);
> +       return ret;
> +}
> --
> 2.34.1
>
diff mbox series

Patch

diff --git a/Makefile b/Makefile
index 06ae0f7..35aca6c 100644
--- a/Makefile
+++ b/Makefile
@@ -7,6 +7,7 @@  objects = \
 	mmc.o \
 	mmc_cmds.o \
 	lsmmc.o \
+	mmc_ffu.o \
 	3rdparty/hmac_sha/hmac_sha2.o \
 	3rdparty/hmac_sha/sha2.o
 
diff --git a/mmc.c b/mmc.c
index 2c5b9b5..52c5a89 100644
--- a/mmc.c
+++ b/mmc.c
@@ -227,11 +227,14 @@  static struct Command commands[] = {
 		  "The device path should specify the scr file directory.",
 	  NULL
 	},
-	{ do_ffu, -2,
-	  "ffu", "<image name> <device> [chunk-bytes]\n"
+	{ do_ffu, -4,
+	  "ffu", "-i <image name> -p <device> [ -c <chunk-bytes>] [-m <ffu_mode>]\n"
 		"Run Field Firmware Update with <image name> on <device>.\n"
-		"[chunk-bytes] is optional and defaults to its max - 512k. "
-		"should be in decimal bytes and sector aligned.\n",
+		"[-c <chunk-bytes>] is optional and defaults to its max - 512k. "
+		"should be in decimal bytes and sector aligned.\n"
+		"[-m <ffu_mode>] Optional, provides five firmware bundle download command modes:\n"
+		" -m 1: Default mode, utilizing the CMD6+CMD23+CMD25+CMD6 command sequence. This \n"
+		" may exit FFU mode during firmware bundle downloading if FW size exceeds the chunk size. \n",
 	  NULL
 	},
 	{ do_erase, -4,
diff --git a/mmc_cmds.c b/mmc_cmds.c
index 3b1bcf4..22ab7d9 100644
--- a/mmc_cmds.c
+++ b/mmc_cmds.c
@@ -58,41 +58,6 @@ 
 #define WPTYPE_PWRON 2
 #define WPTYPE_PERM 3
 
-static inline __u32 per_byte_htole32(__u8 *arr)
-{
-	return arr[0] | arr[1] << 8 | arr[2] << 16 | arr[3] << 24;
-}
-
-static int read_extcsd(int fd, __u8 *ext_csd)
-{
-	int ret = 0;
-	struct mmc_ioc_cmd idata;
-	memset(&idata, 0, sizeof(idata));
-	memset(ext_csd, 0, sizeof(__u8) * 512);
-	idata.write_flag = 0;
-	idata.opcode = MMC_SEND_EXT_CSD;
-	idata.arg = 0;
-	idata.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;
-	idata.blksz = 512;
-	idata.blocks = 1;
-	mmc_ioc_cmd_set_data(idata, ext_csd);
-
-	ret = ioctl(fd, MMC_IOC_CMD, &idata);
-	if (ret)
-		perror("ioctl");
-
-	return ret;
-}
-
-static void fill_switch_cmd(struct mmc_ioc_cmd *cmd, __u8 index, __u8 value)
-{
-	cmd->opcode = MMC_SWITCH;
-	cmd->write_flag = 1;
-	cmd->arg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) | (index << 16) |
-		   (value << 8) | EXT_CSD_CMD_SET_NORMAL;
-	cmd->flags = MMC_RSP_SPI_R1B | MMC_RSP_R1B | MMC_CMD_AC;
-}
-
 static int
 write_extcsd_value(int fd, __u8 index, __u8 value, unsigned int timeout_ms)
 {
@@ -2101,18 +2066,6 @@  struct rpmb_frame {
 	u_int16_t req_resp;
 };
 
-static inline void set_single_cmd(struct mmc_ioc_cmd *ioc, __u32 opcode,
-				  int write_flag, unsigned int blocks,
-				  __u32 arg)
-{
-	ioc->opcode = opcode;
-	ioc->write_flag = write_flag;
-	ioc->arg = arg;
-	ioc->blksz = 512;
-	ioc->blocks = blocks;
-	ioc->flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;
-}
-
 /* Performs RPMB operation.
  *
  * @fd: RPMB device on which we should perform ioctl command
@@ -2810,233 +2763,6 @@  out:
 	return ret;
 }
 
-static void set_ffu_single_cmd(struct mmc_ioc_multi_cmd *multi_cmd,
-			       __u8 *ext_csd, unsigned int bytes, __u8 *buf,
-			       off_t offset)
-{
-	__u32 arg = per_byte_htole32(&ext_csd[EXT_CSD_FFU_ARG_0]);
-
-	/* send block count */
-	set_single_cmd(&multi_cmd->cmds[1], MMC_SET_BLOCK_COUNT, 0, 0,
-		       bytes / 512);
-	multi_cmd->cmds[1].flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
-
-	/*
-	 * send image chunk: blksz and blocks essentially do not matter, as
-	 * long as the product is fw_size, but some hosts don't handle larger
-	 * blksz well.
-	 */
-	set_single_cmd(&multi_cmd->cmds[2], MMC_WRITE_MULTIPLE_BLOCK, 1,
-		       bytes / 512, arg);
-	mmc_ioc_cmd_set_data(multi_cmd->cmds[2], buf + offset);
-}
-
-int do_ffu(int nargs, char **argv)
-{
-	int dev_fd, img_fd;
-	int retry = 3, ret = -EINVAL;
-	unsigned int sect_size;
-	__u8 ext_csd[512];
-	__u8 *buf = NULL;
-	off_t fw_size, bytes_left, off;
-	char *device;
-	struct mmc_ioc_multi_cmd *multi_cmd = NULL;
-	unsigned int default_chunk = MMC_IOC_MAX_BYTES;
-	__u32 sect_done = 0;
-
-	assert (nargs == 3 || nargs == 4);
-
-	device = argv[2];
-	dev_fd = open(device, O_RDWR);
-	if (dev_fd < 0) {
-		perror("device open failed");
-		exit(1);
-	}
-	img_fd = open(argv[1], O_RDONLY);
-	if (img_fd < 0) {
-		perror("image open failed");
-		close(dev_fd);
-		exit(1);
-	}
-
-	ret = read_extcsd(dev_fd, ext_csd);
-	if (ret) {
-		fprintf(stderr, "Could not read EXT_CSD from %s\n", device);
-		goto out;
-	}
-
-	if (ext_csd[EXT_CSD_REV] < EXT_CSD_REV_V5_0) {
-		fprintf(stderr,
-			"The FFU feature is only available on devices >= "
-			"MMC 5.0, not supported in %s\n", device);
-		goto out;
-	}
-
-	if (!(ext_csd[EXT_CSD_SUPPORTED_MODES] & EXT_CSD_FFU)) {
-		fprintf(stderr, "FFU is not supported in %s\n", device);
-		goto out;
-	}
-
-	if (ext_csd[EXT_CSD_FW_CONFIG] & EXT_CSD_UPDATE_DISABLE) {
-		fprintf(stderr, "Firmware update was disabled in %s\n", device);
-		goto out;
-	}
-
-	fw_size = lseek(img_fd, 0, SEEK_END);
-	if (fw_size == 0) {
-		fprintf(stderr, "Wrong firmware size");
-		goto out;
-	}
-
-	/* allocate maximum required */
-	buf = malloc(fw_size);
-	multi_cmd = calloc(1, sizeof(struct mmc_ioc_multi_cmd) +
-				4 * sizeof(struct mmc_ioc_cmd));
-	if (!buf || !multi_cmd) {
-		perror("failed to allocate memory");
-		goto out;
-	}
-
-	/* ensure fw is multiple of native sector size */
-	sect_size = (ext_csd[EXT_CSD_DATA_SECTOR_SIZE] == 0) ? 512 : 4096;
-	if (fw_size % sect_size) {
-		fprintf(stderr, "Firmware data size (%jd) is not aligned!\n", (intmax_t)fw_size);
-		goto out;
-	}
-
-	if (nargs == 4) {
-		default_chunk = strtol(argv[3], NULL, 10);
-		if (default_chunk > MMC_IOC_MAX_BYTES || default_chunk % 512) {
-			fprintf(stderr, "Invalid chunk size");
-			goto out;
-		}
-	}
-
-	/* prepare multi_cmd for FFU based on cmd to be used */
-
-	multi_cmd->num_of_cmds = 4;
-
-	/* put device into ffu mode */
-	fill_switch_cmd(&multi_cmd->cmds[0], EXT_CSD_MODE_CONFIG,
-			EXT_CSD_FFU_MODE);
-
-	/* return device into normal mode */
-	fill_switch_cmd(&multi_cmd->cmds[3], EXT_CSD_MODE_CONFIG,
-			EXT_CSD_NORMAL_MODE);
-
-	/* read firmware */
-	lseek(img_fd, 0, SEEK_SET);
-	if (read(img_fd, buf, fw_size) != fw_size) {
-		perror("Could not read the firmware file: ");
-		ret = -ENOSPC;
-		goto out;
-	}
-
-do_retry:
-	bytes_left = fw_size;
-	off = 0;
-	while (bytes_left) {
-		unsigned int chunk_size = bytes_left < default_chunk ?
-					  bytes_left : default_chunk;
-
-		/* prepare multi_cmd for FFU based on cmd to be used */
-		set_ffu_single_cmd(multi_cmd, ext_csd, chunk_size, buf, off);
-
-		/* send ioctl with multi-cmd */
-		ret = ioctl(dev_fd, MMC_IOC_MULTI_CMD, multi_cmd);
-
-		if (ret) {
-			perror("Multi-cmd ioctl");
-			/*
-			 * In case multi-cmd ioctl failed before exiting from
-			 * ffu mode
-			 */
-			ioctl(dev_fd, MMC_IOC_CMD, &multi_cmd->cmds[3]);
-			goto out;
-		}
-
-		bytes_left -= chunk_size;
-		off += chunk_size;
-	}
-
-	/*
-	 * By spec - check if mode operation codes are supported in ffu features,
-	 * if not then skip checking number of sectors programmed after install
-	 */
-	if (!ext_csd[EXT_CSD_FFU_FEATURES]) {
-		fprintf(stderr, "Please reboot to complete firmware installation on %s\n", device);
-		ret = 0;
-		goto out;
-	}
-
-	ret = read_extcsd(dev_fd, ext_csd);
-	if (ret) {
-		fprintf(stderr, "Could not read EXT_CSD from %s\n", device);
-		goto out;
-	}
-
-	/* Test if we need to restart the download */
-	sect_done = per_byte_htole32(&ext_csd[EXT_CSD_NUM_OF_FW_SEC_PROG_0]);
-	/* By spec, host should re-start download from the first sector if sect_done is 0 */
-	if (sect_done == 0) {
-		if (retry--) {
-			fprintf(stderr, "Programming failed. Retrying... (%d)\n", retry);
-			goto do_retry;
-		}
-		fprintf(stderr, "Programming failed! Aborting...\n");
-		goto out;
-	}
-
-	if ((sect_done * sect_size) == fw_size) {
-		fprintf(stderr, "Programmed %jd/%jd bytes\n", (intmax_t)fw_size, (intmax_t)fw_size);
-		fprintf(stderr, "Programming finished with status %d \n", ret);
-	}
-	else {
-		fprintf(stderr, "FW size and number of sectors written mismatch. Status return %d\n", ret);
-		goto out;
-	}
-
-	fprintf(stderr, "Installing firmware on %s...\n", device);
-	/* Re-enter ffu mode and install the firmware */
-	multi_cmd->num_of_cmds = 2;
-
-	/* set ext_csd to install mode */
-	fill_switch_cmd(&multi_cmd->cmds[1], EXT_CSD_MODE_OPERATION_CODES,
-			EXT_CSD_FFU_INSTALL);
-
-	/* send ioctl with multi-cmd */
-	ret = ioctl(dev_fd, MMC_IOC_MULTI_CMD, multi_cmd);
-
-	if (ret) {
-		perror("Multi-cmd ioctl failed setting install mode");
-		/* In case multi-cmd ioctl failed before exiting from ffu mode */
-		ioctl(dev_fd, MMC_IOC_CMD, &multi_cmd->cmds[3]);
-		goto out;
-	}
-
-	ret = read_extcsd(dev_fd, ext_csd);
-	if (ret) {
-		fprintf(stderr, "Could not read EXT_CSD from %s\n", device);
-		goto out;
-	}
-
-	/* return status */
-	ret = ext_csd[EXT_CSD_FFU_STATUS];
-	if (ret) {
-		fprintf(stderr, "%s: error %d during FFU install:\n", device, ret);
-		goto out;
-	} else {
-		fprintf(stderr, "FFU finished successfully\n");
-	}
-
-out:
-	free(buf);
-	free(multi_cmd);
-	close(img_fd);
-	close(dev_fd);
-	return ret;
-}
-
 int do_general_cmd_read(int nargs, char **argv)
 {
 	int dev_fd;
diff --git a/mmc_cmds.h b/mmc_cmds.h
index 5f2bef1..40a137d 100644
--- a/mmc_cmds.h
+++ b/mmc_cmds.h
@@ -16,6 +16,57 @@ 
  * Modified to add field firmware update support,
  * those modifications are Copyright (c) 2016 SanDisk Corp.
  */
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <string.h>
+#include "mmc.h"
+
+static inline __u32 per_byte_htole32(__u8 *arr)
+{
+	return arr[0] | arr[1] << 8 | arr[2] << 16 | arr[3] << 24;
+}
+
+
+static inline int read_extcsd(int fd, __u8 *ext_csd)
+{
+	int ret = 0;
+	struct mmc_ioc_cmd idata;
+	memset(&idata, 0, sizeof(idata));
+	memset(ext_csd, 0, sizeof(__u8) * 512);
+	idata.write_flag = 0;
+	idata.opcode = MMC_SEND_EXT_CSD;
+	idata.arg = 0;
+	idata.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;
+	idata.blksz = 512;
+	idata.blocks = 1;
+	mmc_ioc_cmd_set_data(idata, ext_csd);
+
+	ret = ioctl(fd, MMC_IOC_CMD, &idata);
+	if (ret)
+		perror("ioctl");
+
+	return ret;
+}
+
+static inline void fill_switch_cmd(struct mmc_ioc_cmd *cmd, __u8 index, __u8 value)
+{
+	cmd->opcode = MMC_SWITCH;
+	cmd->write_flag = 1;
+	cmd->arg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) | (index << 16) |
+		   (value << 8) | EXT_CSD_CMD_SET_NORMAL;
+	cmd->flags = MMC_RSP_SPI_R1B | MMC_RSP_R1B | MMC_CMD_AC;
+}
+
+static inline void set_single_cmd(struct mmc_ioc_cmd *ioc, __u32 opcode, int write_flag,
+						unsigned int blocks, __u32 arg)
+{
+	ioc->opcode = opcode;
+	ioc->write_flag = write_flag;
+	ioc->arg = arg;
+	ioc->blksz = 512;
+	ioc->blocks = blocks;
+	ioc->flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;
+}
 
 /* mmc_cmds.c */
 int do_read_extcsd(int nargs, char **argv);
@@ -50,3 +101,4 @@  int do_general_cmd_read(int nargs, char **argv);
 int do_softreset(int nargs, char **argv);
 int do_preidle(int nargs, char **argv);
 int do_alt_boot_op(int nargs, char **argv);
+int do_ffu(int nargs, char **argv);
diff --git a/mmc_ffu.c b/mmc_ffu.c
new file mode 100644
index 0000000..5f7cb00
--- /dev/null
+++ b/mmc_ffu.c
@@ -0,0 +1,324 @@ 
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Modified and add more FFU modes.
+ * And changed and updated by: Bean Huo <beanhuo@micron.com>
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <ctype.h>
+#include <errno.h>
+#include <stdbool.h>
+#include <assert.h>
+#include <unistd.h>
+
+#include "mmc.h"
+#include "mmc_cmds.h"
+
+static int do_ffu_download(int *dev_fd, __u8 *ext_csd, __u8 *fw_buf, off_t fw_size, unsigned int chunk_size);
+
+static void set_ffu_download_cmd(struct mmc_ioc_multi_cmd *multi_cmd, __u8 *ext_csd,
+				unsigned int bytes, __u8 *buf, off_t offset)
+{
+	__u32 arg = per_byte_htole32(&ext_csd[EXT_CSD_FFU_ARG_0]);
+
+	/* send block count */
+	set_single_cmd(&multi_cmd->cmds[1], MMC_SET_BLOCK_COUNT, 0, 0, bytes / 512);
+	multi_cmd->cmds[1].flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
+
+	/*
+	 * send image chunk: blksz and blocks essentially do not matter, as
+	 * long as the product is fw_size, but some hosts don't handle larger
+	 * blksz well.
+	 */
+	set_single_cmd(&multi_cmd->cmds[2], MMC_WRITE_MULTIPLE_BLOCK, 1, bytes / 512, arg);
+	mmc_ioc_cmd_set_data(multi_cmd->cmds[2], buf + offset);
+}
+
+static int get_ffu_sectors_programmed(int *dev_fd, __u8 *ext_csd)
+{
+	int ret;
+
+	ret = read_extcsd(*dev_fd, ext_csd);
+	if (ret) {
+		fprintf(stderr, "Could not read EXT_CSD\n");
+		return ret;
+	}
+
+	ret = per_byte_htole32((__u8 *)&ext_csd[EXT_CSD_NUM_OF_FW_SEC_PROG_0]);
+
+	return ret;
+}
+
+static bool ffu_is_supported(__u8 *ext_csd, char *device)
+{
+	if (ext_csd == NULL) {
+		fprintf(stderr, "ext_cst is NULL\n");
+		return false;
+	}
+
+	if (ext_csd[EXT_CSD_REV] < EXT_CSD_REV_V5_0) {
+		fprintf(stderr, "The FFU feature is only available on devices >= "
+			"MMC 5.0, not supported in %s\n", device);
+		return false;
+	}
+
+	if (!(ext_csd[EXT_CSD_SUPPORTED_MODES] & EXT_CSD_FFU)) {
+		fprintf(stderr, "FFU is not supported in %s\n", device);
+		return false;
+	}
+
+	if (ext_csd[EXT_CSD_FW_CONFIG] & EXT_CSD_UPDATE_DISABLE) {
+		fprintf(stderr, "Firmware update was disabled in %s\n", device);
+		return false;
+	}
+
+	return true;
+}
+
+static int do_ffu_download(int *dev_fd, __u8 *ext_csd, __u8 *fw_buf, off_t fw_size,
+							unsigned int chunk_size)
+{
+	int ret;
+	__u8 num_of_cmds = 4;
+	off_t bytes_left, off;
+	unsigned int bytes_per_loop, sect_done, retry = 3;
+	struct mmc_ioc_multi_cmd *multi_cmd = NULL;
+
+	if (!dev_fd || !fw_buf || !ext_csd) {
+		fprintf(stderr, "unexpected NULL pointer\n");
+		return -EINVAL;
+	}
+	/* allocate maximum required */
+	multi_cmd = calloc(1, sizeof(struct mmc_ioc_multi_cmd) + num_of_cmds * sizeof(struct mmc_ioc_cmd));
+	if (!multi_cmd) {
+		perror("failed to allocate memory");
+		return -ENOMEM;
+	}
+
+	/* prepare multi_cmd for FFU based on cmd to be used */
+	/* put device into ffu mode */
+	fill_switch_cmd(&multi_cmd->cmds[0], EXT_CSD_MODE_CONFIG, EXT_CSD_FFU_MODE);
+
+	/* return device into normal mode */
+	fill_switch_cmd(&multi_cmd->cmds[3], EXT_CSD_MODE_CONFIG, EXT_CSD_NORMAL_MODE);
+
+do_retry:
+	bytes_left = fw_size;
+	off = 0;
+	multi_cmd->num_of_cmds = num_of_cmds;
+
+	while (bytes_left) {
+		bytes_per_loop = bytes_left < chunk_size ? bytes_left : chunk_size;
+
+		/* prepare multi_cmd for FFU based on cmd to be used */
+		set_ffu_download_cmd(multi_cmd, ext_csd, bytes_per_loop, fw_buf, off);
+
+		/* send ioctl with multi-cmd, download firmware bundle */
+		ret = ioctl(*dev_fd, MMC_IOC_MULTI_CMD, multi_cmd);
+
+		if (ret) {
+			perror("Multi-cmd ioctl");
+			/*
+			 * In case multi-cmd ioctl failed before exiting from
+			 * ffu mode
+			 */
+			ioctl(*dev_fd, MMC_IOC_CMD, &multi_cmd->cmds[3]);
+			goto out;
+		}
+
+		sect_done = get_ffu_sectors_programmed(dev_fd, ext_csd);
+		if (sect_done <= 0) {
+			/* By spec, host should re-start download from the first sector if sect_done is 0 */
+			ioctl(*dev_fd, MMC_IOC_CMD, &multi_cmd->cmds[3]);
+			if (retry > 0) {
+				retry--;
+				fprintf(stderr, "Programming failed. Retrying... (%d)\n", retry);
+				goto do_retry;
+			}
+			fprintf(stderr, "Programming failed! Aborting...\n");
+			ret = sect_done;
+			goto out;
+		} else {
+			fprintf(stderr, "Programmed %d/%jd bytes\r", sect_done * 512, (intmax_t)fw_size);
+		}
+
+		bytes_left -= bytes_per_loop;
+		off += bytes_per_loop;
+	}
+
+	ret = get_ffu_sectors_programmed(dev_fd, ext_csd);
+out:
+	free(multi_cmd);
+	return ret;
+
+}
+
+int do_ffu(int nargs, char **argv)
+{
+	int opt;
+	int dev_fd, img_fd;
+	int ret = -EINVAL;
+	unsigned int sect_size;
+	__u8 ext_csd[512];
+	__u8 *fw_buf = NULL;
+	off_t fw_size;
+	char *device, *fw_img;
+	struct mmc_ioc_multi_cmd *multi_cmd = NULL;
+	unsigned int default_chunk = MMC_IOC_MAX_BYTES;
+	int sect_done = 0;
+	__u8 ffu_mode = 1;
+
+	assert(nargs >= 4);
+
+	while ((opt = getopt(nargs, argv, "i:p:m:c:")) != -1) {
+		switch (opt) {
+		case 'i':
+			fw_img = optarg;
+			break;
+		case 'p':
+			device = optarg;
+			break;
+		case 'c':
+			default_chunk = atoi(optarg);
+			if (default_chunk > MMC_IOC_MAX_BYTES || default_chunk % 512) {
+				fprintf(stderr, "Invalid chunk size");
+				exit(1);
+			}
+			break;
+		case 'm':
+			ffu_mode = atoi(optarg);
+			if (ffu_mode > 1) {
+				fprintf(stderr, "Unsupported ffu mode `%d'.\n", ffu_mode);
+				abort();
+			}
+			break;
+		default:
+			/* Unknown option or missing argument for options */
+			if (isprint(optopt))
+				fprintf(stderr, "Unknown option `-%c'.\n", optopt);
+			else
+				fprintf(stderr, "Unknown option character `\\x%x'.\n", optopt);
+			abort();
+		}
+	}
+	fprintf(stderr, "eMMC Devie: %s, fw %s, FFU mode %d, chunk size: %d\n",
+							device, fw_img, ffu_mode, default_chunk);
+	dev_fd = open(device, O_RDWR);
+	if (dev_fd < 0) {
+		perror("device open failed");
+		exit(1);
+	}
+	img_fd = open(fw_img, O_RDONLY);
+	if (img_fd < 0) {
+		perror("image open failed");
+		close(dev_fd);
+		exit(1);
+	}
+
+	ret = read_extcsd(dev_fd, ext_csd);
+	if (ret) {
+		fprintf(stderr, "Could not read EXT_CSD from %s\n", device);
+		goto out;
+	}
+	if (ffu_is_supported(ext_csd, device) <= 0)
+		goto out;
+
+	fw_size = lseek(img_fd, 0, SEEK_END);
+	if (fw_size == 0) {
+		fprintf(stderr, "Wrong firmware size");
+		goto out;
+	}
+	/* ensure fw is multiple of native sector size */
+	sect_size = (ext_csd[EXT_CSD_DATA_SECTOR_SIZE] == 0) ? 512 : 4096;
+	if (fw_size % sect_size) {
+		fprintf(stderr, "Firmware data size (%jd) is not aligned!\n", (intmax_t)fw_size);
+		goto out;
+	}
+	/* allocate maximum required */
+	fw_buf = malloc(fw_size);
+	if (!fw_buf) {
+		perror("failed to allocate memory");
+		goto out;
+	}
+	/* read firmware */
+	lseek(img_fd, 0, SEEK_SET);
+	if (read(img_fd, fw_buf, fw_size) != fw_size) {
+		perror("Could not read the firmware file: ");
+		ret = -ENOSPC;
+		goto out;
+	}
+
+	sect_done = do_ffu_download((int *)&dev_fd, ext_csd, fw_buf, fw_size, default_chunk);
+
+	/* Check programmed sectors */
+	if (sect_done > 0 && (sect_done * 512) == fw_size) {
+		fprintf(stderr, "Programmed %jd/%jd bytes\n", (intmax_t)fw_size, (intmax_t)fw_size);
+		fprintf(stderr, "Programming finished with status %d \n", ret);
+	} else {
+		fprintf(stderr, "Firmware bundle download failed. Operation status %d\n", sect_done);
+		ret = -EIO;
+		goto out;
+	}
+	/*
+	 * By spec - check if mode operation codes are supported in ffu features,
+	 * if not then skip checking number of sectors programmed after install
+	 */
+	if (!ext_csd[EXT_CSD_FFU_FEATURES]) {
+		fprintf(stderr, "Please reboot to complete firmware installation on %s\n", device);
+		ret = 0;
+		goto out;
+	}
+
+	fprintf(stderr, "Installing firmware on %s...\n", device);
+	multi_cmd = calloc(1, sizeof(struct mmc_ioc_multi_cmd) + 2 * sizeof(struct mmc_ioc_cmd));
+	if (!multi_cmd) {
+		perror("failed to allocate memory");
+		ret = -ENOMEM;
+		goto out;
+	}
+
+	/* Re-enter ffu mode and install the firmware */
+	multi_cmd->num_of_cmds = 2;
+	/* put device into ffu mode */
+	fill_switch_cmd(&multi_cmd->cmds[0], EXT_CSD_MODE_CONFIG, EXT_CSD_FFU_MODE);
+	/* Re-enter ffu mode and set ext_csd to install mode */
+	fill_switch_cmd(&multi_cmd->cmds[1], EXT_CSD_MODE_OPERATION_CODES, EXT_CSD_FFU_INSTALL);
+
+	/* send ioctl with multi-cmd */
+	ret = ioctl(dev_fd, MMC_IOC_MULTI_CMD, multi_cmd);
+
+	if (ret) {
+		perror("Multi-cmd ioctl failed setting install mode");
+		fill_switch_cmd(&multi_cmd->cmds[1], EXT_CSD_MODE_CONFIG, EXT_CSD_NORMAL_MODE);
+		/* In case multi-cmd ioctl failed before exiting from ffu mode */
+		ioctl(dev_fd, MMC_IOC_CMD, &multi_cmd->cmds[1]);
+		goto out;
+	}
+
+	ret = read_extcsd(dev_fd, ext_csd);
+	if (ret) {
+		fprintf(stderr, "Could not read EXT_CSD from %s\n", device);
+		goto out;
+	}
+
+	/* return status */
+	ret = ext_csd[EXT_CSD_FFU_STATUS];
+	if (ret)
+		fprintf(stderr, "%s: error %d during FFU install:\n", device, ret);
+	else
+		fprintf(stderr, "FFU finished successfully\n");
+
+out:
+	if (fw_buf)
+		free(fw_buf);
+	if (multi_cmd)
+		free(multi_cmd);
+	close(img_fd);
+	close(dev_fd);
+	return ret;
+}