>
> From: Bean Huo <beanhuo@xxxxxxxxxx>
>
> 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@xxxxxxxxxx>
> ---
> 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@xxxxxxxxxx>
> + */
> +
> +#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
>
