Mirrors/u-boot
1
0
Fork 0
mirror of https://source.denx.de/u-boot/u-boot.git synced 2026-06-13 15:03:58 +03:00
Code Issues Packages Projects Releases Wiki Activity

fastboot: blk: switch emmc to use the block helpers

Browse Source 
Switch the mmc backend to this new shared block helpers,
reducing block logic and only leaving MMC specific logic.

Signed-off-by: Dmitrii Merkurev <dimorinny@google.com>
Reviewed-by: Mattijs Korpershoek <mkorpershoek@kernel.org>
Tested-by: Mattijs Korpershoek <mkorpershoek@kernel.org>
Signed-off-by: Neil Armstrong <neil.armstrong@linaro.org>
Link: https://lore.kernel.org/r/20251121-topic-fastboot-blk-v7-2-9589d902fc91@linaro.org
Signed-off-by: Mattijs Korpershoek <mkorpershoek@kernel.org>
This commit is contained in:
Dmitrii Merkurev
2025-11-21 11:53:32 +01:00
committed by Mattijs Korpershoek
parent 4bf92b541a
commit b63e85705d
2 changed files with 14 additions and 199 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
drivers/fastboot/Makefile
View File

@@ -3,6 +3,7 @@
obj-y += fb_common.o
obj-y += fb_getvar.o
obj-y += fb_command.o
obj-$(CONFIG_FASTBOOT_FLASH_MMC) += fb_mmc.o
# MMC reuses block implementation
obj-$(CONFIG_FASTBOOT_FLASH_MMC) += fb_block.o fb_mmc.o
obj-$(CONFIG_FASTBOOT_FLASH_NAND) += fb_nand.o
obj-$(CONFIG_FASTBOOT_FLASH_SPI) += fb_spi_flash.o

210
drivers/fastboot/fb_mmc.c
View File

@@ -8,6 +8,7 @@
#include <env.h>
#include <fastboot.h>
#include <fastboot-internal.h>
#include <fb_block.h>
#include <fb_mmc.h>
#include <image-sparse.h>
#include <image.h>
@@ -20,10 +21,6 @@
#define BOOT_PARTITION_NAME "boot"
struct fb_mmc_sparse {
struct blk_desc *dev_desc;
};
static int raw_part_get_info_by_name(struct blk_desc *dev_desc,
const char *name,
struct disk_partition *info)
@@ -114,118 +111,10 @@ static int part_get_info_by_name_or_alias(struct blk_desc **dev_desc,
return do_get_part_info(dev_desc, name, info);
}
/**
* fb_mmc_blk_write() - Write/erase MMC in chunks of FASTBOOT_MAX_BLK_WRITE
*
* @block_dev: Pointer to block device
* @start: First block to write/erase
* @blkcnt: Count of blocks
* @buffer: Pointer to data buffer for write or NULL for erase
*/
static lbaint_t fb_mmc_blk_write(struct blk_desc *block_dev, lbaint_t start,
lbaint_t blkcnt, const void *buffer)
{
lbaint_t blk = start;
lbaint_t blks_written;
lbaint_t cur_blkcnt;
lbaint_t blks = 0;
int i;
for (i = 0; i < blkcnt; i += FASTBOOT_MAX_BLK_WRITE) {
cur_blkcnt = min((int)blkcnt - i, FASTBOOT_MAX_BLK_WRITE);
if (buffer) {
if (fastboot_progress_callback)
fastboot_progress_callback("writing");
blks_written = blk_dwrite(block_dev, blk, cur_blkcnt,
buffer + (i * block_dev->blksz));
} else {
if (fastboot_progress_callback)
fastboot_progress_callback("erasing");
blks_written = blk_derase(block_dev, blk, cur_blkcnt);
}
blk += blks_written;
blks += blks_written;
}
return blks;
}
static lbaint_t fb_mmc_sparse_write(struct sparse_storage *info,
lbaint_t blk, lbaint_t blkcnt, const void *buffer)
{
struct fb_mmc_sparse *sparse = info->priv;
struct blk_desc *dev_desc = sparse->dev_desc;
return fb_mmc_blk_write(dev_desc, blk, blkcnt, buffer);
}
static lbaint_t fb_mmc_sparse_reserve(struct sparse_storage *info,
lbaint_t blk, lbaint_t blkcnt)
{
return blkcnt;
}
static void write_raw_image(struct blk_desc *dev_desc,
struct disk_partition *info, const char *part_name,
void *buffer, u32 download_bytes, char *response)
{
lbaint_t blkcnt;
lbaint_t blks;
/* determine number of blocks to write */
blkcnt = ((download_bytes + (info->blksz - 1)) & ~(info->blksz - 1));
blkcnt = lldiv(blkcnt, info->blksz);
if (blkcnt > info->size) {
pr_err("too large for partition: '%s'\n", part_name);
fastboot_fail("too large for partition", response);
return;
}
puts("Flashing Raw Image\n");
blks = fb_mmc_blk_write(dev_desc, info->start, blkcnt, buffer);
if (blks != blkcnt) {
pr_err("failed writing to device %d\n", dev_desc->devnum);
fastboot_fail("failed writing to device", response);
return;
}
printf("........ wrote " LBAFU " bytes to '%s'\n", blkcnt * info->blksz,
part_name);
fastboot_okay(NULL, response);
}
#if defined(CONFIG_FASTBOOT_MMC_BOOT_SUPPORT) || \
defined(CONFIG_FASTBOOT_MMC_USER_SUPPORT)
static int fb_mmc_erase_mmc_hwpart(struct blk_desc *dev_desc)
{
lbaint_t blks;
debug("Start Erasing mmc hwpart[%u]...\n", dev_desc->hwpart);
blks = fb_mmc_blk_write(dev_desc, 0, dev_desc->lba, NULL);
if (blks != dev_desc->lba) {
pr_err("Failed to erase mmc hwpart[%u]\n", dev_desc->hwpart);
return 1;
}
printf("........ erased %llu bytes from mmc hwpart[%u]\n",
(u64)(dev_desc->lba * dev_desc->blksz), dev_desc->hwpart);
return 0;
}
#endif
#ifdef CONFIG_FASTBOOT_MMC_BOOT_SUPPORT
static void fb_mmc_boot_ops(struct blk_desc *dev_desc, void *buffer,
int hwpart, u32 buff_sz, char *response)
{
lbaint_t blkcnt;
lbaint_t blks;
unsigned long blksz;
// To operate on EMMC_BOOT1/2 (mmc0boot0/1) we first change the hwpart
if (blk_dselect_hwpart(dev_desc, hwpart)) {
pr_err("Failed to select hwpart\n");
@@ -233,42 +122,11 @@ static void fb_mmc_boot_ops(struct blk_desc *dev_desc, void *buffer,
return;
}
if (buffer) { /* flash */
/* determine number of blocks to write */
blksz = dev_desc->blksz;
blkcnt = ((buff_sz + (blksz - 1)) & ~(blksz - 1));
blkcnt = lldiv(blkcnt, blksz);
if (blkcnt > dev_desc->lba) {
pr_err("Image size too large\n");
fastboot_fail("Image size too large", response);
return;
}
debug("Start Flashing Image to EMMC_BOOT%d...\n", hwpart);
blks = fb_mmc_blk_write(dev_desc, 0, blkcnt, buffer);
if (blks != blkcnt) {
pr_err("Failed to write EMMC_BOOT%d\n", hwpart);
fastboot_fail("Failed to write EMMC_BOOT part",
response);
return;
}
printf("........ wrote %llu bytes to EMMC_BOOT%d\n",
(u64)(blkcnt * blksz), hwpart);
} else { /* erase */
if (fb_mmc_erase_mmc_hwpart(dev_desc)) {
pr_err("Failed to erase EMMC_BOOT%d\n", hwpart);
fastboot_fail("Failed to erase EMMC_BOOT part",
response);
return;
}
}
fastboot_okay(NULL, response);
if (buffer) /* flash */
fastboot_block_write_raw_disk(dev_desc, "EMMC_BOOT",
buffer, buff_sz, response);
else /* erase */
fastboot_block_raw_erase_disk(dev_desc, "EMMC_BOOT", response);
}
#endif
@@ -609,30 +467,11 @@ void fastboot_mmc_flash_write(const char *cmd, void *download_buffer,
return;
if (is_sparse_image(download_buffer)) {
struct fb_mmc_sparse sparse_priv;
struct sparse_storage sparse;
int err;
sparse_priv.dev_desc = dev_desc;
sparse.blksz = info.blksz;
sparse.start = info.start;
sparse.size = info.size;
sparse.write = fb_mmc_sparse_write;
sparse.reserve = fb_mmc_sparse_reserve;
sparse.mssg = fastboot_fail;
printf("Flashing sparse image at offset " LBAFU "\n",
sparse.start);
sparse.priv = &sparse_priv;
err = write_sparse_image(&sparse, cmd, download_buffer,
response);
if (!err)
fastboot_okay(NULL, response);
fastboot_block_write_sparse_image(dev_desc, &info, cmd,
download_buffer, response);
} else {
write_raw_image(dev_desc, &info, cmd, download_buffer,
download_bytes, response);
fastboot_block_write_raw_image(dev_desc, &info, cmd, download_buffer,
download_bytes, response);
}
}
@@ -646,7 +485,6 @@ void fastboot_mmc_erase(const char *cmd, char *response)
{
struct blk_desc *dev_desc;
struct disk_partition info;
lbaint_t blks, blks_start, blks_size, grp_size;
struct mmc *mmc = find_mmc_device(CONFIG_FASTBOOT_FLASH_MMC_DEV);
#ifdef CONFIG_FASTBOOT_MMC_BOOT_SUPPORT
@@ -673,10 +511,7 @@ void fastboot_mmc_erase(const char *cmd, char *response)
if (!dev_desc)
return;
if (fb_mmc_erase_mmc_hwpart(dev_desc))
fastboot_fail("Failed to erase EMMC_USER", response);
else
fastboot_okay(NULL, response);
fastboot_block_raw_erase_disk(dev_desc, "EMMC_USER", response);
return;
}
#endif
@@ -685,26 +520,5 @@ void fastboot_mmc_erase(const char *cmd, char *response)
return;
/* Align blocks to erase group size to avoid erasing other partitions */
grp_size = mmc->erase_grp_size;
blks_start = (info.start + grp_size - 1) & ~(grp_size - 1);
if (info.size >= grp_size)
blks_size = (info.size - (blks_start - info.start)) &
(~(grp_size - 1));
else
blks_size = 0;
printf("Erasing blocks " LBAFU " to " LBAFU " due to alignment\n",
blks_start, blks_start + blks_size);
blks = fb_mmc_blk_write(dev_desc, blks_start, blks_size, NULL);
if (blks != blks_size) {
pr_err("failed erasing from device %d\n", dev_desc->devnum);
fastboot_fail("failed erasing from device", response);
return;
}
printf("........ erased " LBAFU " bytes from '%s'\n",
blks_size * info.blksz, cmd);
fastboot_okay(NULL, response);
fastboot_block_raw_erase(dev_desc, &info, cmd, mmc->erase_grp_size, response);
}